Function execute_query

aiscript-vm/src/stdlib/db/pg.rs:194–291

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

}

fn execute_query<'a, E>(
    executor: E,
    query: &str,
    bindings: Vec<Value<'_>>,
) -> Result<Vec<sqlx::postgres::PgRow>, VmError>
where
    E: sqlx::Executor<'a, Database = sqlx::Postgres>,
{
    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) => {
                        let s_str = s.to_str().unwrap();
                        // Try to parse special types from string
                        if let Ok(uuid) = sqlx::types::Uuid::parse_str(s_str) {
                            query_builder = query_builder.bind(uuid);
                        } else if let Ok(date) =
                            sqlx::types::chrono::NaiveDate::parse_from_str(s_str, "%Y-%m-%d")
                        {
                            query_builder = query_builder.bind(date);
                        } else if let Ok(datetime) =
                            sqlx::types::chrono::NaiveDateTime::parse_from_str(
                                s_str,
                                "%Y-%m-%dT%H:%M:%S",
                            )
                        {
                            query_builder = query_builder.bind(datetime);
                        } else {
                            query_builder = query_builder.bind(s_str);
                        }
                    }
                    Value::Boolean(b) => {
                        query_builder = query_builder.bind(b);
                    }
                    Value::Nil => {
                        query_builder = query_builder.bind(Option::<String>::None);
                    }
                    Value::List(arr) => {
                        let arr = &arr.borrow().data;
                        if let Some(first) = arr.first() {
                            match first {
                                Value::Number(_) => {
                                    let nums: Vec<f64> = arr
                                        .iter()
                                        .filter_map(|v| match v {
                                            Value::Number(n) => Some(*n),
                                            _ => None,
                                        })
                                        .collect();
                                    query_builder = query_builder.bind(nums);
                                }