Function register_array_replace

src/functions/array_functions.rs:310–366

array_replace(array, old, new) - Replace all occurrences

(conn: &Connection)

/// array_replace(array, old, new) - Replace all occurrences
fn register_array_replace(conn: &Connection) -> Result<()> {
    conn.create_scalar_function(
        "array_replace",
        3,
        FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
        |ctx| {
            let array_json: String = ctx.get(0)?;
            
            // Handle old_element parameter of different types
            let old_value = match ctx.get_raw(1) {
                rusqlite::types::ValueRef::Text(s) => {
                    let text = std::str::from_utf8(s).unwrap_or("");
                    serde_json::from_str::<JsonValue>(text)
                        .unwrap_or_else(|_| JsonValue::String(text.to_string()))
                }
                rusqlite::types::ValueRef::Integer(i) => JsonValue::Number(serde_json::Number::from(i)),
                rusqlite::types::ValueRef::Real(f) => {
                    JsonValue::Number(serde_json::Number::from_f64(f).unwrap_or_else(|| serde_json::Number::from(0)))
                }
                rusqlite::types::ValueRef::Null => JsonValue::Null,
                rusqlite::types::ValueRef::Blob(b) => {
                    JsonValue::String(format!("\\x{}", hex::encode(b)))
                }
            };
            
            // Handle new_element parameter of different types
            let new_value = match ctx.get_raw(2) {
                rusqlite::types::ValueRef::Text(s) => {
                    let text = std::str::from_utf8(s).unwrap_or("");
                    serde_json::from_str::<JsonValue>(text)
                        .unwrap_or_else(|_| JsonValue::String(text.to_string()))
                }
                rusqlite::types::ValueRef::Integer(i) => JsonValue::Number(serde_json::Number::from(i)),
                rusqlite::types::ValueRef::Real(f) => {
                    JsonValue::Number(serde_json::Number::from_f64(f).unwrap_or_else(|| serde_json::Number::from(0)))
                }
                rusqlite::types::ValueRef::Null => JsonValue::Null,
                rusqlite::types::ValueRef::Blob(b) => {
                    JsonValue::String(format!("\\x{}", hex::encode(b)))
                }
            };
            
            match serde_json::from_str::<JsonValue>(&array_json) {
                Ok(JsonValue::Array(arr)) => {
                    let replaced: Vec<JsonValue> = arr.into_iter()
                        .map(|v| if v == old_value { new_value.clone() } else { v })
                        .collect();
                    
                    Ok(serde_json::to_string(&replaced).ok())
                }
                _ => Ok(None),
            }
        },
    )?;
    
    Ok(())
}