From 1dfffdb851db6943f8054e90dabcde64172ff861 Mon Sep 17 00:00:00 2001 From: Roland Bock Date: Sun, 22 Sep 2024 11:34:47 +0200 Subject: [PATCH] Add tests for from and for join --- tests/core/serialize/basic/join.cpp | 24 +++++++++- tests/core/serialize/clause/CMakeLists.txt | 1 + tests/core/serialize/clause/from.cpp | 55 ++++++++++++++++++++++ 3 files changed, 78 insertions(+), 2 deletions(-) create mode 100644 tests/core/serialize/clause/from.cpp diff --git a/tests/core/serialize/basic/join.cpp b/tests/core/serialize/basic/join.cpp index e8b46173..1f14095f 100644 --- a/tests/core/serialize/basic/join.cpp +++ b/tests/core/serialize/basic/join.cpp @@ -37,6 +37,9 @@ int main(int, char* []) const auto foo = test::TabFoo{}; const auto bar = test::TabBar{}; + const auto aFoo = foo.as(sqlpp::alias::a); + const auto bFoo = foo.as(sqlpp::alias::b); + // Join with two tables SQLPP_COMPARE(foo.join(bar).on(foo.id == bar.id), "tab_foo INNER JOIN tab_bar ON tab_foo.id = tab_bar.id"); SQLPP_COMPARE(foo.inner_join(bar).on(foo.id == bar.id), "tab_foo INNER JOIN tab_bar ON tab_foo.id = tab_bar.id"); @@ -46,6 +49,25 @@ int main(int, char* []) SQLPP_COMPARE(foo.cross_join(bar), "tab_foo CROSS JOIN tab_bar"); + // Join with table aliases. + SQLPP_COMPARE(foo.join(bFoo).on(foo.id == bFoo.id), "tab_foo INNER JOIN tab_foo AS b ON tab_foo.id = b.id"); + SQLPP_COMPARE(aFoo.join(foo).on(aFoo.id == foo.id), "tab_foo AS a INNER JOIN tab_foo ON a.id = tab_foo.id"); + SQLPP_COMPARE(aFoo.join(bFoo).on(aFoo.id == bFoo.id), "tab_foo AS a INNER JOIN tab_foo AS b ON a.id = b.id"); + + // Static joins involving verbatim tables + SQLPP_COMPARE(aFoo.join(sqlpp::verbatim_table("unknown_table")) + .on(aFoo.id == sqlpp::verbatim("unknown_table.column_x")), + "tab_foo AS a INNER JOIN unknown_table ON a.id = unknown_table.column_x"); + SQLPP_COMPARE(sqlpp::verbatim_table("unknown_table") + .join(aFoo) + .on(aFoo.id == sqlpp::verbatim("unknown_table.column_x")), + "unknown_table INNER JOIN tab_foo AS a ON a.id = unknown_table.column_x"); + SQLPP_COMPARE(sqlpp::verbatim_table("unknown_table") + .as(sqlpp::alias::a) + .join(sqlpp::verbatim_table("another_table")) + .on(sqlpp::verbatim("a.column_x = another_table.x")), + "unknown_table AS a INNER JOIN another_table ON a.column_x = another_table.x"); + // Join with dynamic table SQLPP_COMPARE(foo.join(dynamic(true, bar)).on(foo.id == bar.id), "tab_foo INNER JOIN tab_bar ON tab_foo.id = tab_bar.id"); SQLPP_COMPARE(foo.inner_join(dynamic(true, bar)).on(foo.id == bar.id), "tab_foo INNER JOIN tab_bar ON tab_foo.id = tab_bar.id"); @@ -65,8 +87,6 @@ int main(int, char* []) #warning: Need to add tests with 3 tables -#warning: Need to add tests with table aliases -#warning: Need to add tests with verbatim tables #warning: Need to add tests with sub selects #warning: Need to add tests with CTEs return 0; diff --git a/tests/core/serialize/clause/CMakeLists.txt b/tests/core/serialize/clause/CMakeLists.txt index 6316b62b..2d240fe1 100644 --- a/tests/core/serialize/clause/CMakeLists.txt +++ b/tests/core/serialize/clause/CMakeLists.txt @@ -30,6 +30,7 @@ function(create_test name) endfunction() create_test(group_by) +create_test(from) create_test(insert) create_test(insert_columns) create_test(insert_default_values) diff --git a/tests/core/serialize/clause/from.cpp b/tests/core/serialize/clause/from.cpp new file mode 100644 index 00000000..4e8c9dd1 --- /dev/null +++ b/tests/core/serialize/clause/from.cpp @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2024, Roland Bock + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "Sample.h" +#include "../compare.h" +#include + +int main() +{ + const auto foo = test::TabFoo{}; + const auto bar = test::TabBar{}; + const auto aFoo = foo.as(sqlpp::alias::a); + const auto bFoo = foo.as(sqlpp::alias::b); + const auto cFoo = foo.as(sqlpp::alias::c); + + // Single table + SQLPP_COMPARE(from(foo), " FROM tab_foo"); + + // Tests with joined tables are mostly covered by join tests. + + // Static joins + SQLPP_COMPARE(from(foo.cross_join(bar)), " FROM tab_foo CROSS JOIN tab_bar"); + SQLPP_COMPARE(from(foo.join(bar).on(foo.id == bar.id)), + " FROM tab_foo INNER JOIN tab_bar ON tab_foo.id = tab_bar.id"); + + // Multiple tables + SQLPP_COMPARE(from(aFoo.join(bFoo).on(aFoo.id == bFoo.id).join(cFoo).on(bFoo.id == cFoo.id)), + " FROM tab_foo AS a INNER JOIN tab_foo AS b ON a.id = b.id INNER JOIN tab_foo AS c ON b.id = c.id"); + +#warning add tests for dynamic joins + + return 0; +}