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

use pretty_assertions::assert_eq;
use sql_query_builder as sql;

#[test]
fn values_builder_should_be_displayable() {
  let values = sql::Values::new().values("('foo', 'Foo')").values("('bar', 'Bar')");

  println!("{}", values);

  let query = values.as_string();
  let expected_query = "VALUES ('foo', 'Foo'), ('bar', 'Bar')";

  assert_eq!(query, expected_query);
}

#[test]
fn values_builder_should_be_debuggable() {
  let values = sql::Values::new().values("('foo', 'Foo')").values("('bar', 'Bar')");

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

  let expected_query = "VALUES ('foo', 'Foo'), ('bar', 'Bar')";
  let query = values.as_string();

  assert_eq!(query, expected_query);
}

#[test]
fn values_builder_should_be_cloneable() {
  let values_foo = sql::Values::new()
    .raw("/* test raw */")
    .raw_before(sql::ValuesClause::Values, "/* test raw_before */")
    .values("('foo', 'Foo')")
    .raw_after(sql::ValuesClause::Values, "/* test raw_after */");

  let values_foo_bar = values_foo.clone().values("('bar', 'Bar')");

  let query_foo = values_foo.as_string();
  let query_foo_bar = values_foo_bar.as_string();

  let expected_query_foo = "\
    /* test raw */ \
    /* test raw_before */ \
    VALUES ('foo', 'Foo') \
    /* test raw_after */\
  ";
  let expected_query_foo_bar = "\
    /* test raw */ \
    /* 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 values_builder_should_be_able_to_conditionally_add_clauses() {
  let mut values = sql::Values::new().values("('foo', 'Foo')");

  if true {
    values = values.values("('bar', 'Bar')");
  }

  let query = values.as_string();
  let expected_query = "VALUES ('foo', 'Foo'), ('bar', 'Bar')";

  assert_eq!(query, expected_query);
}

#[test]
fn values_builder_should_be_composable() {
  fn value_foo(values: sql::Values) -> sql::Values {
    values.values("('foo', 'Foo')")
  }

  fn value_bar(values: sql::Values) -> sql::Values {
    values.values("('bar', 'Bar')")
  }

  fn as_string(values: sql::Values) -> String {
    values.as_string()
  }

  let query = Some(sql::Values::new())
    .map(value_foo)
    .map(value_bar)
    .map(as_string)
    .unwrap();

  let expected_query = "\
      VALUES ('foo', 'Foo'), ('bar', 'Bar')\
    ";

  assert_eq!(query, expected_query);
}