Function register_jsonb_agg

src/functions/json_functions.rs:944–1000

jsonb_agg(expression) - Aggregate values into a JSONB array (alias for json_agg)

(conn: &Connection)

/// jsonb_agg(expression) - Aggregate values into a JSONB array (alias for json_agg)
fn register_jsonb_agg(conn: &Connection) -> Result<()> {
    use rusqlite::functions::Aggregate;
    
    #[derive(Default)]
    struct JsonbAgg;
    
    impl Aggregate<Vec<JsonValue>, Option<String>> for JsonbAgg {
        fn init(&self, _: &mut rusqlite::functions::Context<'_>) -> Result<Vec<JsonValue>> {
            Ok(Vec::new())
        }
        
        fn step(&self, ctx: &mut rusqlite::functions::Context<'_>, agg: &mut Vec<JsonValue>) -> Result<()> {
            let value = ctx.get_raw(0);
            
            let json_value = match value {
                rusqlite::types::ValueRef::Null => JsonValue::Null,
                rusqlite::types::ValueRef::Integer(i) => JsonValue::Number(serde_json::Number::from(i)),
                rusqlite::types::ValueRef::Real(f) => {
                    if let Some(num) = serde_json::Number::from_f64(f) {
                        JsonValue::Number(num)
                    } else {
                        JsonValue::Null
                    }
                }
                rusqlite::types::ValueRef::Text(s) => {
                    let text = std::str::from_utf8(s).unwrap_or("");
                    // Try to parse as JSON first, if it fails treat as string
                    serde_json::from_str(text)
                        .unwrap_or_else(|_| JsonValue::String(text.to_string()))
                }
                rusqlite::types::ValueRef::Blob(b) => {
                    // Convert blob to hex string
                    JsonValue::String(format!("\\x{}", hex::encode(b)))
                }
            };
            
            agg.push(json_value);
            Ok(())
        }
        
        fn finalize(&self, _: &mut rusqlite::functions::Context<'_>, agg: Option<Vec<JsonValue>>) -> Result<Option<String>> {
            match agg {
                Some(values) => Ok(Some(serde_json::to_string(&values).unwrap_or_else(|_| "[]".to_string()))),
                None => Ok(Some("[]".to_string())), // Return empty array for no rows
            }
        }
    }
    
    conn.create_aggregate_function(
        "jsonb_agg",
        1,
        FunctionFlags::SQLITE_UTF8,
        JsonbAgg,
    )?;
    
    Ok(())
}