database::tests Namespace Reference

Classes
class	SQLQueryBuilderTest
class	UniversalQueryBuilderTest

Functions
	TEST_F (SQLQueryBuilderTest, SimpleSelect)
	TEST_F (SQLQueryBuilderTest, SelectAll)
	TEST_F (SQLQueryBuilderTest, InnerJoin)
	TEST_F (SQLQueryBuilderTest, LeftJoin)
	TEST_F (SQLQueryBuilderTest, RightJoin)
	TEST_F (SQLQueryBuilderTest, FullOuterJoin)
	TEST_F (SQLQueryBuilderTest, CrossJoin)
	TEST_F (SQLQueryBuilderTest, MultipleJoins)
	TEST_F (SQLQueryBuilderTest, SimpleWhere)
	TEST_F (SQLQueryBuilderTest, WhereWithString)
	TEST_F (SQLQueryBuilderTest, WhereWithInt)
	TEST_F (SQLQueryBuilderTest, WhereWithDouble)
	TEST_F (SQLQueryBuilderTest, MultipleWhereConditions)
	TEST_F (SQLQueryBuilderTest, NestedConditionsWithAnd)
	TEST_F (SQLQueryBuilderTest, NestedConditionsWithOr)
	TEST_F (SQLQueryBuilderTest, GroupBy)
	TEST_F (SQLQueryBuilderTest, GroupByMultipleColumns)
	TEST_F (SQLQueryBuilderTest, GroupByWithHaving)
	TEST_F (SQLQueryBuilderTest, OrderByAsc)
	TEST_F (SQLQueryBuilderTest, OrderByDesc)
	TEST_F (SQLQueryBuilderTest, OrderByMultipleColumns)
	TEST_F (SQLQueryBuilderTest, Limit)
	TEST_F (SQLQueryBuilderTest, LimitWithOffset)
	TEST_F (SQLQueryBuilderTest, InsertSingleRow)
	TEST_F (SQLQueryBuilderTest, InsertMultipleRows)
	TEST_F (SQLQueryBuilderTest, UpdateSingleField)
	TEST_F (SQLQueryBuilderTest, UpdateMultipleFields)
	TEST_F (SQLQueryBuilderTest, DeleteWithWhere)
	TEST_F (SQLQueryBuilderTest, DeleteWithMultipleConditions)
	TEST_F (SQLQueryBuilderTest, PostgreSQLSyntax)
	TEST_F (SQLQueryBuilderTest, SQLiteSyntax)
	TEST_F (SQLQueryBuilderTest, Reset)
	TEST_F (SQLQueryBuilderTest, ReuseAfterReset)
	TEST_F (SQLQueryBuilderTest, ComplexSelectQuery)
	TEST_F (SQLQueryBuilderTest, EmptyConditions)
	TEST_F (SQLQueryBuilderTest, SwitchDatabase)
	TEST_F (UniversalQueryBuilderTest, PostgreSQLBuilder)
	TEST_F (UniversalQueryBuilderTest, SQLiteBuilder)
	TEST_F (UniversalQueryBuilderTest, SwitchDatabase)
	TEST_F (UniversalQueryBuilderTest, SelectQuery)
	TEST_F (UniversalQueryBuilderTest, JoinQuery)
	TEST_F (UniversalQueryBuilderTest, InsertData)
	TEST_F (UniversalQueryBuilderTest, UpdateData)
	TEST_F (UniversalQueryBuilderTest, Reset)
	TEST_F (UniversalQueryBuilderTest, DefaultConstructor)
	TEST_F (UniversalQueryBuilderTest, SetDatabaseAfterConstruction)
	TEST_F (UniversalQueryBuilderTest, SameSQLAcrossDialects)
	TEST_F (UniversalQueryBuilderTest, NoDatabaseType)
	TEST_F (UniversalQueryBuilderTest, MethodChaining)
	TEST_F (UniversalQueryBuilderTest, LimitForSQL)

Function Documentation

TEST_F() [1/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		ComplexSelectQuery	)

Definition at line 471 of file sql_query_builder_test.cpp.

{
    std::vector<std::string> cols = {"u.id", "u.name", "COUNT(o.id) as order_count"};
    std::vector<std::string> group_cols = {"u.id", "u.name"};
    auto query = builder_->select(cols)
                         .from("users u")
                         .join("orders o", "u.id = o.user_id", join_type::left)
                         .where("u.status", "=", core::database_value{std::string("active")})
                         .group_by(group_cols)
                         .having("COUNT(o.id) > 5")
                         .order_by("order_count", sort_order::desc)
                         .limit(10)
                         .build();
 
    EXPECT_TRUE(query.find("SELECT") != std::string::npos);
    EXPECT_TRUE(query.find("LEFT JOIN") != std::string::npos);
    EXPECT_TRUE(query.find("WHERE") != std::string::npos);
    EXPECT_TRUE(query.find("GROUP BY") != std::string::npos);
    EXPECT_TRUE(query.find("HAVING") != std::string::npos);
    EXPECT_TRUE(query.find("ORDER BY") != std::string::npos);
    EXPECT_TRUE(query.find("LIMIT") != std::string::npos);
}

References database::desc, and database::left.

TEST_F() [2/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		CrossJoin	)

Definition at line 104 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("colors")
                         .join("sizes", "1=1", join_type::cross)
                         .build();
 
    EXPECT_TRUE(query.find("CROSS JOIN") != std::string::npos);
}

References database::cross.

TEST_F() [3/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		DeleteWithMultipleConditions	)

Definition at line 404 of file sql_query_builder_test.cpp.

{
    auto query = builder_->delete_from("users")
                         .where("status", "=", core::database_value{std::string("inactive")})
                         .where("last_login", "<", core::database_value{std::string("2024-01-01")})
                         .build();
 
    EXPECT_TRUE(query.find("DELETE FROM") != std::string::npos);
    EXPECT_TRUE(query.find("AND") != std::string::npos);
}

TEST_F() [4/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		DeleteWithWhere	)

Definition at line 394 of file sql_query_builder_test.cpp.

{
    auto query = builder_->delete_from("users")
                         .where("id", "=", core::database_value{int64_t(1)})
                         .build();
 
    EXPECT_TRUE(query.find("DELETE FROM") != std::string::npos);
    EXPECT_TRUE(query.find("WHERE") != std::string::npos);
}

TEST_F() [5/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		EmptyConditions	)

Definition at line 498 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"}).from("users").build();
 
    EXPECT_FALSE(query.find("WHERE") != std::string::npos);
}

TEST_F() [6/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		FullOuterJoin	)

Definition at line 94 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .join("orders", "users.id = orders.user_id", join_type::full_outer)
                         .build();
 
    EXPECT_TRUE(query.find("FULL OUTER JOIN") != std::string::npos);
}

References database::full_outer.

TEST_F() [7/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		GroupBy	)

Definition at line 217 of file sql_query_builder_test.cpp.

{
    std::vector<std::string> cols = {"department", "COUNT(*)"};
    auto query = builder_->select(cols)
                         .from("employees")
                         .group_by("department")
                         .build();
 
    EXPECT_TRUE(query.find("GROUP BY") != std::string::npos);
}

TEST_F() [8/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		GroupByMultipleColumns	)

Definition at line 228 of file sql_query_builder_test.cpp.

{
    std::vector<std::string> cols = {"department", "city", "COUNT(*)"};
    std::vector<std::string> group_cols = {"department", "city"};
    auto query = builder_->select(cols)
                         .from("employees")
                         .group_by(group_cols)
                         .build();
 
    EXPECT_TRUE(query.find("GROUP BY") != std::string::npos);
}

TEST_F() [9/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		GroupByWithHaving	)

Definition at line 240 of file sql_query_builder_test.cpp.

{
    std::vector<std::string> cols = {"department", "COUNT(*) as count"};
    auto query = builder_->select(cols)
                         .from("employees")
                         .group_by("department")
                         .having("COUNT(*) > 5")
                         .build();
 
    EXPECT_TRUE(query.find("GROUP BY") != std::string::npos);
    EXPECT_TRUE(query.find("HAVING") != std::string::npos);
    EXPECT_TRUE(query.find("COUNT(*) > 5") != std::string::npos);
}

TEST_F() [10/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		InnerJoin	)

Definition at line 62 of file sql_query_builder_test.cpp.

{
    std::vector<std::string> cols = {"u.id", "u.name", "o.total"};
    auto query = builder_->select(cols)
                         .from("users u")
                         .join("orders o", "u.id = o.user_id", join_type::inner)
                         .build();
 
    EXPECT_TRUE(query.find("INNER JOIN") != std::string::npos);
    EXPECT_TRUE(query.find("ON u.id = o.user_id") != std::string::npos);
}

References database::inner.

TEST_F() [11/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		InsertMultipleRows	)

Definition at line 337 of file sql_query_builder_test.cpp.

{
    std::vector<std::map<std::string, core::database_value>> rows;
 
    std::map<std::string, core::database_value> row1;
    row1["name"] = core::database_value{std::string("John")};
    row1["age"] = core::database_value{int64_t(30)};
    rows.push_back(row1);
 
    std::map<std::string, core::database_value> row2;
    row2["name"] = core::database_value{std::string("Jane")};
    row2["age"] = core::database_value{int64_t(25)};
    rows.push_back(row2);
 
    auto query = builder_->insert_into("users")
                         .values(rows)
                         .build();
 
    EXPECT_TRUE(query.find("INSERT INTO") != std::string::npos);
    EXPECT_TRUE(query.find("VALUES") != std::string::npos);
}

TEST_F() [12/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		InsertSingleRow	)

Definition at line 323 of file sql_query_builder_test.cpp.

{
    std::map<std::string, core::database_value> data;
    data["name"] = core::database_value{std::string("John")};
    data["email"] = core::database_value{std::string("john@example.com")};
 
    auto query = builder_->insert_into("users")
                         .values(data)
                         .build();
 
    EXPECT_TRUE(query.find("INSERT INTO") != std::string::npos);
    EXPECT_TRUE(query.find("VALUES") != std::string::npos);
}

TEST_F() [13/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		LeftJoin	)

Definition at line 74 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .join("profiles", "users.id = profiles.user_id", join_type::left)
                         .build();
 
    EXPECT_TRUE(query.find("LEFT JOIN") != std::string::npos);
}

References database::left.

TEST_F() [14/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		Limit	)

Definition at line 297 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .limit(10)
                         .build();
 
    EXPECT_TRUE(query.find("LIMIT 10") != std::string::npos);
}

TEST_F() [15/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		LimitWithOffset	)

Definition at line 307 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .limit(10)
                         .offset(20)
                         .build();
 
    EXPECT_TRUE(query.find("LIMIT 10") != std::string::npos);
    EXPECT_TRUE(query.find("OFFSET 20") != std::string::npos);
}

TEST_F() [16/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		MultipleJoins	)

Definition at line 114 of file sql_query_builder_test.cpp.

{
    std::vector<std::string> cols = {"u.id", "u.name", "o.total", "p.name"};
    auto query = builder_->select(cols)
                         .from("users u")
                         .join("orders o", "u.id = o.user_id")
                         .join("products p", "o.product_id = p.id", join_type::left)
                         .build();
 
    EXPECT_TRUE(query.find("INNER JOIN") != std::string::npos);
    EXPECT_TRUE(query.find("LEFT JOIN") != std::string::npos);
}

References database::left.

TEST_F() [17/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		MultipleWhereConditions	)

Definition at line 174 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .where("active", "=", core::database_value{true})
                         .where("age", ">", core::database_value{int64_t(18)})
                         .build();
 
    EXPECT_TRUE(query.find("AND") != std::string::npos);
}

TEST_F() [18/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		NestedConditionsWithAnd	)

Definition at line 185 of file sql_query_builder_test.cpp.

{
    query_condition cond1("age", ">", core::database_value{int64_t(18)});
    query_condition cond2("status", "=", core::database_value{std::string("active")});
    auto combined = cond1 && cond2;
 
    auto query = builder_->select({"*"})
                         .from("users")
                         .where(combined)
                         .build();
 
    EXPECT_TRUE(query.find("AND") != std::string::npos);
}

TEST_F() [19/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		NestedConditionsWithOr	)

Definition at line 199 of file sql_query_builder_test.cpp.

{
    query_condition cond1("role", "=", core::database_value{std::string("admin")});
    query_condition cond2("role", "=", core::database_value{std::string("superadmin")});
    auto combined = cond1 || cond2;
 
    auto query = builder_->select({"*"})
                         .from("users")
                         .where(combined)
                         .build();
 
    EXPECT_TRUE(query.find("OR") != std::string::npos);
}

TEST_F() [20/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		OrderByAsc	)

Definition at line 258 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .order_by("name", sort_order::asc)
                         .build();
 
    EXPECT_TRUE(query.find("ORDER BY") != std::string::npos);
    EXPECT_TRUE(query.find("name ASC") != std::string::npos);
}

References database::asc.

TEST_F() [21/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		OrderByDesc	)

Definition at line 269 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .order_by("created_at", sort_order::desc)
                         .build();
 
    EXPECT_TRUE(query.find("ORDER BY") != std::string::npos);
    EXPECT_TRUE(query.find("created_at DESC") != std::string::npos);
}

References database::desc.

TEST_F() [22/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		OrderByMultipleColumns	)

Definition at line 280 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("products")
                         .order_by("category", sort_order::asc)
                         .order_by("price", sort_order::desc)
                         .build();
 
    EXPECT_TRUE(query.find("ORDER BY") != std::string::npos);
    EXPECT_TRUE(query.find("category ASC") != std::string::npos);
    EXPECT_TRUE(query.find("price DESC") != std::string::npos);
}

References database::asc, and database::desc.

TEST_F() [23/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		PostgreSQLSyntax	)

Definition at line 419 of file sql_query_builder_test.cpp.

{
    query_builder pg_builder(database_types::postgres);
    auto query = pg_builder.select({"*"})
                          .from("users")
                          .limit(10)
                          .build();
 
    EXPECT_TRUE(query.find("\"users\"") != std::string::npos);
}

References database::query_builder::build(), database::query_builder::limit(), database::postgres, and database::query_builder::select().

Here is the call graph for this function:

TEST_F() [24/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		Reset	)

Definition at line 445 of file sql_query_builder_test.cpp.

{
    builder_->select({"*"}).from("users").limit(10);
    builder_->reset();
 
    // After reset, builder should be clean - verify by building a new query
    // Reset clears the state, so next query starts fresh
    auto query = builder_->select({"id"}).from("test_table").build();
    EXPECT_TRUE(query.find("test_table") != std::string::npos);
    EXPECT_TRUE(query.find("users") == std::string::npos);  // Previous table not present
}

TEST_F() [25/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		ReuseAfterReset	)

Definition at line 457 of file sql_query_builder_test.cpp.

{
    builder_->select({"*"}).from("users").limit(10);
    builder_->reset();
 
    auto query = builder_->select({"*"}).from("products").build();
    EXPECT_TRUE(query.find("products") != std::string::npos);
    EXPECT_TRUE(query.find("users") == std::string::npos);
}

TEST_F() [26/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		RightJoin	)

Definition at line 84 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .join("orders", "users.id = orders.user_id", join_type::right)
                         .build();
 
    EXPECT_TRUE(query.find("RIGHT JOIN") != std::string::npos);
}

References database::right.

TEST_F() [27/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		SelectAll	)

Definition at line 51 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"}).from("users").build();
    EXPECT_TRUE(query.find("SELECT") != std::string::npos);
    EXPECT_TRUE(query.find("*") != std::string::npos);
}

TEST_F() [28/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		SimpleSelect	)

Definition at line 40 of file sql_query_builder_test.cpp.

{
    std::vector<std::string> cols = {"id", "name", "email"};
    auto query = builder_->select(cols)
                         .from("users")
                         .build();
 
    EXPECT_TRUE(query.find("SELECT") != std::string::npos);
    EXPECT_TRUE(query.find("FROM") != std::string::npos);
}

TEST_F() [29/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		SimpleWhere	)

Definition at line 131 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .where("active", "=", core::database_value{true})
                         .build();
 
    EXPECT_TRUE(query.find("WHERE") != std::string::npos);
    EXPECT_TRUE(query.find("active") != std::string::npos);
    EXPECT_TRUE(query.find("TRUE") != std::string::npos);
}

TEST_F() [30/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		SQLiteSyntax	)

Definition at line 430 of file sql_query_builder_test.cpp.

{
    query_builder sqlite_builder(database_types::sqlite);
    auto query = sqlite_builder.select({"*"})
                              .from("users")
                              .limit(10)
                              .build();
 
    EXPECT_TRUE(query.find("[users]") != std::string::npos);
}

References database::query_builder::build(), database::query_builder::limit(), database::query_builder::select(), and database::sqlite.

Here is the call graph for this function:

TEST_F() [31/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		SwitchDatabase	)

Definition at line 509 of file sql_query_builder_test.cpp.

{
    builder_->for_database(database_types::sqlite);
 
    auto query = builder_->select({"*"})
                        .from("users")
                        .build();
 
    EXPECT_TRUE(query.find("[users]") != std::string::npos);  // SQLite syntax
}

References database::sqlite.

TEST_F() [32/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		UpdateMultipleFields	)

Definition at line 375 of file sql_query_builder_test.cpp.

{
    std::map<std::string, core::database_value> data;
    data["status"] = core::database_value{std::string("active")};
    data["updated_at"] = core::database_value{std::string("2025-01-01")};
 
    auto query = builder_->update("users")
                         .set(data)
                         .where("id", "=", core::database_value{int64_t(1)})
                         .build();
 
    EXPECT_TRUE(query.find("UPDATE") != std::string::npos);
    EXPECT_TRUE(query.find("SET") != std::string::npos);
}

TEST_F() [33/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		UpdateSingleField	)

Definition at line 363 of file sql_query_builder_test.cpp.

{
    auto query = builder_->update("users")
                         .set("status", core::database_value{std::string("active")})
                         .where("id", "=", core::database_value{int64_t(1)})
                         .build();
 
    EXPECT_TRUE(query.find("UPDATE") != std::string::npos);
    EXPECT_TRUE(query.find("SET") != std::string::npos);
    EXPECT_TRUE(query.find("WHERE") != std::string::npos);
}

TEST_F() [34/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		WhereWithDouble	)

Definition at line 163 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("products")
                         .where("price", "<", core::database_value{99.99})
                         .build();
 
    EXPECT_TRUE(query.find("price") != std::string::npos);
    EXPECT_TRUE(query.find("<") != std::string::npos);
}

TEST_F() [35/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		WhereWithInt	)

Definition at line 153 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .where("age", ">", core::database_value{int64_t(18)})
                         .build();
 
    EXPECT_TRUE(query.find("> 18") != std::string::npos);
}

TEST_F() [36/50]

database::tests::TEST_F	(	SQLQueryBuilderTest	,
		WhereWithString	)

Definition at line 143 of file sql_query_builder_test.cpp.

{
    auto query = builder_->select({"*"})
                         .from("users")
                         .where("status", "=", core::database_value{std::string("active")})
                         .build();
 
    EXPECT_TRUE(query.find("'active'") != std::string::npos);
}

TEST_F() [37/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		DefaultConstructor	)

Definition at line 215 of file universal_query_builder_test.cpp.

{
    query_builder builder;
 
    // Default is none, so build should return empty
    auto query = builder.build();
    EXPECT_TRUE(query.empty());
}

References database::query_builder::build().

Here is the call graph for this function:

TEST_F() [38/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		InsertData	)

Definition at line 138 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::postgres);
 
    std::map<std::string, core::database_value> data;
    data["name"] = core::database_value{std::string("John")};
    data["email"] = core::database_value{std::string("john@example.com")};
 
    auto query = builder.insert_into("users").values(data).build();
 
    EXPECT_TRUE(query.find("INSERT INTO") != std::string::npos);
    EXPECT_TRUE(query.find("VALUES") != std::string::npos);
}

References database::query_builder::build(), database::query_builder::insert_into(), database::postgres, and database::query_builder::values().

Here is the call graph for this function:

TEST_F() [39/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		JoinQuery	)

Definition at line 122 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::postgres);
 
    auto query = builder.select({"u.id", "u.name", "o.total"})
                        .from("users u")
                        .join("orders o", "u.id = o.user_id")
                        .build();
 
    EXPECT_TRUE(query.find("JOIN") != std::string::npos);
}

References database::query_builder::build(), database::query_builder::join(), database::postgres, and database::query_builder::select().

Here is the call graph for this function:

TEST_F() [40/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		LimitForSQL	)

Definition at line 326 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::postgres);
 
    auto query = builder.select({"*"})
                        .from("users")
                        .limit(10)
                        .build();
 
    EXPECT_TRUE(query.find("LIMIT 10") != std::string::npos);
}

References database::query_builder::build(), database::query_builder::limit(), database::postgres, and database::query_builder::select().

Here is the call graph for this function:

TEST_F() [41/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		MethodChaining	)

Definition at line 282 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::postgres);
 
    // All methods should return reference for chaining
    auto& ref1 = builder.for_database(database_types::sqlite);
    auto& ref2 = ref1.select({"*"});
    auto& ref3 = ref2.from("users");
    auto& ref4 = ref3.where("active", "=", core::database_value{true});
    auto& ref5 = ref4.order_by("name");
    auto& ref6 = ref5.limit(10);
 
    auto query = ref6.build();
    EXPECT_TRUE(query.find("SELECT") != std::string::npos);
}

References database::query_builder::build(), database::query_builder::for_database(), database::query_builder::from(), database::query_builder::limit(), database::query_builder::order_by(), database::postgres, database::query_builder::select(), database::sqlite, and database::query_builder::where().

Here is the call graph for this function:

TEST_F() [42/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		NoDatabaseType	)

Definition at line 269 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::none);
 
    auto query = builder.select({"*"}).from("users").build();
 
    EXPECT_TRUE(query.empty());
}

References database::query_builder::build(), database::none, and database::query_builder::select().

Here is the call graph for this function:

TEST_F() [43/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		PostgreSQLBuilder	)

Definition at line 34 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::postgres);
 
    auto query = builder.select({"*"})
                        .from("users")
                        .build();
 
    EXPECT_TRUE(query.find("SELECT") != std::string::npos);
    EXPECT_TRUE(query.find("\"users\"") != std::string::npos);  // PostgreSQL uses double quotes
}

References database::query_builder::build(), database::postgres, and database::query_builder::select().

Here is the call graph for this function:

TEST_F() [44/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		Reset	)

Definition at line 170 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::postgres);
 
    builder.select({"*"}).from("users").limit(10);
    builder.reset();
 
    // After reset, building should work with new query
    auto query = builder.select({"*"}).from("products").build();
    EXPECT_TRUE(query.find("products") != std::string::npos);
}

References database::query_builder::build(), database::query_builder::limit(), database::postgres, database::query_builder::reset(), and database::query_builder::select().

Here is the call graph for this function:

TEST_F() [45/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		SameSQLAcrossDialects	)

Definition at line 241 of file universal_query_builder_test.cpp.

{
    // Build same logical query for different databases
    std::vector<database_types> sql_types = {
        database_types::postgres,
        database_types::sqlite
    };
 
    for (auto db_type : sql_types) {
        query_builder builder(db_type);
 
        auto query = builder.select({"id", "name"})
                            .from("users")
                            .where("active", "=", core::database_value{true})
                            .limit(10)
                            .build();
 
        EXPECT_TRUE(query.find("SELECT") != std::string::npos);
        EXPECT_TRUE(query.find("FROM") != std::string::npos);
        EXPECT_TRUE(query.find("WHERE") != std::string::npos);
        EXPECT_TRUE(query.find("LIMIT") != std::string::npos);
    }
}

References database::query_builder::build(), database::postgres, database::query_builder::select(), database::sqlite, and database::query_builder::where().

Here is the call graph for this function:

TEST_F() [46/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		SelectQuery	)

Definition at line 104 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::sqlite);
 
    auto query = builder.select({"id", "name", "email"})
                        .from("users")
                        .where("active", "=", core::database_value{true})
                        .order_by("name", sort_order::asc)
                        .limit(10)
                        .build();
 
    EXPECT_TRUE(query.find("SELECT") != std::string::npos);
    EXPECT_TRUE(query.find("FROM") != std::string::npos);
    EXPECT_TRUE(query.find("WHERE") != std::string::npos);
    EXPECT_TRUE(query.find("ORDER BY") != std::string::npos);
    EXPECT_TRUE(query.find("LIMIT") != std::string::npos);
}

References database::asc, database::query_builder::build(), database::query_builder::limit(), database::query_builder::select(), database::sqlite, and database::query_builder::where().

Here is the call graph for this function:

TEST_F() [47/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		SetDatabaseAfterConstruction	)

Definition at line 224 of file universal_query_builder_test.cpp.

{
    query_builder builder;
 
    builder.for_database(database_types::sqlite);
 
    auto query = builder.select({"*"})
                        .from("users")
                        .build();
 
    EXPECT_TRUE(query.find("SELECT") != std::string::npos);
}

References database::query_builder::build(), database::query_builder::for_database(), database::query_builder::select(), and database::sqlite.

Here is the call graph for this function:

TEST_F() [48/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		SQLiteBuilder	)

Definition at line 46 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::sqlite);
 
    auto query = builder.select({"*"})
                        .from("users")
                        .build();
 
    EXPECT_TRUE(query.find("SELECT") != std::string::npos);
    EXPECT_TRUE(query.find("[users]") != std::string::npos);  // SQLite uses square brackets
}

References database::query_builder::build(), database::query_builder::select(), and database::sqlite.

Here is the call graph for this function:

TEST_F() [49/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		SwitchDatabase	)

Definition at line 87 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::postgres);
 
    builder.for_database(database_types::sqlite);
 
    auto query = builder.select({"*"})
                        .from("users")
                        .build();
 
    EXPECT_TRUE(query.find("[users]") != std::string::npos);  // SQLite syntax
}

References database::query_builder::build(), database::query_builder::for_database(), database::postgres, database::query_builder::select(), and database::sqlite.

Here is the call graph for this function:

TEST_F() [50/50]

database::tests::TEST_F	(	UniversalQueryBuilderTest	,
		UpdateData	)

Definition at line 152 of file universal_query_builder_test.cpp.

{
    query_builder builder(database_types::postgres);
 
    auto query = builder.update("users")
                        .set("status", core::database_value{std::string("active")})
                        .where("id", "=", core::database_value{int64_t(1)})
                        .build();
 
    EXPECT_TRUE(query.find("UPDATE") != std::string::npos);
    EXPECT_TRUE(query.find("SET") != std::string::npos);
    EXPECT_TRUE(query.find("WHERE") != std::string::npos);
}

References database::postgres, database::query_builder::set(), and database::query_builder::update().

Here is the call graph for this function: