rnacos 0.8.3

Nacos server re-implemented in Rust.
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#![allow(dead_code, unused_imports)]

use std::sync::Arc;

use rusqlite::{params_from_iter, Connection, Row};

fn result2option<T>(r: rusqlite::Result<T>) -> Option<T> {
    r.ok()
}

fn result_to_arc_option<T>(r: rusqlite::Result<T>) -> Option<Arc<T>> {
    match r {
        Ok(v) => Some(Arc::new(v)),
        _ => None,
    }
}

pub fn get_row_value<T>(r: &Row, name: &str) -> Option<T>
where
    T: rusqlite::types::FromSql,
{
    result2option(r.get(name))
}

pub fn get_row_arc_value<T>(r: &Row, name: &str) -> Option<Arc<T>>
where
    T: rusqlite::types::FromSql,
{
    result_to_arc_option(r.get(name))
}

pub fn convert_json_param(val: &serde_json::Value) -> rusqlite::types::ToSqlOutput<'_> {
    match val {
        serde_json::Value::Null => {
            rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Null)
        }
        serde_json::Value::Number(n) => {
            if n.is_f64() {
                return rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Real(
                    n.as_f64().unwrap(),
                ));
            }
            rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Integer(
                n.as_i64().unwrap(),
            ))
        }
        serde_json::Value::String(s) => {
            rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Text(s.to_owned()))
        }
        _ => rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Text(val.to_string())),
    }
}

pub fn convert_json_params(inputs: &[serde_json::Value]) -> Vec<rusqlite::types::ToSqlOutput<'_>> {
    inputs.iter().map(convert_json_param).collect()
}

pub fn sqlite_execute(
    conn: &Connection,
    sql: &str,
    args: &[serde_json::Value],
) -> anyhow::Result<usize> {
    //println!("sqlite_execute, {} | {:?}",&sql,&args);
    let result = conn.execute(sql, params_from_iter(convert_json_params(args).iter()));
    Ok(result?)
}

pub fn sqlite_fetch<T, F>(
    conn: &Connection,
    sql: &str,
    args: &[serde_json::Value],
    convert: F,
) -> anyhow::Result<Vec<T>>
where
    F: Fn(&Row) -> T + Send,
{
    //println!("sqlite_fetch, {} | {:?}",&sql,&args);
    let mut stmt = conn.prepare(sql).unwrap();
    let r = stmt.query_map(params_from_iter(convert_json_params(args).iter()), |r| {
        Ok(convert(r))
    });
    let res = r?;
    let list: Vec<T> = res.into_iter().map(|e| e.unwrap()).collect();
    Ok(list)
}

pub fn sqlite_fetch_count(
    conn: &Connection,
    sql: &str,
    args: &[serde_json::Value],
) -> anyhow::Result<u64> {
    //println!("sqlite_fetch_count, {} | {:?}",&sql,&args);
    let mut stmt = conn.prepare(sql).unwrap();
    let r = stmt.query_map(params_from_iter(convert_json_params(args).iter()), |r| {
        r.get(0)
    });
    let res = r?;
    let list: Vec<u64> = res.into_iter().map(|e| e.unwrap()).collect();
    let v = list.first().unwrap().to_owned();
    Ok(v)
}