Function register_array_remove

src/functions/array_functions.rs:268–307

array_remove(array, element) - Remove all occurrences of element

(conn: &Connection)

/// array_remove(array, element) - Remove all occurrences of element
fn register_array_remove(conn: &Connection) -> Result<()> {
    conn.create_scalar_function(
        "array_remove",
        2,
        FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_DETERMINISTIC,
        |ctx| {
            let array_json: String = ctx.get(0)?;
            
            // Handle element parameter of different types
            let elem_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)))
                }
            };
            
            match serde_json::from_str::<JsonValue>(&array_json) {
                Ok(JsonValue::Array(arr)) => {
                    let filtered: Vec<JsonValue> = arr.into_iter()
                        .filter(|v| v != &elem_value)
                        .collect();
                    
                    Ok(serde_json::to_string(&filtered).ok())
                }
                _ => Ok(None),
            }
        },
    )?;
    
    Ok(())
}

/// array_replace(array, old, new) - Replace all occurrences
fn register_array_replace(conn: &Connection) -> Result<()> {