sqlint 0.2.2

An abstraction layer for SQL databases.
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

use super::TestApi;
use crate::{connector::Queryable, single::Sqlint};
use names::Generator;
use once_cell::sync::Lazy;
use std::env;
use test_setup::Tags;

pub static CONN_STR: Lazy<String> = Lazy::new(|| env::var("TEST_PSQL").expect("TEST_PSQL env var"));
pub static CRDB_CONN_STR: Lazy<String> = Lazy::new(|| env::var("TEST_CRDB").expect("TEST_CRDB env var"));

pub(crate) async fn postgresql_test_api<'a>() -> crate::Result<PostgreSql<'a>> {
    PostgreSql::new().await
}

pub struct PostgreSql<'a> {
    names: Generator<'a>,
    conn: Sqlint,
}

impl<'a> PostgreSql<'a> {
    pub async fn new() -> crate::Result<PostgreSql<'a>> {
        let names = Generator::default();
        let conn = Sqlint::new(&CONN_STR).await?;

        Ok(Self { names, conn })
    }
}

#[async_trait::async_trait]
impl<'a> TestApi for PostgreSql<'a> {
    fn system(&self) -> &'static str {
        "postgres"
    }

    async fn create_type_table(&mut self, r#type: &str) -> crate::Result<String> {
        self.create_temp_table(&format!("{}, value {}", self.autogen_id("id"), r#type)).await
    }

    async fn create_table(&mut self, _columns: &str) -> crate::Result<String> {
        unimplemented!("only required for MySql nested sub select test")
    }

    async fn delete_table(&mut self, _table_name: &str) -> crate::Result<()> {
        unimplemented!("only required for MySql nested sub select test")
    }

    async fn create_temp_table(&mut self, columns: &str) -> crate::Result<String> {
        let name = self.get_name();

        let (name, create) = self.render_create_table(&name, columns);

        self.conn().raw_cmd(&create).await?;

        Ok(name)
    }

    fn render_create_table(&mut self, table_name: &str, columns: &str) -> (String, String) {
        let create = format!(
            r##"
            CREATE TEMPORARY TABLE "{table_name}" ({columns})
            "##,
        );

        (table_name.to_string(), create)
    }

    async fn create_index(&mut self, table: &str, columns: &str) -> crate::Result<String> {
        let name = self.get_name();

        let create = format!(
            r##"
            CREATE UNIQUE INDEX {name} ON {table} ({columns})
            "##
        );

        self.conn().raw_cmd(&create).await?;

        Ok(name)
    }

    fn conn(&self) -> &Sqlint {
        &self.conn
    }

    async fn create_additional_connection(&self) -> crate::Result<Sqlint> {
        Sqlint::new(&CONN_STR).await
    }

    fn unique_constraint(&mut self, column: &str) -> String {
        format!("UNIQUE({column})")
    }

    fn foreign_key(&mut self, parent_table: &str, parent_column: &str, child_column: &str) -> String {
        let name = self.get_name();

        format!("CONSTRAINT {} FOREIGN KEY ({}) REFERENCES {}({})", &name, child_column, parent_table, parent_column)
    }

    fn autogen_id(&self, name: &str) -> String {
        format!("{name} SERIAL PRIMARY KEY")
    }

    fn get_name(&mut self) -> String {
        self.names.next().unwrap().replace('-', "")
    }

    fn connector_tag(&self) -> test_setup::Tags {
        Tags::POSTGRES
    }
}