mod where_clause {
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
mod create_index_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_clause_should_add_the_where_clause() {
let query = sql::CreateIndex::new().where_clause("created_at >= $1").as_string();
let expected_query = "WHERE created_at >= $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_omit_the_operation_when_was_the_first_clause() {
let query = sql::CreateIndex::new().where_clause("status = 'active'").as_string();
let expected_query = "WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_accumulate_values_on_consecutive_calls_using_the_and_operator() {
let query = sql::CreateIndex::new()
.where_clause("created_at >= $1")
.where_clause("status = 'active'")
.as_string();
let expected_query = "\
WHERE \
created_at >= $1 \
AND status = 'active'\
";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_not_accumulate_values_when_expression_is_empty() {
let query = sql::CreateIndex::new()
.where_clause("")
.where_clause("status = 'active'")
.where_clause("")
.as_string();
let expected_query = "WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_not_accumulate_arguments_with_the_same_content() {
let query = sql::CreateIndex::new()
.where_clause("status = 'active'")
.where_clause("status = 'active'")
.as_string();
let expected_query = "WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_trim_space_of_the_argument() {
let query = sql::CreateIndex::new()
.where_clause(" status = 'active' ")
.as_string();
let expected_query = "WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_before_should_add_raw_sql_before_where_clause() {
let query = sql::CreateIndex::new()
.raw_before(sql::CreateIndexParams::Where, "/* uncommon parameter */")
.where_clause("status = 'active'")
.as_string();
let expected_query = "/* uncommon parameter */ WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_after_should_add_raw_sql_after_where_clause() {
let query = sql::CreateIndex::new()
.where_clause("created_at >= $1")
.raw_after(sql::CreateIndexParams::Where, "and created_at < $2")
.as_string();
let expected_query = "WHERE created_at >= $1 and created_at < $2";
assert_eq!(query, expected_query);
}
}
mod delete_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_clause_should_add_the_where_clause() {
let query = sql::Delete::new().where_clause("id = $1").as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_omit_the_operation_when_was_the_first_clause() {
let query = sql::Delete::new().where_clause("login = 'foo'").as_string();
let expected_query = "WHERE login = 'foo'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_accumulate_values_on_consecutive_calls_using_the_and_operator() {
let query = sql::Delete::new()
.where_clause("id = $1")
.where_clause("status = 'pending'")
.as_string();
let expected_query = "\
WHERE \
id = $1 \
AND status = 'pending'\
";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_not_accumulate_values_when_expression_is_empty() {
let query = sql::Delete::new()
.where_clause("")
.where_clause("status = 'pending'")
.where_clause("")
.as_string();
let expected_query = "WHERE status = 'pending'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_not_accumulate_arguments_with_the_same_content() {
let query = sql::Delete::new()
.where_clause("id = $1")
.where_clause("id = $1")
.as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_trim_space_of_the_argument() {
let query = sql::Delete::new().where_clause(" id = $1 ").as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn clause_where_should_be_after_delete_from_clause() {
let query = sql::Delete::new()
.where_clause("name = $1")
.delete_from("users")
.as_string();
let expected_query = "DELETE FROM users WHERE name = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_before_should_add_raw_sql_before_where_clause() {
let query = sql::Delete::new()
.raw_before(sql::DeleteClause::Where, "delete from users")
.where_clause("login = $1")
.as_string();
let expected_query = "delete from users WHERE login = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_after_should_add_raw_sql_after_where_clause() {
let query = sql::Delete::new()
.where_clause("created_at::date >= $1")
.raw_after(sql::DeleteClause::Where, "and created_at::date < $2")
.as_string();
let expected_query = "WHERE created_at::date >= $1 and created_at::date < $2";
assert_eq!(query, expected_query);
}
}
mod select_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_clause_should_add_the_where_clause() {
let query = sql::Select::new()
.where_clause("created_at::date = current_date")
.as_string();
let expected_query = "WHERE created_at::date = current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_omit_the_operation_when_was_the_first_clause() {
let query = sql::Select::new().where_clause("login = 'foo'").as_string();
let expected_query = "WHERE login = 'foo'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_accumulate_values_on_consecutive_calls_using_the_and_operator() {
let query = sql::Select::new()
.where_clause("created_at::date > current_date - INTERVAL '2 days'")
.where_clause("created_at::date <= current_date")
.as_string();
let expected_query = "\
WHERE \
created_at::date > current_date - INTERVAL '2 days' \
AND created_at::date <= current_date\
";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_not_accumulate_values_when_expression_is_empty() {
let query = sql::Select::new()
.where_clause("")
.where_clause("created_at::date <= current_date")
.where_clause("")
.as_string();
let expected_query = "WHERE created_at::date <= current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_trim_space_of_the_argument() {
let query = sql::Select::new().where_clause(" id = $1 ").as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_not_accumulate_arguments_with_the_same_content() {
let query = sql::Select::new()
.where_clause("active = true")
.where_clause("active = true")
.as_string();
let expected_query = "WHERE active = true";
assert_eq!(query, expected_query);
}
#[test]
fn clause_where_should_be_after_any_of_the_joins_clauses() {
let query = sql::Select::new()
.where_clause("user.login = $1")
.inner_join("addresses ON users.login = addresses.login")
.as_string();
let expected_query = "INNER JOIN addresses ON users.login = addresses.login WHERE user.login = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_before_should_add_raw_sql_before_where_clause() {
let query = sql::Select::new()
.raw_before(sql::SelectClause::Where, "from orders")
.where_clause("created_at::date = current_date")
.as_string();
let expected_query = "from orders WHERE created_at::date = current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_after_should_add_raw_sql_after_where_clause() {
let query = sql::Select::new()
.where_clause("created_at::date = current_date")
.raw_after(sql::SelectClause::Where, "limit 10")
.as_string();
let expected_query = "WHERE created_at::date = current_date limit 10";
assert_eq!(query, expected_query);
}
}
mod update_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_clause_should_add_the_where_clause() {
let query = sql::Update::new().where_clause("id = $1").as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_accumulate_values_on_consecutive_calls_using_the_and_operator() {
let query = sql::Update::new()
.where_clause("id = $1")
.where_clause("status = 'pending'")
.as_string();
let expected_query = "\
WHERE \
id = $1 \
AND status = 'pending'\
";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_not_accumulate_values_when_expression_is_empty() {
let query = sql::Update::new()
.where_clause("")
.where_clause("status = 'pending'")
.where_clause("")
.as_string();
let expected_query = "WHERE status = 'pending'";
assert_eq!(query, expected_query);
}
#[test]
fn clause_where_should_be_after_set_clause() {
let query = sql::Update::new()
.set("name = $1")
.where_clause("login = $2")
.as_string();
let expected_query = "SET name = $1 WHERE login = $2";
assert_eq!(query, expected_query);
}
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
#[test]
fn clause_where_should_be_after_from_clause() {
let query = sql::Update::new().where_or("user.login = $1").from("users").as_string();
let expected_query = "FROM users WHERE user.login = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_not_accumulate_arguments_with_the_same_content() {
let query = sql::Update::new()
.where_clause("id = $1")
.where_clause("id = $1")
.as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_clause_should_trim_space_of_the_argument() {
let query = sql::Update::new().where_clause(" id = $1 ").as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_before_should_add_raw_sql_before_where_clause() {
let query = sql::Update::new()
.raw_before(sql::UpdateClause::Where, "set name = $1")
.where_clause("login = $2")
.as_string();
let expected_query = "set name = $1 WHERE login = $2";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_after_should_add_raw_sql_after_where_clause() {
let query = sql::Update::new()
.where_clause("created_at::date >= $1")
.raw_after(sql::UpdateClause::Where, "and created_at::date < $2")
.as_string();
let expected_query = "WHERE created_at::date >= $1 and created_at::date < $2";
assert_eq!(query, expected_query);
}
}
}
mod where_and {
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
mod create_index_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_and_should_be_an_alias_of_where_clause() {
let query = sql::CreateIndex::new()
.where_and("active = 'true'")
.where_and("created_at >= $1")
.as_string();
let expected_query = "WHERE active = 'true' AND created_at >= $1";
assert_eq!(query, expected_query);
}
}
mod delete_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_and_should_be_an_alias_of_where_clause() {
let query = sql::Delete::new().where_and("login = $1").as_string();
let expected_query = "WHERE login = $1";
assert_eq!(query, expected_query);
}
}
mod select_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_and_should_be_an_alias_of_where_clause() {
let query = sql::Select::new().where_and("login = $1").as_string();
let expected_query = "WHERE login = $1";
assert_eq!(query, expected_query);
}
}
mod update_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_and_should_be_an_alias_of_where_clause() {
let query = sql::Update::new().where_and("login = $1").as_string();
let expected_query = "WHERE login = $1";
assert_eq!(query, expected_query);
}
}
}
mod where_or {
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
mod create_index_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_or_should_add_the_where_clause() {
let query = sql::CreateIndex::new().where_or("created_at >= $1").as_string();
let expected_query = "WHERE created_at >= $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_omit_the_operation_when_was_the_first_clause() {
let query = sql::CreateIndex::new().where_or("created_at >= $1").as_string();
let expected_query = "WHERE created_at >= $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_accumulate_values_on_consecutive_calls_using_the_or_operator() {
let query = sql::CreateIndex::new()
.where_or("created_at >= $1")
.where_or("status = 'active'")
.as_string();
let expected_query = "\
WHERE \
created_at >= $1 \
OR status = 'active'\
";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_not_accumulate_values_when_expression_is_empty() {
let query = sql::CreateIndex::new()
.where_or("")
.where_or("status = 'active'")
.where_or("")
.as_string();
let expected_query = "WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_trim_space_of_the_argument() {
let query = sql::CreateIndex::new().where_or(" status = 'active' ").as_string();
let expected_query = "WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_not_accumulate_arguments_with_the_same_content() {
let query = sql::CreateIndex::new()
.where_or("status = 'active'")
.where_or("status = 'active'")
.as_string();
let expected_query = "WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_before_should_add_raw_sql_before_where_clause() {
let query = sql::CreateIndex::new()
.raw_before(sql::CreateIndexParams::Where, "/* uncommon parameter */")
.where_or("status = 'active'")
.as_string();
let expected_query = "/* uncommon parameter */ WHERE status = 'active'";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_after_should_add_raw_sql_after_where_clause() {
let query = sql::CreateIndex::new()
.where_or("status = 'active'")
.raw_after(sql::CreateIndexParams::Where, "/* uncommon parameter */")
.as_string();
let expected_query = "WHERE status = 'active' /* uncommon parameter */";
assert_eq!(query, expected_query);
}
}
mod delete_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_or_should_add_the_where_clause() {
let query = sql::Delete::new()
.where_or("created_at::date = current_date")
.as_string();
let expected_query = "WHERE created_at::date = current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_omit_the_operation_when_was_the_first_clause() {
let query = sql::Delete::new().where_or("login = 'foo'").as_string();
let expected_query = "WHERE login = 'foo'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_accumulate_values_on_consecutive_calls_using_the_or_operator() {
let query = sql::Delete::new()
.where_or("login = 'foo'")
.where_or("login = 'bar'")
.as_string();
let expected_query = "\
WHERE \
login = 'foo' \
OR login = 'bar'\
";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_not_accumulate_values_when_expression_is_empty() {
let query = sql::Delete::new()
.where_or("")
.where_or("login = 'bar'")
.where_or("")
.as_string();
let expected_query = "WHERE login = 'bar'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_trim_space_of_the_argument() {
let query = sql::Delete::new().where_or(" id = $1 ").as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_not_accumulate_arguments_with_the_same_content() {
let query = sql::Delete::new()
.where_or("active = true")
.where_or("active = true")
.as_string();
let expected_query = "WHERE active = true";
assert_eq!(query, expected_query);
}
#[test]
fn clause_where_should_be_after_delete_from_clause() {
let query = sql::Delete::new()
.where_or("user.login = $1")
.delete_from("users")
.as_string();
let expected_query = "DELETE FROM users WHERE user.login = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_before_should_add_raw_sql_before_where_clause() {
let query = sql::Delete::new()
.raw_before(sql::DeleteClause::Where, "delete from orders")
.where_or("created_at::date = current_date")
.as_string();
let expected_query = "delete from orders WHERE created_at::date = current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_after_should_add_raw_sql_after_where_clause() {
let query = sql::Delete::new()
.where_or("created_at::date = current_date")
.raw_after(sql::DeleteClause::Where, "/* end of the delete clause */")
.as_string();
let expected_query = "WHERE created_at::date = current_date /* end of the delete clause */";
assert_eq!(query, expected_query);
}
}
mod select_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_or_should_add_the_where_clause() {
let query = sql::Select::new()
.where_or("created_at::date = current_date")
.as_string();
let expected_query = "WHERE created_at::date = current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_omit_the_operation_when_was_the_first_clause() {
let query = sql::Select::new().where_or("login = 'foo'").as_string();
let expected_query = "WHERE login = 'foo'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_accumulate_values_on_consecutive_calls_using_the_or_operator() {
let query = sql::Select::new()
.where_or("login = 'foo'")
.where_or("login = 'bar'")
.as_string();
let expected_query = "\
WHERE \
login = 'foo' \
OR login = 'bar'\
";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_not_accumulate_values_when_expression_is_empty() {
let query = sql::Select::new()
.where_or("")
.where_or("login = 'bar'")
.where_or("")
.as_string();
let expected_query = "WHERE login = 'bar'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_trim_space_of_the_argument() {
let query = sql::Select::new().where_or(" id = $1 ").as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_not_accumulate_arguments_with_the_same_content() {
let query = sql::Select::new()
.where_or("active = true")
.where_or("active = true")
.as_string();
let expected_query = "WHERE active = true";
assert_eq!(query, expected_query);
}
#[test]
fn clause_where_should_be_after_any_of_the_joins_clauses() {
let query = sql::Select::new()
.where_or("user.login = $1")
.inner_join("addresses ON users.login = addresses.login")
.as_string();
let expected_query = "INNER JOIN addresses ON users.login = addresses.login WHERE user.login = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_before_should_add_raw_sql_before_where_clause() {
let query = sql::Select::new()
.raw_before(sql::SelectClause::Where, "from orders")
.where_or("created_at::date = current_date")
.as_string();
let expected_query = "from orders WHERE created_at::date = current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_after_should_add_raw_sql_after_where_clause() {
let query = sql::Select::new()
.where_or("created_at::date = current_date")
.raw_after(sql::SelectClause::Where, "limit 10")
.as_string();
let expected_query = "WHERE created_at::date = current_date limit 10";
assert_eq!(query, expected_query);
}
}
mod update_command {
use pretty_assertions::assert_eq;
use sql_query_builder as sql;
#[test]
fn method_where_or_should_add_the_where_clause() {
let query = sql::Update::new()
.where_or("created_at::date = current_date")
.as_string();
let expected_query = "WHERE created_at::date = current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_omit_the_operation_when_was_the_first_clause() {
let query = sql::Update::new().where_or("login = 'foo'").as_string();
let expected_query = "WHERE login = 'foo'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_accumulate_values_on_consecutive_calls_using_the_or_operator() {
let query = sql::Update::new()
.where_or("login = 'foo'")
.where_or("login = 'bar'")
.as_string();
let expected_query = "\
WHERE \
login = 'foo' \
OR login = 'bar'\
";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_not_accumulate_values_when_expression_is_empty() {
let query = sql::Update::new()
.where_or("")
.where_or("login = 'bar'")
.where_or("")
.as_string();
let expected_query = "WHERE login = 'bar'";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_trim_space_of_the_argument() {
let query = sql::Update::new().where_or(" id = $1 ").as_string();
let expected_query = "WHERE id = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_where_or_should_not_accumulate_arguments_with_the_same_content() {
let query = sql::Update::new()
.where_or("active = true")
.where_or("active = true")
.as_string();
let expected_query = "WHERE active = true";
assert_eq!(query, expected_query);
}
#[test]
fn clause_where_should_be_after_set_clause() {
let query = sql::Update::new()
.where_or("user.login = $1")
.set("users.name = 'Foo'")
.as_string();
let expected_query = "SET users.name = 'Foo' WHERE user.login = $1";
assert_eq!(query, expected_query);
}
#[cfg(any(feature = "postgresql", feature = "sqlite"))]
#[test]
fn clause_where_should_be_after_from_clause() {
let query = sql::Update::new().where_or("user.login = $1").from("users").as_string();
let expected_query = "FROM users WHERE user.login = $1";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_before_should_add_raw_sql_before_where_clause() {
let query = sql::Update::new()
.raw_before(sql::UpdateClause::Where, "SET users.name = 'Foo'")
.where_or("created_at::date = current_date")
.as_string();
let expected_query = "SET users.name = 'Foo' WHERE created_at::date = current_date";
assert_eq!(query, expected_query);
}
#[test]
fn method_raw_after_should_add_raw_sql_after_where_clause() {
let query = sql::Update::new()
.where_or("created_at::date = current_date")
.raw_after(sql::UpdateClause::Where, "/* end of the update clause */")
.as_string();
let expected_query = "WHERE created_at::date = current_date /* end of the update clause */";
assert_eq!(query, expected_query);
}
}
}