Function encode_attr_col

nodedb-array/src/codec/column_codec.rs:96–154

(values: &[CellValue])

const ATTR_TAG_MSGPACK: u8 = 2; // String, Bytes, Null — zerompk per-value

pub fn encode_attr_col(values: &[CellValue]) -> ArrayResult<Vec<u8>> {
    if values.is_empty() {
        let mut out = vec![ATTR_TAG_MSGPACK];
        out.extend_from_slice(&0u32.to_le_bytes());
        return Ok(out);
    }

    // Check if all values are Int64 or Float64 — only then use numeric codec.
    let all_int = values
        .iter()
        .all(|v| matches!(v, CellValue::Int64(_) | CellValue::Null));
    let all_float = values
        .iter()
        .all(|v| matches!(v, CellValue::Float64(_) | CellValue::Null));

    if all_int {
        let ints: Vec<i64> = values
            .iter()
            .map(|v| match v {
                CellValue::Int64(i) => *i,
                _ => 0,
            })
            .collect();
        let encoded = nodedb_codec::fastlanes::encode(&ints);
        let mut out = vec![ATTR_TAG_INT64];
        out.extend_from_slice(&encoded);
        return Ok(out);
    }

    if all_float {
        // Gorilla XOR-encodes f64 series — exploits common-prefix bits across
        // adjacent values, which dominates the size of monotonic / smooth
        // numeric columns. fastlanes-on-bits used to live here but treats
        // each f64 as an independent i64, missing the inter-value redundancy.
        let floats: Vec<f64> = values
            .iter()
            .map(|v| match v {
                CellValue::Float64(f) => *f,
                _ => 0.0,
            })
            .collect();
        let encoded = nodedb_codec::gorilla::encode_f64(&floats);
        let mut out = vec![ATTR_TAG_FLOAT64];
        out.extend_from_slice(&encoded);
        return Ok(out);
    }

    // Generic zerompk fallback for String / Bytes / mixed / Null.
    let mut out = vec![ATTR_TAG_MSGPACK];
    out.extend_from_slice(&(values.len() as u32).to_le_bytes());
    for v in values {
        let bytes = zerompk::to_msgpack_vec(v).map_err(|e| ArrayError::SegmentCorruption {
            detail: format!("attr col encode: {e}"),
        })?;
        out.extend_from_slice(&(bytes.len() as u32).to_le_bytes());
        out.extend_from_slice(&bytes);
    }
    Ok(out)