gobang 0.1.0-alpha.0

A cross-platform terminal database tool written in Rust
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

use crate::app::{Database, Table};
use chrono::NaiveDate;
use futures::TryStreamExt;
use sqlx::mysql::MySqlPool;
use sqlx::{Column, Executor, Row, TypeInfo};

pub async fn get_databases(pool: &MySqlPool) -> anyhow::Result<Vec<Database>> {
    let databases = sqlx::query("show databases")
        .fetch_all(pool)
        .await?
        .iter()
        .map(|table| table.get(0))
        .collect::<Vec<String>>();
    let mut list = vec![];
    for db in databases {
        list.push(Database::new(db, pool).await?)
    }
    Ok(list)
}

pub async fn get_tables(database: String, pool: &MySqlPool) -> anyhow::Result<Vec<Table>> {
    let tables = sqlx::query(format!("show tables from `{}`", database).as_str())
        .fetch_all(pool)
        .await?
        .iter()
        .map(|table| Table { name: table.get(0) })
        .collect::<Vec<Table>>();
    Ok(tables)
}

pub async fn get_records(
    database: &Database,
    table: &Table,
    pool: &MySqlPool,
) -> anyhow::Result<(Vec<String>, Vec<Vec<String>>)> {
    pool.execute(format!("use `{}`", database.name).as_str())
        .await?;
    let table_name = format!("SELECT * FROM `{}`", table.name);
    let mut rows = sqlx::query(table_name.as_str()).fetch(pool);
    let headers = sqlx::query(format!("desc `{}`", table.name).as_str())
        .fetch_all(pool)
        .await?
        .iter()
        .map(|table| table.get(0))
        .collect::<Vec<String>>();
    let mut records = vec![];
    while let Some(row) = rows.try_next().await? {
        let mut row_vec = vec![];
        for col in row.columns() {
            let col_name = col.name();
            match col.type_info().clone().name() {
                "INT" | "DECIMAL" | "SMALLINT" => match row.try_get(col_name) {
                    Ok(value) => {
                        let value: i64 = value;
                        row_vec.push(value.to_string())
                    }
                    Err(_) => row_vec.push("".to_string()),
                },
                "INT UNSIGNED" => match row.try_get(col_name) {
                    Ok(value) => {
                        let value: u64 = value;
                        row_vec.push(value.to_string())
                    }
                    Err(_) => row_vec.push("".to_string()),
                },
                "VARCHAR" | "CHAR" => {
                    let value: String = row.try_get(col_name).unwrap_or("".to_string());
                    row_vec.push(value);
                }
                "DATE" => match row.try_get(col_name) {
                    Ok(value) => {
                        let value: NaiveDate = value;
                        row_vec.push(value.to_string())
                    }
                    Err(_) => row_vec.push("".to_string()),
                },
                "TIMESTAMP" => match row.try_get(col_name) {
                    Ok(value) => {
                        let value: chrono::DateTime<chrono::Utc> = value;
                        row_vec.push(value.to_string())
                    }
                    Err(_) => row_vec.push("".to_string()),
                },
                "BOOLEAN" => match row.try_get(col_name) {
                    Ok(value) => {
                        let value: bool = value;
                        row_vec.push(value.to_string())
                    }
                    Err(_) => row_vec.push("".to_string()),
                },
                "ENUM" => {
                    let value: String = row.try_get(col_name).unwrap_or("".to_string());
                    row_vec.push(value);
                }
                _ => (),
            }
        }
        records.push(row_vec)
    }
    Ok((headers, records))
}