Function value_to_binary_tuple

nodedb/src/data/executor/strict_format/encode.rs:24–66

Encode a `nodedb_types::Value` as a Binary Tuple according to the schema.

(value: &Value, schema: &StrictSchema)

/// Encode a `nodedb_types::Value` as a Binary Tuple according to the schema.
pub fn value_to_binary_tuple(value: &Value, schema: &StrictSchema) -> crate::Result<Vec<u8>> {
    let map = match value {
        Value::Object(m) => m,
        _ => {
            return Err(crate::Error::BadRequest {
                detail: "strict value must be an Object".to_string(),
            });
        }
    };

    let schema_columns: std::collections::HashSet<&str> =
        schema.columns.iter().map(|c| c.name.as_str()).collect();
    if let Some(unknown) = map.keys().find(|k| !schema_columns.contains(k.as_str())) {
        return Err(crate::Error::BadRequest {
            detail: format!("unknown field '{unknown}' not present in strict schema"),
        });
    }

    let encoder = nodedb_strict::TupleEncoder::new(schema);
    let mut values = Vec::with_capacity(schema.columns.len());

    for col in &schema.columns {
        let field_val = map.get(&col.name);
        let typed = match field_val {
            None | Some(Value::Null) => {
                if !col.nullable {
                    return Err(crate::Error::BadRequest {
                        detail: format!("column '{}' is NOT NULL but no value provided", col.name),
                    });
                }
                Value::Null
            }
            Some(v) => coerce_value(v, &col.column_type, &col.name)?,
        };
        values.push(typed);
    }

    encoder
        .encode(&values)
        .map_err(|e| crate::Error::BadRequest {
            detail: format!("Binary Tuple encode: {e}"),
        })
}

/// Bitemporal variant: decode msgpack to `Value`, then encode as a Binary
/// Tuple with reserved slots 0/1/2 populated from the supplied timestamps.