Function parse_range_literal

nodedb-columnar/src/memtable/column_data/push.rs:43–85

Parse a PostgreSQL range literal into a structured Value. Accepts the four standard bound forms: `[lo,hi)`, `(lo,hi]`, `[lo,hi]`, `(lo,hi)`. The bounds are stored as string tokens so the caller can interpret them as any scalar type.

(s: &str, col_name: &str)

/// `(lo,hi)`.  The bounds are stored as string tokens so the caller can
/// interpret them as any scalar type.
fn parse_range_literal(s: &str, col_name: &str) -> Result<Vec<u8>, ColumnarError> {
    let s = s.trim();
    let (lower_inclusive, rest) = if let Some(r) = s.strip_prefix('[') {
        (true, r)
    } else if let Some(r) = s.strip_prefix('(') {
        (false, r)
    } else {
        return Err(ColumnarError::RangeParse {
            column: col_name.to_string(),
            literal: s.to_string(),
        });
    };

    let (body, upper_inclusive) = if let Some(b) = rest.strip_suffix(']') {
        (b, true)
    } else if let Some(b) = rest.strip_suffix(')') {
        (b, false)
    } else {
        return Err(ColumnarError::RangeParse {
            column: col_name.to_string(),
            literal: s.to_string(),
        });
    };

    let comma = body.find(',').ok_or_else(|| ColumnarError::RangeParse {
        column: col_name.to_string(),
        literal: s.to_string(),
    })?;
    let lower = body[..comma].trim().to_string();
    let upper = body[comma + 1..].trim().to_string();

    let mut map = std::collections::HashMap::new();
    map.insert("lower".to_string(), Value::String(lower));
    map.insert("upper".to_string(), Value::String(upper));
    map.insert("lower_inclusive".to_string(), Value::Bool(lower_inclusive));
    map.insert("upper_inclusive".to_string(), Value::Bool(upper_inclusive));
    let structured = Value::Object(map);

    value_to_msgpack(&structured).map_err(|e| ColumnarError::MsgpackSerialize {
        column: col_name.to_string(),
        source: e,
    })
}

impl ColumnData {
    /// Push a validity bit (if the column is nullable).