sql_reverse 0.1.21

Generate the multiple programming languages structure based on the MySQL/PostgresSQL table structure
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

use app_arguments::{ApplicationArguments, Command};
mod app_arguments;
mod error;
mod keywords;
mod reverse_impl;
mod table;
mod template;

use crate::error::Result;
use crate::keywords::get_or_init;
use crate::reverse_impl::export::export;
use crate::reverse_impl::gen_struct::GenStruct;
use crate::reverse_impl::clickhouse_impl::ClickhouseImpl;
use crate::reverse_impl::mysql_impl::MysqlImpl;
use crate::reverse_impl::postgres_impl::PostgresImpl;
use crate::reverse_impl::sqlite_impl::SqliteImpl;
use crate::table::Table;
use crate::template::kit::Kit;
use crate::template::render::Render;
use crate::template::template_type::{TemplateType, update_template_type};
use structopt::StructOpt;

#[tokio::main]
async fn main() -> Result<()> {
    let args = ApplicationArguments::from_args();
    let key = args.command;
    match key {
        Command::Mysql(opt) => {
            update_template_type(TemplateType::Mysql);
            get_or_init(&opt.suffix).await;
            let config = MysqlImpl::load(&opt.file).await?;
            let mysql = MysqlImpl::init(config).await?;
            let tables = mysql.run(&opt.custom_field_type).await?;
            Table::check_download_tera(&opt.template_path, &opt.template_name).await?;
            Table::render_rust(
                &opt.template_path,
                &opt.template_name,
                &opt.suffix,
                &mysql.config.output_dir,
                &tables,
            )
            .await?;
        }

        Command::Postgres(opt) => {
            update_template_type(TemplateType::Postgres);
            get_or_init(&opt.suffix).await;
            let config = PostgresImpl::load(&opt.file).await?;
            let postgres = PostgresImpl::init(config).await?;
            let tables = postgres.run(&opt.custom_field_type).await?;
            Table::check_download_tera(&opt.template_path, &opt.template_name).await?;
            Table::render_rust(
                &opt.template_path,
                &opt.template_name,
                &opt.suffix,
                &postgres.config.output_dir,
                &tables,
            )
            .await?;
        }
        Command::Sqlite(opt) => {
            update_template_type(TemplateType::Sqlite);
            get_or_init(&opt.suffix).await;
            let config = SqliteImpl::load(&opt.file).await?;
            let sqlite = SqliteImpl::init(config).await?;
            let tables = sqlite.run(&opt.custom_field_type).await?;
            Table::check_download_tera(&opt.template_path, &opt.template_name).await?;
            Table::render_rust(
                &opt.template_path,
                &opt.template_name,
                &opt.suffix,
                &sqlite.config.output_dir,
                &tables,
            )
            .await?;
        }
        Command::Clickhouse(opt) => {
            update_template_type(TemplateType::Clickhouse);
            get_or_init(&opt.suffix).await;
            let config = ClickhouseImpl::load(&opt.file).await?;
            let clickhouse = ClickhouseImpl::init(config).await?;
            let tables = clickhouse.run(&opt.custom_field_type).await?;
            Table::check_download_tera(&opt.template_path, &opt.template_name).await?;
            Table::render_rust(
                &opt.template_path,
                &opt.template_name,
                &opt.suffix,
                &clickhouse.config.output_dir,
                &tables,
            )
            .await?;
        }
        Command::Export => {
            export().await?;
        }
    }
    Ok(())
}