unionid-query 0.14.0

Compile-time checked inline Unionid queries for Rust applications
Documentation
use serde::{Deserialize, Serialize};

#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct CallerOwnedModel {
    label: String,
}

unionid_query::queries! {
    schema "tests/schema.unid"

    query find_pending {
        from tasks
        filter state == Pending and priority >= $min_priority
        sort {-priority, id}
        select {id, title, state}
        take 20
    }

    query reprioritize_task {
        update tasks
        filter id == $id
        set priority = $priority
        returning {id, priority, state}
        expect affected == 1
    }

    query due_before {
        from tasks
        filter due_on < @2026-10-01
        select {id, due_on}
    }

    query running_for_worker {
        from tasks
        filter match state {
            Pending => false
            Running {worker} => worker == $worker
            Done {..} => false
        }
        select {id, state}
    }

    query normalize_text {
        from tasks
        filter id == $id
        derive label = concat (substring (lower (trim title)) 0 $end) "!"
        derive matched = starts_with label $prefix
        select {label, matched}
    }

    query convert_integer {
        from tasks
        filter id == $id
        derive value = int_to_float $value
        select value
    }

    query round_float {
        from tasks
        filter id == $id
        derive value = float_to_int $value "half_even"
        select value
    }

    query convert_decimal {
        from tasks
        filter id == $id
        derive value = int_to_decimal $value 8 2
        select value
    }

    query scalar_label {
        from tasks
        filter id == $id
        derive value = concat (to_text priority) (concat "@" (to_text due_on))
        select value
    }

    query calendar_bucket {
        from tasks
        filter id == $id
        derive day = date_of $at "+08:00"
        derive bucket = timestamp_trunc $at "day" "+08:00"
        select {day, bucket}
    }
}

#[test]
fn inline_temporal_functions_infer_native_params_outputs_and_range_errors() {
    let mut engine = unionid::Engine::memory();
    assert!(engine.execute(include_str!("schema.unid")).ok);
    assert!(engine.execute("insert tasks {id: 1, title: \"calendar\", state: Pending, priority: 1, due_on: @2026-09-17}").ok);
    let rows = calendar_bucket::calendar_bucket(
        &mut engine,
        calendar_bucket::CalendarBucketParams {
            id: 1,
            at: "2026-10-02T18:00:00Z".parse().unwrap(),
        },
    )
    .unwrap();
    assert_eq!(rows[0].day.to_string(), "2026-10-03");
    assert_eq!(rows[0].bucket.to_string(), "2026-10-02T16:00:00Z");
    let error = calendar_bucket::calendar_bucket(
        &mut engine,
        calendar_bucket::CalendarBucketParams {
            id: 1,
            at: "9999-12-31T23:59:59Z".parse().unwrap(),
        },
    )
    .unwrap_err();
    assert_eq!(error.code, "E_ARITH");
}

#[test]
fn inline_text_conversion_formats_int_and_native_date_as_typed_text() {
    let mut engine = unionid::Engine::memory();
    assert!(engine.execute(include_str!("schema.unid")).ok);
    assert!(engine.execute("insert tasks {id: 1, title: \"label\", state: Pending, priority: 1, due_on: @2026-09-17}").ok);
    let rows =
        scalar_label::scalar_label(&mut engine, scalar_label::ScalarLabelParams { id: 1 }).unwrap();
    assert_eq!(rows[0].value, "1@2026-09-17");
}

#[test]
fn inline_decimal_conversion_has_typed_output_and_preserves_precision_errors() {
    let mut engine = unionid::Engine::memory();
    assert!(engine.execute(include_str!("schema.unid")).ok);
    assert!(engine.execute("insert tasks {id: 1, title: \"decimal\", state: Pending, priority: 1, due_on: @2026-09-17}").ok);
    let rows = convert_decimal::convert_decimal(
        &mut engine,
        convert_decimal::ConvertDecimalParams { id: 1, value: 12 },
    )
    .unwrap();
    assert_eq!(rows[0].value.to_string(), "12.00");
    let error = convert_decimal::convert_decimal(
        &mut engine,
        convert_decimal::ConvertDecimalParams {
            id: 1,
            value: 1_000_000,
        },
    )
    .unwrap_err();
    assert_eq!(error.code, "E_DECIMAL_RANGE");
}

#[test]
fn inline_float_conversion_infers_float_params_and_preserves_range_errors() {
    let mut engine = unionid::Engine::memory();
    assert!(engine.execute(include_str!("schema.unid")).ok);
    assert!(engine.execute("insert tasks {id: 1, title: \"round\", state: Pending, priority: 1, due_on: @2026-09-17}").ok);
    let rows = round_float::round_float(
        &mut engine,
        round_float::RoundFloatParams { id: 1, value: 2.5 },
    )
    .unwrap();
    assert_eq!(rows[0].value, 2);
    let error = round_float::round_float(
        &mut engine,
        round_float::RoundFloatParams {
            id: 1,
            value: 9_223_372_036_854_775_808.0,
        },
    )
    .unwrap_err();
    assert_eq!(error.code, "E_CAST_RANGE");
}

#[test]
fn inline_integer_conversion_infers_int_params_and_float_rows() {
    let mut engine = unionid::Engine::memory();
    assert!(engine.execute(include_str!("schema.unid")).ok);
    assert!(engine.execute("insert tasks {id: 1, title: \"cast\", state: Pending, priority: 1, due_on: @2026-09-17}").ok);
    let rows = convert_integer::convert_integer(
        &mut engine,
        convert_integer::ConvertIntegerParams { id: 1, value: 2 },
    )
    .unwrap();
    assert_eq!(rows[0].value, 2.0);
    let error = convert_integer::convert_integer(
        &mut engine,
        convert_integer::ConvertIntegerParams {
            id: 1,
            value: i64::MAX,
        },
    )
    .unwrap_err();
    assert_eq!(error.code, "E_CAST_PRECISION");
}

#[test]
fn inline_text_functions_infer_typed_parameters_and_preserve_range_errors() {
    let mut engine = unionid::Engine::memory();
    assert!(engine.execute(include_str!("schema.unid")).ok);
    assert!(engine.execute("insert tasks {id: 1, title: \" Aé🦀 \", state: Pending, priority: 1, due_on: @2026-09-17}").ok);
    let rows = normalize_text::normalize_text(
        &mut engine,
        normalize_text::NormalizeTextParams {
            id: 1,
            end: 2,
            prefix: "a".into(),
        },
    )
    .unwrap();
    assert_eq!(rows.len(), 1);
    assert_eq!(rows[0].label, "aé!");
    assert!(rows[0].matched);
    let error = normalize_text::normalize_text(
        &mut engine,
        normalize_text::NormalizeTextParams {
            id: 1,
            end: 4,
            prefix: "a".into(),
        },
    )
    .unwrap_err();
    assert_eq!(error.code, "E_TEXT_RANGE");
}

#[test]
fn inline_queries_generate_shared_typed_bindings() {
    let caller_model = CallerOwnedModel {
        label: "caller import remains usable".into(),
    };
    assert_eq!(caller_model.label, "caller import remains usable");

    let mut engine = unionid::Engine::memory();
    let schema = include_str!("schema.unid");
    let created = engine.execute(schema);
    assert!(created.ok, "{}", created.message);
    let inserted = engine.execute(
        r#"insert tasks {id: 1, title: "macro", state: Pending, priority: 4, due_on: @2026-09-17}"#,
    );
    assert!(inserted.ok, "{}", inserted.message);
    let inserted = engine.execute(
        r#"insert tasks {id: 2, title: "worker", state: Running {worker: "alpha"}, priority: 2, due_on: @2026-10-17}"#,
    );
    assert!(inserted.ok, "{}", inserted.message);

    let rows = find_pending::find_pending(
        &mut engine,
        find_pending::FindPendingParams { min_priority: 3 },
    )
    .unwrap();
    assert_eq!(rows.len(), 1);
    assert_eq!(rows[0].id, 1);
    assert_eq!(rows[0].state, State::Pending);

    let changed = reprioritize_task::reprioritize_task(
        &mut engine,
        reprioritize_task::ReprioritizeTaskParams { id: 1, priority: 9 },
    )
    .unwrap();
    assert_eq!(changed.affected_rows, 1);
    assert_eq!(changed.rows.len(), 1);
    assert_eq!(changed.rows[0].state, State::Pending);
    assert_eq!(changed.rows[0].priority, 9);
    let missed = reprioritize_task::reprioritize_task(
        &mut engine,
        reprioritize_task::ReprioritizeTaskParams {
            id: 99,
            priority: 0,
        },
    )
    .unwrap_err();
    assert_eq!(missed.code, "E_EXPECTATION");
    assert_eq!(missed.statement_index, Some(2));
    let due = due_before::due_before(&mut engine, due_before::DueBeforeParams).unwrap();
    assert_eq!(due.len(), 1);
    assert_eq!(due[0].id, 1);
    let running = running_for_worker::running_for_worker(
        &mut engine,
        running_for_worker::RunningForWorkerParams {
            worker: "alpha".into(),
        },
    )
    .unwrap();
    assert_eq!(running.len(), 1);
    assert_eq!(running[0].id, 2);
    assert_eq!(
        running[0].state,
        State::Running {
            worker: "alpha".into()
        }
    );
    assert!(find_pending::FIND_PENDING_DIGEST.starts_with("sha256:"));
    let described =
        unionid::query_contract::describe(schema, find_pending::FIND_PENDING_SOURCE).unwrap();
    assert_eq!(
        described.canonical_source,
        find_pending::FIND_PENDING_SOURCE
    );
    assert_eq!(described.query_digest, find_pending::FIND_PENDING_DIGEST);
}

#[test]
fn generated_query_rejects_runtime_schema_drift() {
    let mut engine = unionid::Engine::memory();
    assert!(engine.execute(include_str!("schema.unid")).ok);
    assert!(engine.execute("type Extra = text").ok);
    let error = find_pending::find_pending(
        &mut engine,
        find_pending::FindPendingParams { min_priority: 0 },
    )
    .unwrap_err();
    assert_eq!(error.code, "E_SCHEMA_CHANGED");
}

#[test]
fn inline_queries_execute_against_redb() {
    let directory = std::env::temp_dir().join(format!(
        "unionid-query-macro-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&directory).unwrap();
    let database = directory.join("inline.redb");
    {
        let mut engine = unionid::Engine::open_redb(&database).unwrap();
        assert!(engine.execute(include_str!("schema.unid")).ok);
        let inserted = engine.execute(
            r#"insert tasks {id: 7, title: "redb", state: Pending, priority: 5, due_on: @2026-09-18}"#,
        );
        assert!(inserted.ok, "{}", inserted.message);
        let rows = find_pending::find_pending(
            &mut engine,
            find_pending::FindPendingParams { min_priority: 5 },
        )
        .unwrap();
        assert_eq!(rows.len(), 1);
        assert_eq!(rows[0].id, 7);
        assert_eq!(rows[0].state, State::Pending);
    }
    {
        let mut reopened = unionid::Engine::open_redb(&database).unwrap();
        let rows = due_before::due_before(&mut reopened, due_before::DueBeforeParams).unwrap();
        assert_eq!(rows.len(), 1);
        assert_eq!(rows[0].id, 7);
    }
    std::fs::remove_dir_all(directory).unwrap();
}