diff --git a/include/sqlpp11/functions.h b/include/sqlpp11/functions.h index 0f9563da..3efa7aed 100644 --- a/include/sqlpp11/functions.h +++ b/include/sqlpp11/functions.h @@ -34,6 +34,8 @@ #include #include #include +#include +#include #include #include #include diff --git a/include/sqlpp11/lower.h b/include/sqlpp11/lower.h new file mode 100644 index 00000000..a5d2cafd --- /dev/null +++ b/include/sqlpp11/lower.h @@ -0,0 +1,99 @@ +/* + * Copyright (c) 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. + */ + +#ifndef SQLPP11_LOWER_H +#define SQLPP11_LOWER_H + +#include +#include +#include + +namespace sqlpp +{ + struct lower_alias_t + { + struct _alias_t + { + static constexpr const char _literal[] = "lower_"; + using _name_t = sqlpp::make_char_sequence; + template + struct _member_t + { + T lower; + T& operator()() + { + return lower; + } + const T& operator()() const + { + return lower; + } + }; + }; + }; + + template + struct lower_t : public expression_operators, text>, public alias_operators> + { + using _traits = make_traits; + + using _nodes = detail::type_vector; + using _can_be_null = can_be_null_t; + + using _auto_alias_t = lower_alias_t; + + lower_t(const Expr expr) : _expr(expr) + { + } + + lower_t(const lower_t&) = default; + lower_t(lower_t&&) = default; + lower_t& operator=(const lower_t&) = default; + lower_t& operator=(lower_t&&) = default; + ~lower_t() = default; + + Expr _expr; + }; + + template + Context& serialize(const lower_t& t, Context& context) + { + context << "LOWER("; + serialize_operand(t._expr, context); + context << ")"; + return context; + } + + template + auto lower(T t) -> lower_t> + { + static_assert(is_text_t>::value, "lower() requires a text expression as argument"); + return {t}; + } + +} // namespace sqlpp + +#endif diff --git a/include/sqlpp11/upper.h b/include/sqlpp11/upper.h new file mode 100644 index 00000000..c07f74fe --- /dev/null +++ b/include/sqlpp11/upper.h @@ -0,0 +1,99 @@ +/* + * Copyright (c) 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. + */ + +#ifndef SQLPP11_UPPER_H +#define SQLPP11_UPPER_H + +#include +#include +#include + +namespace sqlpp +{ + struct upper_alias_t + { + struct _alias_t + { + static constexpr const char _literal[] = "upper_"; + using _name_t = sqlpp::make_char_sequence; + template + struct _member_t + { + T upper; + T& operator()() + { + return upper; + } + const T& operator()() const + { + return upper; + } + }; + }; + }; + + template + struct upper_t : public expression_operators, text>, public alias_operators> + { + using _traits = make_traits; + + using _nodes = detail::type_vector; + using _can_be_null = can_be_null_t; + + using _auto_alias_t = upper_alias_t; + + upper_t(const Expr expr) : _expr(expr) + { + } + + upper_t(const upper_t&) = default; + upper_t(upper_t&&) = default; + upper_t& operator=(const upper_t&) = default; + upper_t& operator=(upper_t&&) = default; + ~upper_t() = default; + + Expr _expr; + }; + + template + Context& serialize(const upper_t& t, Context& context) + { + context << "UPPER("; + serialize_operand(t._expr, context); + context << ")"; + return context; + } + + template + auto upper(T t) -> upper_t> + { + static_assert(is_text_t>::value, "upper() requires a text expression as argument"); + return {t}; + } + +} // namespace sqlpp + +#endif diff --git a/tests/core/serialize/CMakeLists.txt b/tests/core/serialize/CMakeLists.txt index 32130a41..4aacac5e 100644 --- a/tests/core/serialize/CMakeLists.txt +++ b/tests/core/serialize/CMakeLists.txt @@ -33,12 +33,14 @@ set(test_files From.cpp In.cpp Insert.cpp + Lower.cpp Max.cpp Min.cpp Operator.cpp Over.cpp Sum.cpp TableAlias.cpp + Upper.cpp Where.cpp ParameterizedVerbatim.cpp ) diff --git a/tests/core/serialize/Lower.cpp b/tests/core/serialize/Lower.cpp new file mode 100644 index 00000000..859d774c --- /dev/null +++ b/tests/core/serialize/Lower.cpp @@ -0,0 +1,45 @@ +/* + * 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 + +int Lower(int, char* []) +{ + const auto bar = test::TabBar{}; + + // Single column. + compare(__LINE__, lower(bar.beta), "LOWER(tab_bar.beta)"); + + // Expression. + // Note that the inner parens aren't necessary. + compare(__LINE__, lower(bar.beta + "suffix"), "LOWER((tab_bar.beta||'suffix'))"); + + // With sub select. + compare(__LINE__, lower(select(sqlpp::value("something").as(sqlpp::alias::a))), "LOWER((SELECT 'something' AS a))"); + + return 0; +} diff --git a/tests/core/serialize/Upper.cpp b/tests/core/serialize/Upper.cpp new file mode 100644 index 00000000..47db0659 --- /dev/null +++ b/tests/core/serialize/Upper.cpp @@ -0,0 +1,45 @@ +/* + * 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 + +int Upper(int, char* []) +{ + const auto bar = test::TabBar{}; + + // Single column. + compare(__LINE__, upper(bar.beta), "UPPER(tab_bar.beta)"); + + // Expression. + // Note that the inner parens aren't necessary. + compare(__LINE__, upper(bar.beta + "suffix"), "UPPER((tab_bar.beta||'suffix'))"); + + // With sub select. + compare(__LINE__, upper(select(sqlpp::value("something").as(sqlpp::alias::a))), "UPPER((SELECT 'something' AS a))"); + + return 0; +}