feat: orchestrator test harness

Author: indietyp

Cargo.lock

@@ -39,6 +39,10 @@ pub enum Function {
     /// values unchanged; wraps text, uuid, integer, boolean, etc. as jsonb
     /// scalars.
     ToJson(Box<Expression>),
+    /// Returns the first non-NULL argument.
+    ///
+    /// Transpiles to `COALESCE(expr, fallback)`.
+    Coalesce(Box<Expression>, Box<Expression>),
     Lower(Box<Expression>),
     Upper(Box<Expression>),
     LowerInc(Box<Expression>),
@@ -137,6 +141,13 @@ impl Transpile for Function {
                 expression.transpile(fmt)?;
                 fmt.write_char(')')
             }
+            Self::Coalesce(expression, fallback) => {
+                fmt.write_str("COALESCE(")?;
+                expression.transpile(fmt)?;
+                fmt.write_str(", ")?;
+                fallback.transpile(fmt)?;
+                fmt.write_char(')')
+            }
             Self::Lower(expression) => {
                 fmt.write_str("lower(")?;
                 expression.transpile(fmt)?;
@@ -602,6 +613,11 @@ impl Expression {
         Self::Grouped(Box::new(self))
     }
 
+    #[must_use]
+    pub fn coalesce(self, fallback: Self) -> Self {
+        Self::Function(Function::Coalesce(Box::new(self), Box::new(fallback)))
+    }
+
     #[must_use]
     pub fn starts_with(lhs: Self, rhs: Self) -> Self {
         Self::StartsWith(Box::new(lhs), Box::new(rhs))

libs/@local/graph/postgres-store/src/store/postgres/query/expression/conditional.rs

@@ -5,22 +5,22 @@
 | ID  | Name                                    | Status | File |
 | --- | --------------------------------------- | ------ | ---- |
 | 1.1 | Simple entity read, no filter           | done   | `jsonc/simple-read.jsonc` |
-| 1.2 | Property access                         | skip   | needs MIR builder (properties are un-narrowed `?`) |
-| 1.3 | Individual metadata leaf fields         | skip   | needs MIR builder (metadata behind `List`/`Option`) |
+| 1.2 | Property access                         | done   | `programmatic/property-access` + `programmatic/property-arithmetic` |
+| 1.3 | Individual metadata leaf fields         | done   | `jsonc/metadata-leaf-fields.jsonc` |
 | 1.4 | Equality filter                         | done   | `jsonc/filter-by-uuid.jsonc` |
 | 1.5 | Input-driven filter                     | done   | `jsonc/filter-by-entity-id.jsonc` |
 | 1.6 | Link entity read                        | done   | `jsonc/has-link-data.jsonc` |
 | 1.7 | Non-link entity (null link_data)        | done   | `jsonc/null-link-data.jsonc` |
-| 1.8 | Organization type                       | skip   | needs MIR builder (entity_type_ids behind `List`) |
+| 1.8 | Organization type                       | done   | `jsonc/organization-type.jsonc` |
 | 1.9 | Pinned temporal axis                    | done   | `jsonc/pinned-decision-time.jsonc` |
 | 1.A | Inequality filter                       | done   | `jsonc/filter-not-equal.jsonc` |
 | 1.B | Let binding propagation                 | done   | `jsonc/let-binding.jsonc` |
 | 1.C | Empty result set                        | done   | `jsonc/filter-false.jsonc` |
-| 1.D | Diamond CFG in filter                   | todo   | `jsonc/filter-diamond-cfg.jsonc` |
+| 1.D | Diamond CFG in filter                   | done   | `jsonc/filter-diamond-cfg.jsonc` |
 | 2.1 | Interpreter-only filter                 | done   | `jsonc/filter-by-entity-id.jsonc` (EntityId is not serialization-safe) |
 | 2.2 | Postgres-only filter                    | done   | `jsonc/filter-by-uuid.jsonc` (EntityUuid is serialization-safe) |
 | 2.3 | Mixed island filter (continuation)      | done   | `jsonc/filter-diamond-cfg.jsonc` (both EntityUuid and EntityId branches) |
-| 2.4 | Multiple sequential filters             | todo   | `jsonc/filter-sequential.jsonc` |
+| 2.4 | Multiple sequential filters             | done   | `jsonc/filter-sequential.jsonc` |
 | 3.1 | Metadata only, no properties            | todo   | unit test (hydration) |
 | 3.2 | Full metadata population                | todo   | unit test (hydration) |
 | 3.3 | Composite path: RecordId                | todo   | unit test (hydration) |

libs/@local/hashql/eval/spec/orchestrator-test-plan.md

@@ -96,7 +96,10 @@ impl From<Continuation> for Expression {
         let row = match continuation {
             Continuation::Return { filter } => {
                 vec![
-                    filter.grouped().cast(PostgresType::Boolean),
+                    filter
+                        .grouped()
+                        .cast(PostgresType::Boolean)
+                        .coalesce(Self::Constant(query::Constant::Boolean(false))),
                     null.clone(),
                     null.clone(),
                     null,
@@ -184,7 +187,20 @@ fn finish_switch_int<A: Allocator>(
     let discriminant = Box::new(discriminant.grouped().cast(PostgresType::Int));
 
     let mut discriminant = Some(discriminant);
-    let mut conditions = Vec::with_capacity(targets.values().len());
+    // +1 for the NULL guard: a NULL discriminant means the computation could
+    // not be evaluated (e.g. missing JSONB key), so we reject the row.
+    let mut conditions = Vec::with_capacity(targets.values().len() + 1);
+
+    conditions.push((
+        Expression::Unary(UnaryExpression {
+            op: UnaryOperator::IsNull,
+            expr: discriminant.clone().unwrap_or_else(|| unreachable!()),
+        }),
+        Continuation::Return {
+            filter: Expression::Constant(query::Constant::Boolean(false)),
+        }
+        .into(),
+    ));
 
     for (index, (&value, then)) in targets.values().iter().zip(branch_results).enumerate() {
         let is_last = index == targets.values().len() - 1;

libs/@local/hashql/eval/src/postgres/filter/mod.rs

@@ -15,6 +15,7 @@ use hash_graph_postgres_store::store::postgres::query::{Expression, Transpile as
 use hashql_core::{
     heap::{Heap, Scratch},
     id::Id as _,
+    module::std_lib::graph::types::knowledge::entity as entity_types,
     symbol::sym,
     r#type::{TypeBuilder, TypeId, environment::Environment},
 };
@@ -562,10 +563,10 @@ fn data_island_provides_without_lateral() {
 
     let callee_id = DefId::new(99);
 
-    // Light entity path accesses — solver puts everything on Interpreter, creating only a
+    // Light entity path accesses: solver puts everything on Interpreter, creating only a
     // Postgres Data island for the entity columns. No Postgres exec island exists.
     let body = body!(interner, env; [graph::read::filter]@0/2 -> ? {
-        decl env: (), vertex: [Opaque sym::path::Entity; ?],
+        decl env: (), vertex: (|t| entity_types::types::entity(t, t.unknown(), None)),
              uuid: ?, func: [fn() -> ?], result: ?;
         @proj v_uuid = vertex.entity_uuid: ?;
 
@@ -612,7 +613,7 @@ fn provides_drives_select_and_joins() {
     // bb0 accesses entity paths (Postgres-origin), then bb1 uses a closure (Interpreter).
     // The Postgres island should provide the accessed paths to the Interpreter island.
     let body = body!(interner, env; [graph::read::filter]@0/2 -> ? {
-        decl env: (), vertex: [Opaque sym::path::Entity; ?],
+        decl env: (), vertex: (|t| entity_types::types::entity(t, t.unknown(), None)),
              uuid: ?, archived: ?, func: [fn() -> ?], result: ?;
         @proj v_uuid = vertex.entity_uuid: ?,
               v_metadata = vertex.metadata: ?,
@@ -743,7 +744,7 @@ fn property_mask() {
     // Properties access in bb0 (Postgres Data island) with an apply in bb1 (Interpreter)
     // ensures Properties and `PropertyMetadata` appear in the provides set.
     let body = body!(interner, env; [graph::read::filter]@0/2 -> ? {
-        decl env: (), vertex: [Opaque sym::path::Entity; ?],
+        decl env: (), vertex: (|t| entity_types::types::entity(t, t.unknown(), None)),
              props: ?, prop_meta: ?, func: [fn() -> ?], result: ?;
         @proj v_props = vertex.properties: ?,
               v_meta = vertex.metadata: ?,

libs/@local/hashql/eval/src/postgres/filter/tests.rs

@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use hashql_core::heap::Heap;
+use hashql_compiletest::pipeline::Pipeline;
 use hashql_mir::{
     body::Body,
     def::{DefId, DefIdVec},
@@ -9,11 +9,12 @@ use hashql_mir::{
 
 /// Signature for programmatic test builders.
 ///
-/// Each builder receives a heap and returns the MIR components needed for
-/// execution: an interner, the entry definition, and the body set. Inputs
-/// are constructed by the test runner from seeded entity data, not by the
-/// builder.
-pub(crate) type ProgrammaticBuilder = fn(&Heap) -> (Interner<'_>, DefId, DefIdVec<Body<'_>>);
+/// Each builder receives the pipeline (providing the heap and the shared type
+/// environment) and returns the MIR components needed for execution: an
+/// interner, the entry definition, and the body set. Inputs are constructed
+/// by the test runner from seeded entity data, not by the builder.
+pub(crate) type ProgrammaticBuilder =
+    for<'heap> fn(&Pipeline<'heap>) -> (Interner<'heap>, DefId, DefIdVec<Body<'heap>>);
 
 /// A discovered test case, either from a `.jsonc` file or a programmatic
 /// registration.

libs/@local/hashql/eval/tests/orchestrator/discover.rs

@@ -2,7 +2,12 @@ use alloc::alloc::Global;
 
 use hashql_compiletest::pipeline::Pipeline;
 use hashql_core::{
-    heap::Heap, module::std_lib::graph::types::knowledge::entity, symbol::sym, r#type::TypeBuilder,
+    heap::Heap,
+    module::std_lib::graph::types::{
+        knowledge::entity, principal::actor_group::web::types as web_types,
+    },
+    symbol::sym,
+    r#type::TypeBuilder,
 };
 use hashql_eval::orchestrator::codec::{Decoder, JsonValueRef};
 use hashql_mir::{
@@ -249,6 +254,16 @@ pub(crate) fn build_inputs<'heap>(
     insert_entity_id(&mut inputs, "friend_link_id", &entities.friend_link);
     insert_entity_id(&mut inputs, "draft_alice_id", &entities.draft_alice);
 
+    // WebId input (all seeded entities share the same web).
+    let web_id_type = web_types::web_id(&ty, None);
+    let web_id_value = decoder
+        .decode(
+            web_id_type,
+            JsonValueRef::String(&entities.alice.web_id.to_string()),
+        )
+        .expect("could not decode WebId input");
+    inputs.insert(heap.intern_symbol("web_id"), web_id_value);
+
     // String inputs for property-based filtering.
     let string_type = ty.string();
     let alice_name = decoder

libs/@local/hashql/eval/tests/orchestrator/inputs.rs

@@ -18,6 +18,7 @@ mod error;
 mod execution;
 mod inputs;
 mod output;
+mod programmatic;
 mod seed;
 
 use self::{
@@ -46,6 +47,13 @@ async fn setup() -> Result<TestContext, Report<SetupError>> {
         .with_name("pgvector/pgvector")
         .with_tag("0.8.2-pg18-trixie")
         .with_reuse(ReuseDirective::CurrentSession)
+        .with_cmd([
+            "postgres",
+            "-c",
+            "log_statement=all",
+            "-c",
+            "log_destination=stderr",
+        ])
         .start()
         .await
         .change_context(SetupError::Container)?;
@@ -149,8 +157,8 @@ fn run_programmatic_test(
     bless: bool,
 ) -> Result<(), Report<TestError>> {
     let heap = Heap::new();
-    let (interner, entry, mut bodies) = builder(&heap);
     let mut pipeline = Pipeline::new(&heap);
+    let (interner, entry, mut bodies) = builder(&pipeline);
 
     let inputs = build_inputs(
         &heap,
@@ -184,7 +192,10 @@ fn run_programmatic_test(
     }
 }
 
-const PROGRAMMATIC_TESTS: &[(&str, ProgrammaticBuilder)] = &[];
+const PROGRAMMATIC_TESTS: &[(&str, ProgrammaticBuilder)] = &[
+    ("property-access", programmatic::property_access),
+    ("property-arithmetic", programmatic::property_arithmetic),
+];
 
 fn main() -> Result<(), Report<SetupError>> {
     let arguments = libtest_mimic::Arguments::from_args();