fv-compute-container 0.2.0

The container backend for fv-compute: a transform is a process or image that reads Arrow IPC (or row JSON) on stdin and writes it on stdout — for heavy, GPU or arbitrary-dependency transforms.
Documentation
//! Reference Arrow-IPC container transform `spikeTotal`: reads Arrow IPC on stdin, appends
//! `total = amount*2 + id`, writes Arrow IPC on stdout. Identical logic to the wasm guests, so the
//! backends are interchangeable behind the contract. (A real container transform can be any language
//! that speaks Arrow IPC over stdio — e.g. Python + pyarrow.)

use arrow::array::{Float64Array, Int64Array, RecordBatch};
use arrow::datatypes::{DataType, Field, Schema};
use std::io::Read;
use std::sync::Arc;

fn main() {
    if let Err(e) = run() {
        eprintln!("refguest error: {e}");
        std::process::exit(1);
    }
}

fn run() -> Result<(), Box<dyn std::error::Error>> {
    let mut bytes = Vec::new();
    std::io::stdin().read_to_end(&mut bytes)?;
    let reader = arrow::ipc::reader::StreamReader::try_new(std::io::Cursor::new(&bytes), None)?;

    let out_schema = Arc::new(Schema::new(vec![
        Field::new("id", DataType::Int64, true),
        Field::new("amount", DataType::Float64, true),
        Field::new("total", DataType::Float64, true),
    ]));

    let stdout = std::io::stdout();
    let mut w = arrow::ipc::writer::StreamWriter::try_new(stdout.lock(), &out_schema)?;
    for batch in reader {
        let batch = batch?;
        let out = transform(&batch, &out_schema)?;
        w.write(&out)?;
    }
    w.finish()?;
    Ok(())
}

fn transform(rb: &RecordBatch, out_schema: &Arc<Schema>) -> Result<RecordBatch, Box<dyn std::error::Error>> {
    let ids = rb
        .column_by_name("id")
        .and_then(|c| c.as_any().downcast_ref::<Int64Array>())
        .ok_or("missing int64 column 'id'")?;
    let amounts = rb
        .column_by_name("amount")
        .and_then(|c| c.as_any().downcast_ref::<Float64Array>())
        .ok_or("missing float64 column 'amount'")?;
    let total: Float64Array = ids
        .iter()
        .zip(amounts.iter())
        .map(|(i, a)| match (i, a) {
            (Some(i), Some(a)) => Some(a * 2.0 + i as f64),
            _ => None,
        })
        .collect();
    Ok(RecordBatch::try_new(
        out_schema.clone(),
        vec![Arc::new(ids.clone()), Arc::new(amounts.clone()), Arc::new(total)],
    )?)
}