Function execute_query

aiscript-vm/src/stdlib/db/sqlite.rs:103–146

(
    executor: E,
    query: &str,
    bindings: Vec<Value<'_>>,
)

}

fn execute_query<'a, E>(
    executor: E,
    query: &str,
    bindings: Vec<Value<'_>>,
) -> Result<Vec<sqlx::sqlite::SqliteRow>, VmError>
where
    E: sqlx::Executor<'a, Database = sqlx::Sqlite>,
{
    Handle::current()
        .block_on(async {
            let mut query_builder = sqlx::query(query);

            // Bind parameters
            for value in bindings {
                match value {
                    Value::Number(n) => {
                        query_builder = query_builder.bind(n);
                    }
                    Value::String(s) => {
                        query_builder = query_builder.bind(s.to_str().unwrap());
                    }
                    Value::Boolean(b) => {
                        query_builder = query_builder.bind(b);
                    }
                    Value::Nil => {
                        query_builder = query_builder.bind(Option::<String>::None);
                    }
                    Value::List(list) => {
                        let vec = &list.borrow().data;
                        // SQLite doesn't have native array types, so convert to string representation
                        let json = serde_json::to_string(
                            &vec.iter().map(Value::to_serde_value).collect::<Vec<_>>(),
                        )
                        .map_err(|e| sqlx::Error::Protocol(e.to_string()))?;
                        query_builder = query_builder.bind(json);
                    }
                    _ => return Err(sqlx::Error::Protocol("Unsupported parameter type".into())),
                }
            }

            query_builder.fetch_all(executor).await
        })
        .map_err(|e| VmError::RuntimeError(format!("Database query error: {}", e)))
}

fn execute_typed_query<'gc, 'a, E>(
    ctx: Context<'gc>,