sqlex 0.1.0

A tool to extract tables from a sql dump and run sql queries on them
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

use std::collections::HashMap;

use serde::ser::SerializeStruct;
use serde::Serialize;
use serde::Serializer;
use sql_parse::Type;

#[derive(Clone, Debug, Serialize)]
pub struct Table {
    pub name: String,
    pub columns: Vec<Column>,
    pub constraints: Option<Vec<Constraint>>,
}

impl Table {
    pub fn into_json(&self) -> String {
        let mut map = HashMap::new();
        map.insert("name", self.name.clone());
        map.insert(
            "columns",
            self.columns
                .iter()
                .map(|c| serde_json::to_string(c).unwrap())
                .collect(),
        );
        serde_json::to_string(&map).unwrap()
    }
}

#[derive(Clone, Debug)]
pub struct Column {
    pub name: String,
    pub type_: ColumnType,
}

#[derive(Clone, Debug, Serialize)]
pub enum ColumnType {
    String,
    Int,
    BigInt,
    Boolean,
    Float,
    Double,
    Decimal,
    Char,
    Timestamp,
    Date,
    DateTime,
    Time,
}

impl Serialize for Column {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("Column", 2)?;
        state.serialize_field("name", &self.name)?;
        state.serialize_field("type_", &self.type_)?;
        state.end()
    }
}

impl<'a> From<Type<'a>> for ColumnType {
    fn from(data_type: Type<'a>) -> Self {
        match data_type {
            Type::Boolean => ColumnType::Boolean,
            Type::Integer(..) => ColumnType::Int,
            Type::BigInt(..) => ColumnType::BigInt,
            Type::Float(..) => ColumnType::Float,
            Type::Double(..) => ColumnType::Double,
            Type::TinyInt(..) => ColumnType::Decimal,
            Type::SmallInt(..) => ColumnType::Decimal,
            Type::Char(..) => ColumnType::Char,
            Type::VarChar(..) => ColumnType::String,
            Type::Text(..) => ColumnType::String,
            Type::Timestamp(..) => ColumnType::Timestamp,
            Type::DateTime(..) => ColumnType::DateTime,
            Type::Time(..) => ColumnType::Time,
            _ => ColumnType::String,
        }
    }
}

#[derive(Clone, Debug, Serialize)]
pub struct Constraint {
    pub name: String,
}