welds-connections 0.4.0

An async ORM for (postgres, mssql, mysql, sqlite)
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


head = %Q|
use super::*;

#[cfg(any(feature = "sqlite", feature = "postgres", feature = "mysql"))]
use sqlx::Row as SqlxRow;
|

def blocky(cfg, wheres)
  %Q|

#{cfg}
impl Row {
    pub fn get<T>(&self, name: &str) -> Result<T>
      where T: #{wheres}
    {
        match &self.inner {
            #[cfg(feature = "sqlite")]
            RowInner::Sqlite(r) => Ok(r.try_get(name)?),
            #[cfg(feature = "mssql")]
            RowInner::Mssql(r) => r.try_get(name),
            #[cfg(feature = "postgres")]
            RowInner::Postgres(r) => Ok(r.try_get(name)?),
            #[cfg(feature = "mysql")]
            RowInner::Mysql(r) => Ok(r.try_get(name)?),
        }
    }

    pub fn get_by_position<T>(&self, index: usize) -> Result<T>
      where T: #{wheres}
    {
        match &self.inner {
            #[cfg(feature = "sqlite")]
            RowInner::Sqlite(r) => Ok(r.try_get(index)?),
            #[cfg(feature = "mssql")]
            RowInner::Mssql(r) => r.try_get_by_posision(index),
            #[cfg(feature = "postgres")]
            RowInner::Postgres(r) => Ok(r.try_get(index)?),
            #[cfg(feature = "mysql")]
            RowInner::Mysql(r) => Ok(r.try_get(index)?),
        }
    }
}

|


end

p = [
  ["sqlite"  , "for<'r> Decode<'r, sqlx::Sqlite> + Type<sqlx::Sqlite>"],
  ["postgres", "for<'r> Decode<'r, sqlx::Postgres> + Type<sqlx::Postgres>"],
  ["mysql"   , "for<'r> Decode<'r, sqlx::MySql> + Type<sqlx::MySql>"],
  ["mssql"   , "TiberiusDecode"],
]

cc = p.combination(1) + p.combination(2) + p.combination(3) + p.combination(4)

all = ["sqlite", "postgres", "mysql", "mssql"]

full = head

cc.each do |c| 

  enabled_list = c.map{|a| a[0] } 
  disabled_list = all - enabled_list
  
  enabled = enabled_list.map{|f| "feature = \"#{f}\""}
  disabled = disabled_list.map{|f| "not(feature = \"#{f}\")"}
  rules = enabled + disabled
  cfgs = "#[cfg(all(#{rules.join(", ")}))]"

  wheres = c.map{|a| a[1]}
  wheres = wheres.join(" + ")

  full = full + "\n\n" + blocky(cfgs, wheres)
end


puts full