sql_query_builder 1.0.4

Write SQL queries in a simple and composable way
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

use pretty_assertions::assert_eq;
use sql_query_builder as sql;

#[test]
fn insert_builder_should_be_displayable() {
  let insert = sql::Insert::new()
    .insert_into("users(login, name)")
    .values("('foo', 'Foo')");

  println!("{}", insert);

  let query = insert.as_string();
  let expected_query = "INSERT INTO users(login, name) VALUES ('foo', 'Foo')";

  assert_eq!(query, expected_query);
}

#[test]
fn insert_builder_should_be_debuggable() {
  let insert = sql::Insert::new()
    .insert_into("users(login, name)")
    .values("('foo', 'Foo')")
    .overriding("user value");

  println!("{:?}", insert);

  let expected_query = "INSERT INTO users(login, name) OVERRIDING user value VALUES ('foo', 'Foo')";
  let query = insert.as_string();

  assert_eq!(query, expected_query);
}

#[test]
fn insert_builder_should_be_cloneable() {
  let insert_foo = sql::Insert::new()
    .raw("/* test raw */")
    .raw_before(sql::InsertClause::Values, "/* test raw_before */")
    .raw_after(sql::InsertClause::Values, "/* test raw_after */")
    .insert_into("users(login, name)")
    .values("('foo', 'Foo')");
  let insert_foo_bar = insert_foo.clone().values("('bar', 'Bar')");
  let query_foo = insert_foo.as_string();
  let query_foo_bar = insert_foo_bar.as_string();

  let expected_query_foo = "\
    /* test raw */ \
    INSERT INTO users(login, name) \
    /* test raw_before */ \
    VALUES ('foo', 'Foo') \
    /* test raw_after */\
  ";
  let expected_query_foo_bar = "\
    /* test raw */ \
    INSERT INTO users(login, name) \
    /* test raw_before */ \
    VALUES ('foo', 'Foo'), ('bar', 'Bar') \
    /* test raw_after */\
  ";

  assert_eq!(query_foo, expected_query_foo);
  assert_eq!(query_foo_bar, expected_query_foo_bar);
}

#[test]
fn insert_builder_should_be_able_to_conditionally_add_clauses() {
  let mut insert = sql::Insert::new()
    .insert_into("users(login, name)")
    .values("('bar', 'Bar')");

  if true {
    insert = insert.overriding("system value");
  }

  let query = insert.as_string();
  let expected_query = "INSERT INTO users(login, name) OVERRIDING system value VALUES ('bar', 'Bar')";

  assert_eq!(query, expected_query);
}

#[test]
fn insert_builder_should_be_composable() {
  fn insert(insert: sql::Insert) -> sql::Insert {
    insert.insert_into("users (login, name)")
  }

  fn values(insert: sql::Insert) -> sql::Insert {
    insert
      .values("('foo', 'Foo')")
      .values("('bar', 'Bar')")
      .values("('max', 'Max')")
  }

  fn as_string(insert: sql::Insert) -> String {
    insert.as_string()
  }

  let query = Some(sql::Insert::new()).map(insert).map(values).map(as_string).unwrap();

  let expected_query = "\
      INSERT INTO users (login, name) \
      VALUES \
      ('foo', 'Foo'), \
      ('bar', 'Bar'), \
      ('max', 'Max')\
    ";

  assert_eq!(query, expected_query);
}