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
111

use super::*;

impl<C, R, T, S> update::Update<C, R, T> for S
where S: update::UpdateStatement,
      C: Connection<R>,
      R: Row,
      T: params::Params + row::TryFromRefRow<R>,
{
  fn update(&self, conn: &mut C, object: &T) -> Result<()> {
    conn.execute_with_params(self.update_stmt()?, object)?;
    Ok(())
  }

  fn update_with_filter<F>(&self, conn: &mut C, filter: &F, object: &T) -> Result<()>
  where F: traits::Filter
  {
    conn.execute_with_params(self.update_with_filter_stmt(filter)?, object)?;
    Ok(())
  }

  fn update_with_filter_order_limit_offset<F, O>(&self, conn: &mut C, filter: &F, order: &O, limit: usize, offset: usize, object: &T) -> Result<()>
  where F: traits::Filter, O: Order,
  {
    conn.execute_with_params(self.update_with_filter_order_limit_offset_stmt(filter, order, limit, offset)?, object)?;
    Ok(())
  }
}

impl<C, R, S> delete::Delete<C, R> for S
where S: delete::DeleteStatement,
      C: Connection<R>,
      R: Row,
{
  fn delete(&self, conn: &mut C) -> Result<()> {
    conn.query_drop(self.delete_stmt()?)?;
    Ok(())
  }

  fn delete_with_filter<F>(&self, conn: &mut C, filter: &F) -> Result<()> 
  where F: traits::Filter
  {
    conn.query_drop(self.delete_with_filter_stmt(filter)?)?;
    Ok(())
  }

  fn delete_with_filter_order_limit_offset<F, O>(&self, conn: &mut C, filter: &F, order: &O, limit: usize, offset: usize) -> Result<()> 
  where F: traits::Filter, O: Order,
  {
    conn.query_drop(self.delete_with_filter_order_limit_offset_stmt(filter, order, limit, offset)?)?;
    Ok(())
  }
}

impl<C, R, T, S> insert::Insert<C, R, T> for S
where S: insert::InsertStatement,
      T: params::Params,
      C: Connection<R>,
      R: Row,
{
  fn insert(&self, conn: &mut C, object: &T) -> Result<()> {
    conn.execute_with_params(self.insert_stmt()?, object)?;
    Ok(())
  }
}

impl<C, R, T, S> select::Select<C, R, T> for S
where S: select::SelectStatement,
      T: row::TryFromRefRow<R>,
      C: Connection<R>,
      R: Row,
{
  fn select(&self, conn: &mut C) -> Result<Vec<T>> {
    conn.query_try_as_object(self.select_stmt()?)
  }

  fn select_with_filter<F>(&self, conn: &mut C, filter: &F) -> Result<Vec<T>>
  where F: traits::Filter
  {
    conn.query_try_as_object(self.select_with_filter_stmt(filter)?)
  }

  fn select_with_filter_order<F, O>(&self, conn: &mut C, filter: &F, order: &O) -> Result<Vec<T>>
  where F: traits::Filter, O: traits::Order,
  {
    conn.query_try_as_object(self.select_with_filter_order_stmt(filter, order)?)
  }

  fn select_with_filter_order_limit_offset<F, O>(&self, conn: &mut C, filter: &F, order: &O, limit: usize, offset: usize) -> Result<Vec<T>> 
  where F: traits::Filter, O: traits::Order,
  {
    conn.query_try_as_object(self.select_with_filter_order_limit_offset_stmt(filter, order, limit, offset)?)
  }
}

impl<C, R, S> table::Table<C, R> for S
where S: table::TableStatement,
      C: Connection<R>,
      R: Row,
{
  fn create(&self, conn: &mut C) -> Result<()> {
    conn.query_drop(self.create_stmt()?)
  }

  fn create_if_not_exist(&self, conn: &mut C) -> Result<()> {
    conn.query_drop(self.create_if_not_exist_stmt()?)
  }

  fn drop(&self, conn: &mut C) -> Result<()> {
    conn.query_drop(self.drop_stmt()?)
  }
}