rssql 0.2.6

Struct free Rust SQL tool.
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
102
103
104
105
106
107
108
109
110
111
112

use anyhow;
use sqlx::types::chrono::{DateTime, NaiveDate, NaiveDateTime, NaiveTime};
use sqlx::{Column, Row, TypeInfo};
use sqlx::sqlite::SqliteRow;
use std::collections::HashMap;
use std::fmt;

use crate::SQLDataTypes;
use crate::SQLRets;
use crate::BINARY;
use crate::UNKNOWN;

#[derive(Debug, Clone)]
pub enum SQLiteDataTypes {
    /// From https://docs.rs/sqlx-sqlite/0.7.0/sqlx_sqlite/types/index.html
    Bool(bool),
    I32(i32),
    I64(i64),
    F64(f64),
    String(String),
    Binary(Vec<u8>),
    NaiveDateTime(NaiveDateTime),
    DateTime(DateTime<chrono::Utc>),
    NaiveDate(NaiveDate),
    NaiveTime(NaiveTime),
}

impl fmt::Display for SQLiteDataTypes {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            SQLiteDataTypes::Bool(v) => write!(f, "{}", v),
            SQLiteDataTypes::I32(v) => write!(f, "{}", v),
            SQLiteDataTypes::I64(v) => write!(f, "{}", v),
            SQLiteDataTypes::F64(v) => write!(f, "{}", v),
            SQLiteDataTypes::String(v) => write!(f, "{}", v),
            SQLiteDataTypes::Binary(_) => write!(f, "{}", BINARY),
            SQLiteDataTypes::NaiveDateTime(v) => write!(f, "{}", v),
            SQLiteDataTypes::DateTime(v) => write!(f, "{}", v),
            SQLiteDataTypes::NaiveDate(v) => write!(f, "{}", v),
            SQLiteDataTypes::NaiveTime(v) => write!(f, "{}", v),
        }
    }
}

pub async fn rows_process(rows: Vec<SqliteRow>) -> anyhow::Result<SQLRets> {
    let mut sql_rets = SQLRets::new();

    if rows.len() > 0 {
        // push all column
        let mysql_row = &rows[0];
        let mysql_row_len = mysql_row.len();
        for i in 0..mysql_row_len {
            let col = mysql_row.column(i);
            let col_name = col.name().to_string();
            sql_rets.push_column_name(&col_name);
        }
    }

    for mysql_row in &rows {
        let mut sql_row: HashMap<String, SQLDataTypes> = HashMap::new();
        let sqlite_row_len = mysql_row.len();

        for i in 0..sqlite_row_len {
            let col = mysql_row.column(i);
            let col_name = col.name().to_string();
            let type_info = col.type_info();
            let sqlite_value = match type_info.name() {
                "BOOLEAN" => {
                    let value: bool = mysql_row.get(i);
                    SQLiteDataTypes::Bool(value)
                }
                "INTEGER" => {
                    let value: i32 = mysql_row.get(i);
                    SQLiteDataTypes::I32(value)
                }
                "BIGINT" | "INT8" => {
                    let value: i64 = mysql_row.get(i);
                    SQLiteDataTypes::I64(value)
                }
                "REAL" => {
                    let value: f64 = mysql_row.get(i);
                    SQLiteDataTypes::F64(value)
                }
                "TEXT" => {
                    let value: String = mysql_row.get(i);
                    SQLiteDataTypes::String(value)
                }
                "BLOB" => {
                    let value: Vec<u8> = mysql_row.get(i);
                    SQLiteDataTypes::Binary(value)
                }
                "DATETIME" => {
                    let value: NaiveDateTime = mysql_row.get(i);
                    SQLiteDataTypes::NaiveDateTime(value)
                }
                "DATE" => {
                    let value: NaiveDate = mysql_row.get(i);
                    SQLiteDataTypes::NaiveDate(value)
                }
                "TIME" => {
                    let value: NaiveTime = mysql_row.get(i);
                    SQLiteDataTypes::NaiveTime(value)
                }
                _ => SQLiteDataTypes::String(UNKNOWN.into()),
            };
            let sql_value = SQLDataTypes::SQLiteDataTypes(sqlite_value);
            sql_row.insert(col_name, sql_value);
        }
        sql_rets.push_rets(sql_row);
    }
    Ok(sql_rets)
}