omnia-wasi-sql 0.28.0

WASI SQL database interface for the Omnia runtime
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

//! # WASI SQL WIT implementation

// Bindings for the `wasi:sql` world.
// See (<https://github.com/augentic/wasi-sql/>)
mod generated {
    #![allow(missing_docs)]

    wit_bindgen::generate!({
        world: "sql",
        path: "wit",
        generate_all,
    });
}

use anyhow::Result;
use base64ct::{Base64, Encoding};
use serde_json::Value;

pub use self::generated::wasi::sql::*;
pub use crate::types::{DataType, Field, Row};

/// Helper function to create JSON output from rows returned by a query.
///
/// # Errors
/// Transforms into JSON value types fail.
pub fn into_json(rows: Vec<Row>) -> Result<Value> {
    let json_rows: Vec<Value> = rows
        .into_iter()
        .map(|row| {
            let mut map = serde_json::Map::new();
            for field in row.fields {
                let json_value = match field.value {
                    DataType::Int32(Some(v)) => Value::Number(v.into()),
                    DataType::Int64(Some(v)) => Value::Number(v.into()),
                    DataType::Uint32(Some(v)) => Value::Number(v.into()),
                    DataType::Uint64(Some(v)) => Value::Number(v.into()),
                    DataType::Float(Some(v)) => serde_json::Number::from_f64(f64::from(v))
                        .map_or(Value::Null, Value::Number),
                    DataType::Double(Some(v)) => {
                        serde_json::Number::from_f64(v).map_or(Value::Null, Value::Number)
                    }
                    DataType::Str(Some(v))
                    | DataType::Date(Some(v))
                    | DataType::Time(Some(v))
                    | DataType::Timestamp(Some(v)) => Value::String(v),
                    DataType::Boolean(Some(v)) => Value::Bool(v),
                    DataType::Binary(Some(v)) => {
                        let encoded = Base64::encode_string(&v);
                        Value::String(encoded)
                    }
                    DataType::Int32(None)
                    | DataType::Int64(None)
                    | DataType::Uint32(None)
                    | DataType::Uint64(None)
                    | DataType::Float(None)
                    | DataType::Double(None)
                    | DataType::Str(None)
                    | DataType::Boolean(None)
                    | DataType::Date(None)
                    | DataType::Time(None)
                    | DataType::Timestamp(None)
                    | DataType::Binary(None) => Value::Null,
                };
                map.insert(field.name, json_value);
            }
            Value::Object(map)
        })
        .collect();

    Ok(Value::Array(json_rows))
}