3party/sqlpp11
0
0
Fork 0
mirror of https://github.com/rbock/sqlpp11.git synced 2024-11-15 12:29:41 +08:00
Code Issues Projects Releases Wiki Activity

Add missing braces to aggregatedfunctions with sub select #469

Browse Source 
Also allow MIN and MAX to be used with DISTINCT.
This commit is contained in:
Roland Bock 2023-01-29 14:39:07 +01:00
parent 673b07361b
commit 82758a2046
10 changed files with 255 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/sqlpp11/aggregate_functions/avg.h
View File

@ -91,12 +91,8 @@ namespace sqlpp
{
serialize(Flag(), context);
context << ' ';
serialize_operand(t._expr, context);
}
else
{
serialize(t._expr, context);
}
serialize_operand(t._expr, context);
context << ")";
return context;
}

6
include/sqlpp11/aggregate_functions/count.h
View File

@ -94,12 +94,8 @@ namespace sqlpp
{
serialize(Flag(), context);
context << ' ';
serialize_operand(t._expr, context);
}
else
{
serialize(t._expr, context);
}
serialize_operand(t._expr, context);
context << ")";
return context;
}

30
include/sqlpp11/aggregate_functions/max.h
View File

@ -54,10 +54,10 @@ namespace sqlpp
};
};
template <typename Expr>
struct max_t : public expression_operators<max_t<Expr>, value_type_of<Expr>>,
public aggregate_function_operators<max_t<Expr>>,
public alias_operators<max_t<Expr>>
template <typename Flag, typename Expr>
struct max_t : public expression_operators<max_t<Flag, Expr>, value_type_of<Expr>>,
public aggregate_function_operators<max_t<Flag, Expr>>,
public alias_operators<max_t<Flag, Expr>>
{
using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
using _nodes = detail::type_vector<Expr, aggregate_function>;
@ -79,17 +79,31 @@ namespace sqlpp
Expr _expr;
};
template <typename Context, typename Expr>
Context& serialize(const max_t<Expr>& t, Context& context)
template <typename Context, typename Flag, typename Expr>
Context& serialize(const max_t<Flag, Expr>& t, Context& context)
{
context << "MAX(";
serialize(t._expr, context);
if (std::is_same<distinct_t, Flag>::value)
{
serialize(Flag(), context);
context << ' ';
}
serialize_operand(t._expr, context);
context << ")";
return context;
}
template <typename T>
auto max(T t) -> max_t<wrap_operand_t<T>>
auto max(T t) -> max_t<noop, wrap_operand_t<T>>
{
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
"max() cannot be used on an aggregate function");
static_assert(is_expression_t<wrap_operand_t<T>>::value, "max() requires an expression as argument");
return {t};
}
template <typename T>
auto max(const distinct_t& /*unused*/, T t) -> max_t<distinct_t, wrap_operand_t<T>>
{
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
"max() cannot be used on an aggregate function");

30
include/sqlpp11/aggregate_functions/min.h
View File

@ -54,10 +54,10 @@ namespace sqlpp
};
};
template <typename Expr>
struct min_t : public expression_operators<min_t<Expr>, value_type_of<Expr>>,
public aggregate_function_operators<min_t<Expr>>,
public alias_operators<min_t<Expr>>
template <typename Flag, typename Expr>
struct min_t : public expression_operators<min_t<Flag, Expr>, value_type_of<Expr>>,
public aggregate_function_operators<min_t<Flag, Expr>>,
public alias_operators<min_t<Flag, Expr>>
{
using _traits = make_traits<value_type_of<Expr>, tag::is_expression, tag::is_selectable>;
using _nodes = detail::type_vector<Expr, aggregate_function>;
@ -79,17 +79,31 @@ namespace sqlpp
Expr _expr;
};
template <typename Context, typename Expr>
Context& serialize(const min_t<Expr>& t, Context& context)
template <typename Context, typename Flag, typename Expr>
Context& serialize(const min_t<Flag, Expr>& t, Context& context)
{
context << "MIN(";
serialize(t._expr, context);
if (std::is_same<distinct_t, Flag>::value)
{
serialize(Flag(), context);
context << ' ';
}
serialize_operand(t._expr, context);
context << ")";
return context;
}
template <typename T>
auto min(T t) -> min_t<wrap_operand_t<T>>
auto min(T t) -> min_t<noop, wrap_operand_t<T>>
{
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
"min() cannot be used on an aggregate function");
static_assert(is_expression_t<wrap_operand_t<T>>::value, "min() requires an expression as argument");
return {t};
}
template <typename T>
auto min(const distinct_t& /*unused*/, T t) -> min_t<distinct_t, wrap_operand_t<T>>
{
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
"min() cannot be used on an aggregate function");

48
tests/core/serialize/Avg.cpp Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c) 2023-2023, 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 <sqlpp11/sqlpp11.h>
int Avg(int, char* [])
{
const auto bar = test::TabBar{};
// Single column.
compare(__LINE__, avg(bar.alpha), "AVG(tab_bar.alpha)");
compare(__LINE__, avg(sqlpp::distinct, bar.alpha), "AVG(DISTINCT tab_bar.alpha)");
// Expression.
// Note that the inner parens aren't necessary.
compare(__LINE__, avg(bar.alpha + 7), "AVG((tab_bar.alpha+7))");
compare(__LINE__, avg(sqlpp::distinct, bar.alpha + 7), "AVG(DISTINCT (tab_bar.alpha+7))");
// With sub select.
compare(__LINE__, avg(select(sqlpp::value(7).as(sqlpp::alias::a))), "AVG((SELECT 7 AS a))");
compare(__LINE__, avg(sqlpp::distinct, select(sqlpp::value(7).as(sqlpp::alias::a))), "AVG(DISTINCT (SELECT 7 AS a))");
return 0;
}

4
tests/core/serialize/CMakeLists.txt
View File

@ -24,13 +24,17 @@
set(test_files
As.cpp
Avg.cpp
Blob.cpp
Count.cpp
CustomQuery.cpp
DynamicWhere.cpp
ForUpdate.cpp
From.cpp
In.cpp
Insert.cpp
Max.cpp
Min.cpp
Operator.cpp
Over.cpp
Sum.cpp

48
tests/core/serialize/Count.cpp Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c) 2023-2023, 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 <sqlpp11/sqlpp11.h>
int Count(int, char* [])
{
const auto bar = test::TabBar{};
// Single column.
compare(__LINE__, count(bar.alpha), "COUNT(tab_bar.alpha)");
compare(__LINE__, count(sqlpp::distinct, bar.alpha), "COUNT(DISTINCT tab_bar.alpha)");
// Expression.
// Note that the inner parens aren't necessary.
compare(__LINE__, count(bar.alpha + 7), "COUNT((tab_bar.alpha+7))");
compare(__LINE__, count(sqlpp::distinct, bar.alpha + 7), "COUNT(DISTINCT (tab_bar.alpha+7))");
// With sub select.
compare(__LINE__, count(select(sqlpp::value(7).as(sqlpp::alias::a))), "COUNT((SELECT 7 AS a))");
compare(__LINE__, count(sqlpp::distinct, select(sqlpp::value(7).as(sqlpp::alias::a))), "COUNT(DISTINCT (SELECT 7 AS a))");
return 0;
}

48
tests/core/serialize/Max.cpp Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c) 2023-2023, 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 <sqlpp11/sqlpp11.h>
int Max(int, char* [])
{
const auto bar = test::TabBar{};
// Single column.
compare(__LINE__, max(bar.alpha), "MAX(tab_bar.alpha)");
compare(__LINE__, max(sqlpp::distinct, bar.alpha), "MAX(DISTINCT tab_bar.alpha)");
// Expression.
// Note that the inner parens aren't necessary.
compare(__LINE__, max(bar.alpha + 7), "MAX((tab_bar.alpha+7))");
compare(__LINE__, max(sqlpp::distinct, bar.alpha + 7), "MAX(DISTINCT (tab_bar.alpha+7))");
// With sub select.
compare(__LINE__, max(select(sqlpp::value(7).as(sqlpp::alias::a))), "MAX((SELECT 7 AS a))");
compare(__LINE__, max(sqlpp::distinct, select(sqlpp::value(7).as(sqlpp::alias::a))), "MAX(DISTINCT (SELECT 7 AS a))");
return 0;
}

48
tests/core/serialize/Min.cpp Normal file
View File

@ -0,0 +1,48 @@
/*
* Copyright (c) 2023-2023, 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 <sqlpp11/sqlpp11.h>
int Min(int, char* [])
{
const auto bar = test::TabBar{};
// Single column.
compare(__LINE__, min(bar.alpha), "MIN(tab_bar.alpha)");
compare(__LINE__, min(sqlpp::distinct, bar.alpha), "MIN(DISTINCT tab_bar.alpha)");
// Expression.
// Note that the inner parens aren't necessary.
compare(__LINE__, min(bar.alpha + 7), "MIN((tab_bar.alpha+7))");
compare(__LINE__, min(sqlpp::distinct, bar.alpha + 7), "MIN(DISTINCT (tab_bar.alpha+7))");
// With sub select.
compare(__LINE__, min(select(sqlpp::value(7).as(sqlpp::alias::a))), "MIN((SELECT 7 AS a))");
compare(__LINE__, min(sqlpp::distinct, select(sqlpp::value(7).as(sqlpp::alias::a))), "MIN(DISTINCT (SELECT 7 AS a))");
return 0;
}

14
tests/core/serialize/Sum.cpp
View File

@ -29,8 +29,20 @@
int Sum(int, char* [])
{
// Function
const auto bar = test::TabBar{};
// Single column.
compare(__LINE__, sum(bar.alpha), "SUM(tab_bar.alpha)");
compare(__LINE__, sum(sqlpp::distinct, bar.alpha), "SUM(DISTINCT tab_bar.alpha)");
// Expression.
// Note that the inner parens aren't necessary.
compare(__LINE__, sum(bar.alpha + 7), "SUM((tab_bar.alpha+7))");
compare(__LINE__, sum(sqlpp::distinct, bar.alpha + 7), "SUM(DISTINCT (tab_bar.alpha+7))");
// With sub select.
compare(__LINE__, sum(select(sqlpp::value(7).as(sqlpp::alias::a))), "SUM((SELECT 7 AS a))");
compare(__LINE__, sum(sqlpp::distinct, select(sqlpp::value(7).as(sqlpp::alias::a))), "SUM(DISTINCT (SELECT 7 AS a))");
return 0;
}