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

Merge branch 'release/0.52'

Browse Source
This commit is contained in:
rbock 2017-10-21 17:17:03 +02:00
commit 62d915e04d
228 changed files with 1022 additions and 921 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
README.md
View File

@ -4,26 +4,8 @@ A type safe embedded domain specific language for SQL queries and results in C++
Documentation is found in the [wiki](https://github.com/rbock/sqlpp11/wiki) Documentation is found in the [wiki](https://github.com/rbock/sqlpp11/wiki)
Contact: So what is this about?
-------- ----------------------
* Issues at https://github.com/rbock/sqlpp11/issues
* email at rbock at eudoxos dot de
* [![Join the chat at https://gitter.im/sqlpp11/Lobby](https://badges.gitter.im/sqlpp11/Lobby.svg)](https://gitter.im/sqlpp11/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
Breaking changes in 0.36:
-------------------------
See [Changes](ChangeLog.md)
Status:
-------
Branch / Compiler | clang-3.4, gcc-4.9, Xcode-7 | MSVC 2015/2017 | Test Coverage
------------------| -------------------------------|-------------|---------------
master | [![Build Status](https://travis-ci.org/rbock/sqlpp11.svg?branch=master)](https://travis-ci.org/rbock/sqlpp11?branch=master) | [![Build status](https://ci.appveyor.com/api/projects/status/eid7mwqgavo0h61h/branch/master?svg=true)](https://ci.appveyor.com/project/rbock/sqlpp11/branch/master) | [![Coverage Status](https://coveralls.io/repos/rbock/sqlpp11/badge.svg?branch=master)](https://coveralls.io/r/rbock/sqlpp11?branch=master)
develop | [![Build Status](https://travis-ci.org/rbock/sqlpp11.svg?branch=develop)](https://travis-ci.org/rbock/sqlpp11?branch=develop) | [![Build status](https://ci.appveyor.com/api/projects/status/eid7mwqgavo0h61h/branch/develop?svg=true)](https://ci.appveyor.com/project/rbock/sqlpp11/branch/develop) | [![Coverage Status](https://coveralls.io/repos/rbock/sqlpp11/badge.svg?branch=develop)](https://coveralls.io/r/rbock/sqlpp11?branch=develop)
Motivation:
-----------
SQL and C++ are both strongly typed languages. Still, most C/C++ interfaces to SQL are based on constructing queries as strings and on interpreting arrays or maps of strings as results. SQL and C++ are both strongly typed languages. Still, most C/C++ interfaces to SQL are based on constructing queries as strings and on interpreting arrays or maps of strings as results.
sqlpp11 is a templated library representing an embedded domain specific language (EDSL) that allows you to sqlpp11 is a templated library representing an embedded domain specific language (EDSL) that allows you to
@ -100,6 +82,21 @@ db(update(foo).set(foo.hasFun = not foo.hasFun).where(foo.name != "nobody"));
db(remove_from(foo).where(not foo.hasFun)); db(remove_from(foo).where(not foo.hasFun));
``` ```
License:
-------------
sqlpp11 is distributed under the [BSD 2-Clause License](https://github.com/rbock/sqlpp11/blob/master/LICENSE).
Status:
-------
Branch / Compiler | clang-3.4, gcc-4.9, Xcode-7 | MSVC 2015/2017 | Test Coverage
------------------| -------------------------------|-------------|---------------
master | [![Build Status](https://travis-ci.org/rbock/sqlpp11.svg?branch=master)](https://travis-ci.org/rbock/sqlpp11?branch=master) | [![Build status](https://ci.appveyor.com/api/projects/status/eid7mwqgavo0h61h/branch/master?svg=true)](https://ci.appveyor.com/project/rbock/sqlpp11/branch/master) | [![Coverage Status](https://coveralls.io/repos/rbock/sqlpp11/badge.svg?branch=master)](https://coveralls.io/r/rbock/sqlpp11?branch=master)
develop | [![Build Status](https://travis-ci.org/rbock/sqlpp11.svg?branch=develop)](https://travis-ci.org/rbock/sqlpp11?branch=develop) | [![Build status](https://ci.appveyor.com/api/projects/status/eid7mwqgavo0h61h/branch/develop?svg=true)](https://ci.appveyor.com/project/rbock/sqlpp11/branch/develop) | [![Coverage Status](https://coveralls.io/repos/rbock/sqlpp11/badge.svg?branch=develop)](https://coveralls.io/r/rbock/sqlpp11?branch=develop)
MSVC 2017 is currently broken, see
- https://github.com/rbock/sqlpp11/issues/181
- https://developercommunity.visualstudio.com/content/problem/95983/c-vs152-153-regression-in-variadic-template-argume.html
Additional information available: Additional information available:
--------------------------------- ---------------------------------
Past talks about sqlpp11 and some coding concepts used within the library: Past talks about sqlpp11 and some coding concepts used within the library:
@ -192,7 +189,14 @@ Include generated header (MyTable.h), that's all.
If you prefer Ruby over Python, you might want to take a look at https://github.com/douyw/sqlpp11gen If you prefer Ruby over Python, you might want to take a look at https://github.com/douyw/sqlpp11gen
License: Contact:
------------- --------
sqlpp11 is distributed under the [BSD 2-Clause License](https://github.com/rbock/sqlpp11/blob/master/LICENSE). * Issues at https://github.com/rbock/sqlpp11/issues
* email at rbock at eudoxos dot de
* [![Join the chat at https://gitter.im/sqlpp11/Lobby](https://badges.gitter.im/sqlpp11/Lobby.svg)](https://gitter.im/sqlpp11/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
Breaking changes in 0.36:
-------------------------
See [Changes](ChangeLog.md)

4
include/sqlpp11/aggregate_functions.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_AGGREGATE_FUNCTIONS_H #ifndef SQLPP11_AGGREGATE_FUNCTIONS_H
#define SQLPP_AGGREGATE_FUNCTIONS_H #define SQLPP11_AGGREGATE_FUNCTIONS_H
#include <sqlpp11/aggregate_functions/count.h> #include <sqlpp11/aggregate_functions/count.h>
#include <sqlpp11/aggregate_functions/min.h> #include <sqlpp11/aggregate_functions/min.h>

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

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_AVG_H #ifndef SQLPP11_AGGREGATE_FUNCTIONS_AVG_H
#define SQLPP_AVG_H #define SQLPP11_AGGREGATE_FUNCTIONS_AVG_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
@ -116,13 +116,13 @@ namespace sqlpp
} }
template <typename T> template <typename T>
auto avg(const distinct_t&, T t) -> avg_t<distinct_t, wrap_operand_t<T>> auto avg(const distinct_t& /*unused*/, T t) -> avg_t<distinct_t, wrap_operand_t<T>>
{ {
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
"avg() cannot be used on an aggregate function"); "avg() cannot be used on an aggregate function");
static_assert(is_numeric_t<wrap_operand_t<T>>::value, "avg() requires a numeric value expression as argument"); static_assert(is_numeric_t<wrap_operand_t<T>>::value, "avg() requires a numeric value expression as argument");
return {t}; return {t};
} }
} } // namespace sqlpp
#endif #endif

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

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_COUNT_H #ifndef SQLPP11_AGGREGATE_FUNCTIONS_COUNT_H
#define SQLPP_COUNT_H #define SQLPP11_AGGREGATE_FUNCTIONS_COUNT_H
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
#include <sqlpp11/select_flags.h> #include <sqlpp11/select_flags.h>
@ -117,13 +117,13 @@ namespace sqlpp
} }
template <typename T> template <typename T>
auto count(const distinct_t&, T t) -> count_t<distinct_t, wrap_operand_t<T>> auto count(const distinct_t& /*unused*/, T t) -> count_t<distinct_t, wrap_operand_t<T>>
{ {
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
"count() cannot be used on an aggregate function"); "count() cannot be used on an aggregate function");
static_assert(is_expression_t<wrap_operand_t<T>>::value, "count() requires an expression as argument"); static_assert(is_expression_t<wrap_operand_t<T>>::value, "count() requires an expression as argument");
return {t}; return {t};
} }
} } // namespace sqlpp
#endif #endif

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

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_MAX_H #ifndef SQLPP11_AGGREGATE_FUNCTIONS_MAX_H
#define SQLPP_MAX_H #define SQLPP11_AGGREGATE_FUNCTIONS_MAX_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
@ -100,6 +100,6 @@ namespace sqlpp
static_assert(is_expression_t<wrap_operand_t<T>>::value, "max() requires an expression as argument"); static_assert(is_expression_t<wrap_operand_t<T>>::value, "max() requires an expression as argument");
return {t}; return {t};
} }
} } // namespace sqlpp
#endif #endif

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

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_MIN_H #ifndef SQLPP11_AGGREGATE_FUNCTIONS_MIN_H
#define SQLPP_MIN_H #define SQLPP11_AGGREGATE_FUNCTIONS_MIN_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
@ -100,6 +100,6 @@ namespace sqlpp
static_assert(is_expression_t<wrap_operand_t<T>>::value, "min() requires an expression as argument"); static_assert(is_expression_t<wrap_operand_t<T>>::value, "min() requires an expression as argument");
return {t}; return {t};
} }
} } // namespace sqlpp
#endif #endif

10
include/sqlpp11/aggregate_functions/sum.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_SUM_H #ifndef SQLPP11_AGGREGATE_FUNCTIONS_SUM_H
#define SQLPP_SUM_H #define SQLPP11_AGGREGATE_FUNCTIONS_SUM_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
@ -98,7 +98,9 @@ namespace sqlpp
serialize_operand(t._expr, context); serialize_operand(t._expr, context);
} }
else else
{
serialize(t._expr, context); serialize(t._expr, context);
}
context << ")"; context << ")";
return context; return context;
@ -115,13 +117,13 @@ namespace sqlpp
} }
template <typename T> template <typename T>
auto sum(const distinct_t&, T t) -> sum_t<distinct_t, wrap_operand_t<T>> auto sum(const distinct_t& /*unused*/, T t) -> sum_t<distinct_t, wrap_operand_t<T>>
{ {
static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value, static_assert(not contains_aggregate_function_t<wrap_operand_t<T>>::value,
"sum() cannot be used on an aggregate function"); "sum() cannot be used on an aggregate function");
static_assert(is_numeric_t<wrap_operand_t<T>>::value, "sum() requires a numeric expression as argument"); static_assert(is_numeric_t<wrap_operand_t<T>>::value, "sum() requires a numeric expression as argument");
return {t}; return {t};
} }
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/alias.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_ALIAS_H #ifndef SQLPP11_ALIAS_H
#define SQLPP_ALIAS_H #define SQLPP11_ALIAS_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/serializer.h> #include <sqlpp11/serializer.h>
@ -70,6 +70,6 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

8
include/sqlpp11/alias_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_ALIAS_OPERATORS_H #ifndef SQLPP11_ALIAS_OPERATORS_H
#define SQLPP_ALIAS_OPERATORS_H #define SQLPP11_ALIAS_OPERATORS_H
#include <sqlpp11/alias.h> #include <sqlpp11/alias.h>
@ -35,10 +35,10 @@ namespace sqlpp
struct alias_operators struct alias_operators
{ {
template <typename alias_provider> template <typename alias_provider>
expression_alias_t<Expr, alias_provider> as(const alias_provider&) const expression_alias_t<Expr, alias_provider> as(const alias_provider& /*unused*/) const
{ {
return {*static_cast<const Expr*>(this)}; return {*static_cast<const Expr*>(this)};
} }
}; };
} } // namespace sqlpp
#endif #endif

8
include/sqlpp11/alias_provider.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_ALIAS_PROVIDER_H #ifndef SQLPP11_ALIAS_PROVIDER_H
#define SQLPP_ALIAS_PROVIDER_H #define SQLPP11_ALIAS_PROVIDER_H
#include <type_traits> #include <type_traits>
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
@ -100,7 +100,7 @@ namespace sqlpp
SQLPP_ALIAS_PROVIDER(z) SQLPP_ALIAS_PROVIDER(z)
SQLPP_ALIAS_PROVIDER(left) SQLPP_ALIAS_PROVIDER(left)
SQLPP_ALIAS_PROVIDER(right) SQLPP_ALIAS_PROVIDER(right)
} } // namespace alias
} } // namespace sqlpp
#endif #endif

10
include/sqlpp11/all_of.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_ALL_OF_H #ifndef SQLPP11_ALL_OF_H
#define SQLPP_ALL_OF_H #define SQLPP11_ALL_OF_H
#include <sqlpp11/alias.h> #include <sqlpp11/alias.h>
#include <sqlpp11/interpret.h> #include <sqlpp11/interpret.h>
@ -47,7 +47,7 @@ namespace sqlpp
}; };
template <typename Table> template <typename Table>
auto all_of(Table) -> all_of_t<Table> auto all_of(Table /*unused*/) -> all_of_t<Table>
{ {
return {}; return {};
} }
@ -60,11 +60,11 @@ namespace sqlpp
using _serialize_check = assert_no_stand_alone_all_of_t; using _serialize_check = assert_no_stand_alone_all_of_t;
using T = all_of_t<Table>; using T = all_of_t<Table>;
static Context& _(const T&, const Context&) static Context& _(const T& /*unused*/, const Context& /*unused*/)
{ {
_serialize_check{}; _serialize_check{};
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/any.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_ANY_H #ifndef SQLPP11_ANY_H
#define SQLPP_ANY_H #define SQLPP11_ANY_H
#include <sqlpp11/data_types/boolean.h> #include <sqlpp11/data_types/boolean.h>
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
@ -76,6 +76,6 @@ namespace sqlpp
// FIXME: can we accept non-values like NULL here? // FIXME: can we accept non-values like NULL here?
return {t}; return {t};
} }
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/assignment.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_ASSIGNMENT_H #ifndef SQLPP11_ASSIGNMENT_H
#define SQLPP_ASSIGNMENT_H #define SQLPP11_ASSIGNMENT_H
#include <sqlpp11/default_value.h> #include <sqlpp11/default_value.h>
#include <sqlpp11/null.h> #include <sqlpp11/null.h>
@ -77,6 +77,6 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

8
include/sqlpp11/auto_alias.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_AUTO_ALIAS_H #ifndef SQLPP11_AUTO_ALIAS_H
#define SQLPP_AUTO_ALIAS_H #define SQLPP11_AUTO_ALIAS_H
#include <sqlpp11/alias.h> #include <sqlpp11/alias.h>
@ -56,10 +56,10 @@ namespace sqlpp
{ {
using type = expression_alias_t<T, typename T::_auto_alias_t>; using type = expression_alias_t<T, typename T::_auto_alias_t>;
}; };
} } // namespace detail
template <typename T> template <typename T>
using auto_alias_t = typename detail::auto_alias_impl<T>::type; using auto_alias_t = typename detail::auto_alias_impl<T>::type;
} } // namespace sqlpp
#endif #endif

8
include/sqlpp11/bad_expression.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BAD_EXPRESSION_H #ifndef SQLPP11_BAD_EXPRESSION_H
#define SQLPP_BAD_EXPRESSION_H #define SQLPP11_BAD_EXPRESSION_H
#include <sqlpp11/portable_static_assert.h> #include <sqlpp11/portable_static_assert.h>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -38,7 +38,7 @@ namespace sqlpp
struct bad_expression struct bad_expression
{ {
template <typename... T> template <typename... T>
bad_expression(T&&...) bad_expression(T&&... /*unused*/)
{ {
} }
using _traits = make_traits<ValueType, tag::is_expression>; using _traits = make_traits<ValueType, tag::is_expression>;
@ -53,6 +53,6 @@ namespace sqlpp
static Context& _(const T&, Context&); static Context& _(const T&, Context&);
}; };
} } // namespace sqlpp
#endif #endif

10
include/sqlpp11/basic_expression_operators.h
View File

@ -25,8 +25,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DETAIL_BASIC_EXPRESSION_OPERATORS_H #ifndef SQLPP11_BASIC_EXPRESSION_OPERATORS_H
#define SQLPP_DETAIL_BASIC_EXPRESSION_OPERATORS_H #define SQLPP11_BASIC_EXPRESSION_OPERATORS_H
#include <sqlpp11/value_type_fwd.h> #include <sqlpp11/value_type_fwd.h>
#include <sqlpp11/bad_expression.h> #include <sqlpp11/bad_expression.h>
@ -82,7 +82,7 @@ namespace sqlpp
{ {
using type = Expr<wrap_operand_t<Lhs>, wrap_operand_t<Rhs>>; using type = Expr<wrap_operand_t<Lhs>, wrap_operand_t<Rhs>>;
}; };
} } // namespace detail
template <template <typename Lhs, typename Rhs> class Expr, typename Lhs, typename Rhs> template <template <typename Lhs, typename Rhs> class Expr, typename Lhs, typename Rhs>
using comparison_expression_t = using comparison_expression_t =
typename detail::comparison_expression_impl<check_comparison_t<Lhs, Rhs>::value, Expr, Lhs, Rhs>::type; typename detail::comparison_expression_impl<check_comparison_t<Lhs, Rhs>::value, Expr, Lhs, Rhs>::type;
@ -100,7 +100,7 @@ namespace sqlpp
{ {
using type = Expr<Lhs, Rhs...>; using type = Expr<Lhs, Rhs...>;
}; };
} } // namespace detail
template <typename Check, template <typename Lhs, typename... Rhs> class Expr, typename Lhs, typename... Rhs> template <typename Check, template <typename Lhs, typename... Rhs> class Expr, typename Lhs, typename... Rhs>
using in_expression_t = typename detail::in_expression_impl<Check::value, Expr, Lhs, Rhs...>::type; using in_expression_t = typename detail::in_expression_impl<Check::value, Expr, Lhs, Rhs...>::type;
@ -300,6 +300,6 @@ namespace sqlpp
return {*static_cast<const Expr*>(this)}; return {*static_cast<const Expr*>(this)};
} }
}; };
} } // namespace sqlpp
#endif #endif

11
include/sqlpp11/boolean_expression.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_EXPRESSION_H #ifndef SQLPP11_BOOLEAN_EXPRESSION_H
#define SQLPP_BOOLEAN_EXPRESSION_H #define SQLPP11_BOOLEAN_EXPRESSION_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/interpretable.h> #include <sqlpp11/interpretable.h>
@ -39,8 +39,7 @@ namespace sqlpp
using _nodes = detail::type_vector<>; using _nodes = detail::type_vector<>;
template <typename Expr> template <typename Expr>
boolean_expression_t(Expr expr) boolean_expression_t(Expr expr) : _expr(expr)
: _expr(expr)
{ {
static_assert(is_expression_t<Expr>::value, "boolean_expression requires a boolean expression argument"); static_assert(is_expression_t<Expr>::value, "boolean_expression requires a boolean expression argument");
static_assert(is_boolean_t<Expr>::value, "boolean_expression requires a boolean expression argument"); static_assert(is_boolean_t<Expr>::value, "boolean_expression requires a boolean expression argument");
@ -63,7 +62,7 @@ namespace sqlpp
} }
template <typename Database, typename T> template <typename Database, typename T>
boolean_expression_t<Database> boolean_expression(const Database&, T t) boolean_expression_t<Database> boolean_expression(const Database& /*unused*/, T t)
{ {
return boolean_expression<Database>(t); return boolean_expression<Database>(t);
} }
@ -79,6 +78,6 @@ namespace sqlpp
return serialize(t._expr, context); return serialize(t._expr, context);
} }
}; };
} } // namespace sqlpp
#endif #endif

14
include/sqlpp11/case.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_CASE_H #ifndef SQLPP11_CASE_H
#define SQLPP_CASE_H #define SQLPP11_CASE_H
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
#include <sqlpp11/data_types/boolean.h> #include <sqlpp11/data_types/boolean.h>
@ -87,7 +87,7 @@ namespace sqlpp
class case_then_t class case_then_t
{ {
template <typename Else> template <typename Else>
auto _else_impl(consistent_t, Else else_) -> case_t<When, Then, Else> auto _else_impl(consistent_t /*unused*/, Else else_) -> case_t<When, Then, Else>
{ {
return {_when, _then, else_}; return {_when, _then, else_};
} }
@ -121,7 +121,7 @@ namespace sqlpp
class case_when_t class case_when_t
{ {
template <typename Then> template <typename Then>
auto _then_impl(consistent_t, Then t) -> case_then_t<When, wrap_operand_t<Then>> auto _then_impl(consistent_t /*unused*/, Then t) -> case_then_t<When, wrap_operand_t<Then>>
{ {
return {_when, t}; return {_when, t};
} }
@ -172,20 +172,20 @@ namespace sqlpp
namespace detail namespace detail
{ {
template <typename When> template <typename When>
auto case_when_impl(consistent_t, When when) -> case_when_t<wrap_operand_t<When>> auto case_when_impl(consistent_t /*unused*/, When when) -> case_when_t<wrap_operand_t<When>>
{ {
return {when}; return {when};
} }
template <typename Check, typename When> template <typename Check, typename When>
auto case_when_impl(Check, When when) -> inconsistent<Check>; auto case_when_impl(Check, When when) -> inconsistent<Check>;
} } // namespace detail
template <typename When> template <typename When>
auto case_when(When when) -> decltype(detail::case_when_impl(check_case_when_t<When>{}, when)) auto case_when(When when) -> decltype(detail::case_when_impl(check_case_when_t<When>{}, when))
{ {
return detail::case_when_impl(check_case_when_t<When>{}, when); return detail::case_when_impl(check_case_when_t<When>{}, when);
} }
} } // namespace sqlpp
#endif #endif

12
include/sqlpp11/char_sequence.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_CHAR_SEQUENCE_H #ifndef SQLPP11_CHAR_SEQUENCE_H
#define SQLPP_CHAR_SEQUENCE_H #define SQLPP11_CHAR_SEQUENCE_H
#include <sqlpp11/detail/index_sequence.h> #include <sqlpp11/detail/index_sequence.h>
@ -41,18 +41,18 @@ namespace sqlpp
}; };
}; };
template <std::size_t N, const char(&s)[N], typename T> template <std::size_t N, const char (&s)[N], typename T>
struct make_char_sequence_impl; struct make_char_sequence_impl;
template <std::size_t N, const char(&s)[N], std::size_t... i> template <std::size_t N, const char (&s)[N], std::size_t... i>
struct make_char_sequence_impl<N, s, sqlpp::detail::index_sequence<i...>> struct make_char_sequence_impl<N, s, sqlpp::detail::index_sequence<i...>>
{ {
using type = char_sequence<s[i]...>; using type = char_sequence<s[i]...>;
}; };
template <std::size_t N, const char(&Input)[N]> template <std::size_t N, const char (&Input)[N]>
using make_char_sequence = using make_char_sequence =
typename make_char_sequence_impl<sizeof(Input), Input, sqlpp::detail::make_index_sequence<sizeof(Input)>>::type; typename make_char_sequence_impl<sizeof(Input), Input, sqlpp::detail::make_index_sequence<sizeof(Input)>>::type;
} } // namespace sqlpp
#endif #endif

8
include/sqlpp11/chrono.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_CHRONO_H #ifndef SQLPP11_CHRONO_H
#define SQLPP_CHRONO_H #define SQLPP11_CHRONO_H
#include <date.h> #include <date.h>
@ -51,7 +51,7 @@ namespace sqlpp
const auto dp = floor<days>(t); const auto dp = floor<days>(t);
return std::chrono::duration_cast<std::chrono::microseconds>(::date::make_time(t - dp).to_duration()); return std::chrono::duration_cast<std::chrono::microseconds>(::date::make_time(t - dp).to_duration());
} }
} } // namespace chrono
} } // namespace sqlpp
#endif #endif

14
include/sqlpp11/column.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_COLUMN_H #ifndef SQLPP11_COLUMN_H
#define SQLPP_COLUMN_H #define SQLPP11_COLUMN_H
#include <sqlpp11/alias.h> #include <sqlpp11/alias.h>
#include <sqlpp11/column_fwd.h> #include <sqlpp11/column_fwd.h>
@ -78,7 +78,7 @@ namespace sqlpp
} }
template <typename alias_provider> template <typename alias_provider>
expression_alias_t<column_t, alias_provider> as(const alias_provider&) const expression_alias_t<column_t, alias_provider> as(const alias_provider& /*unused*/) const
{ {
return {*this}; return {*this};
} }
@ -92,13 +92,13 @@ namespace sqlpp
return {*this, {rhs{t}}}; return {*this, {rhs{t}}};
} }
auto operator=(null_t) const -> assignment_t<column_t, null_t> auto operator=(null_t /*unused*/) const -> assignment_t<column_t, null_t>
{ {
static_assert(can_be_null_t<column_t>::value, "column cannot be null"); static_assert(can_be_null_t<column_t>::value, "column cannot be null");
return {*this, null_t{}}; return {*this, null_t{}};
} }
auto operator=(default_value_t) const -> assignment_t<column_t, default_value_t> auto operator=(default_value_t /*unused*/) const -> assignment_t<column_t, default_value_t>
{ {
return {*this, default_value_t{}}; return {*this, default_value_t{}};
} }
@ -123,12 +123,12 @@ namespace sqlpp
using _serialize_check = consistent_t; using _serialize_check = consistent_t;
using T = column_t<Args1, Args2>; using T = column_t<Args1, Args2>;
static Context& _(const T&, Context& context) static Context& _(const T& /*unused*/, Context& context)
{ {
context << name_of<typename T::_table>::char_ptr() << '.' << name_of<T>::char_ptr(); context << name_of<typename T::_table>::char_ptr() << '.' << name_of<T>::char_ptr();
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/column_fwd.h
View File

@ -24,13 +24,13 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_COLUMN_FWD_H #ifndef SQLPP11_COLUMN_FWD_H
#define SQLPP_COLUMN_FWD_H #define SQLPP11_COLUMN_FWD_H
namespace sqlpp namespace sqlpp
{ {
template <typename Table, typename ColumnSpec> template <typename Table, typename ColumnSpec>
struct column_t; struct column_t;
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/connection.h
View File

@ -24,14 +24,14 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_CONNECTION_H #ifndef SQLPP11_CONNECTION_H
#define SQLPP_CONNECTION_H #define SQLPP11_CONNECTION_H
namespace sqlpp namespace sqlpp
{ {
struct connection struct connection
{ {
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/consistent.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_CONSISTENT_H #ifndef SQLPP11_CONSISTENT_H
#define SQLPP_CONSISTENT_H #define SQLPP11_CONSISTENT_H
#include <type_traits> #include <type_traits>
@ -35,6 +35,6 @@ namespace sqlpp
{ {
static void _(){}; static void _(){};
}; };
} } // namespace sqlpp
#endif #endif

14
include/sqlpp11/cte.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_CTE_H #ifndef SQLPP11_CTE_H
#define SQLPP_CTE_H #define SQLPP11_CTE_H
#include <sqlpp11/expression.h> #include <sqlpp11/expression.h>
#include <sqlpp11/interpret_tuple.h> #include <sqlpp11/interpret_tuple.h>
@ -86,7 +86,7 @@ namespace sqlpp
struct cte_ref_t; struct cte_ref_t;
template <typename AliasProvider, typename Statement, typename... FieldSpecs> template <typename AliasProvider, typename Statement, typename... FieldSpecs>
auto from_table(cte_t<AliasProvider, Statement, FieldSpecs...>) -> cte_ref_t<AliasProvider> auto from_table(cte_t<AliasProvider, Statement, FieldSpecs...> /*unused*/) -> cte_ref_t<AliasProvider>
{ {
return cte_ref_t<AliasProvider>{}; return cte_ref_t<AliasProvider>{};
} }
@ -208,7 +208,7 @@ namespace sqlpp
auto _union_impl(Check, Rhs rhs) const -> inconsistent<Check>; auto _union_impl(Check, Rhs rhs) const -> inconsistent<Check>;
template <typename Flag, typename Rhs> template <typename Flag, typename Rhs>
auto _union_impl(consistent_t, Rhs rhs) const auto _union_impl(consistent_t /*unused*/, Rhs rhs) const
-> cte_t<AliasProvider, cte_union_t<Flag, Statement, Rhs>, FieldSpecs...> -> cte_t<AliasProvider, cte_union_t<Flag, Statement, Rhs>, FieldSpecs...>
{ {
return cte_union_t<Flag, Statement, Rhs>{_statement, rhs}; return cte_union_t<Flag, Statement, Rhs>{_statement, rhs};
@ -277,7 +277,7 @@ namespace sqlpp
using _serialize_check = consistent_t; using _serialize_check = consistent_t;
using T = cte_ref_t<AliasProvider>; using T = cte_ref_t<AliasProvider>;
static Context& _(const T&, Context& context) static Context& _(const T& /*unused*/, Context& context)
{ {
context << name_of<T>::char_ptr(); context << name_of<T>::char_ptr();
return context; return context;
@ -285,10 +285,10 @@ namespace sqlpp
}; };
template <typename AliasProvider> template <typename AliasProvider>
auto cte(const AliasProvider&) -> cte_ref_t<AliasProvider> auto cte(const AliasProvider & /*unused*/) -> cte_ref_t<AliasProvider>
{ {
return {}; return {};
} }
} } // namespace sqlpp
#endif #endif

11
include/sqlpp11/custom_query.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_CUSTOM_QUERY_H #ifndef SQLPP11_CUSTOM_QUERY_H
#define SQLPP_CUSTOM_QUERY_H #define SQLPP11_CUSTOM_QUERY_H
#include <sqlpp11/connection.h> #include <sqlpp11/connection.h>
#include <sqlpp11/detail/get_first.h> #include <sqlpp11/detail/get_first.h>
@ -59,7 +59,7 @@ namespace sqlpp
using _result_type_provider = typename unhide<_maybe_hidden_result_type_provider>::type; using _result_type_provider = typename unhide<_maybe_hidden_result_type_provider>::type;
using _result_methods_t = typename _result_type_provider::template _result_methods_t<_result_type_provider>; using _result_methods_t = typename _result_type_provider::template _result_methods_t<_result_type_provider>;
}; };
} } // namespace detail
template <typename Database, typename... Parts> template <typename Database, typename... Parts>
struct custom_query_t : private detail::custom_parts_t<Database, Parts...>::_result_methods_t struct custom_query_t : private detail::custom_parts_t<Database, Parts...>::_result_methods_t
@ -143,12 +143,13 @@ namespace sqlpp
} }
template <typename Database, typename... Parts> template <typename Database, typename... Parts>
auto dynamic_custom_query(const Database&, Parts... parts) -> custom_query_t<Database, wrap_operand_t<Parts>...> auto dynamic_custom_query(const Database& /*unused*/, Parts... parts)
-> custom_query_t<Database, wrap_operand_t<Parts>...>
{ {
static_assert(sizeof...(Parts) > 0, "custom query requires at least one query argument"); static_assert(sizeof...(Parts) > 0, "custom query requires at least one query argument");
static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter"); static_assert(std::is_base_of<connection, Database>::value, "Invalid database parameter");
return custom_query_t<Database, wrap_operand_t<Parts>...>(parts...); return custom_query_t<Database, wrap_operand_t<Parts>...>(parts...);
} }
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DATA_TYPES_H #ifndef SQLPP11_DATA_TYPES_H
#define SQLPP_DATA_TYPES_H #define SQLPP11_DATA_TYPES_H
#include <sqlpp11/data_types/boolean.h> #include <sqlpp11/data_types/boolean.h>
#include <sqlpp11/data_types/integral.h> #include <sqlpp11/data_types/integral.h>

4
include/sqlpp11/data_types/boolean.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_H #ifndef SQLPP11_DATA_TYPES_BOOLEAN_H
#define SQLPP_BOOLEAN_H #define SQLPP11_DATA_TYPES_BOOLEAN_H
#include <sqlpp11/data_types/boolean/data_type.h> #include <sqlpp11/data_types/boolean/data_type.h>
#include <sqlpp11/data_types/boolean/operand.h> #include <sqlpp11/data_types/boolean/operand.h>

6
include/sqlpp11/data_types/boolean/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_COLUMN_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_BOOLEAN_COLUMN_OPERATORS_H
#define SQLPP_BOOLEAN_COLUMN_OPERATORS_H #define SQLPP11_DATA_TYPES_BOOLEAN_COLUMN_OPERATORS_H
#include <sqlpp11/data_types/column_operators.h> #include <sqlpp11/data_types/column_operators.h>
@ -37,5 +37,5 @@ namespace sqlpp
struct column_operators<Column, boolean> struct column_operators<Column, boolean>
{ {
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/boolean/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_BOOLEAN_DATA_TYPE_H
#define SQLPP_BOOLEAN_DATA_TYPE_H #define SQLPP11_DATA_TYPES_BOOLEAN_DATA_TYPE_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -41,6 +41,6 @@ namespace sqlpp
}; };
using bit = sqlpp::boolean; using bit = sqlpp::boolean;
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/boolean/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_BOOLEAN_EXPRESSION_OPERATORS_H
#define SQLPP_BOOLEAN_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_BOOLEAN_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_return_types.h> #include <sqlpp11/expression_return_types.h>
#include <sqlpp11/operand_check.h> #include <sqlpp11/operand_check.h>
@ -59,6 +59,6 @@ namespace sqlpp
using check = consistent_t; using check = consistent_t;
using type = logical_not_t<wrap_operand_t<T>>; using type = logical_not_t<wrap_operand_t<T>>;
}; };
} } // namespace sqlpp
#endif #endif

10
include/sqlpp11/data_types/boolean/operand.h
View File

@ -24,8 +24,10 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_OPERAND_H #ifndef SQLPP11_DATA_TYPES_BOOLEAN_OPERAND_H
#define SQLPP_BOOLEAN_OPERAND_H #define SQLPP11_DATA_TYPES_BOOLEAN_OPERAND_H
#include <ciso646> // Required for some compilers to use aliases for boolean operators
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/alias_operators.h> #include <sqlpp11/alias_operators.h>
@ -59,7 +61,7 @@ namespace sqlpp
bool _is_trivial() const bool _is_trivial() const
{ {
return _t == false; return not _t;
} }
_value_t _t; _value_t _t;
@ -77,6 +79,6 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/boolean/parameter_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_BOOLEAN_PARAMETER_VALUE_H
#define SQLPP_BOOLEAN_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_BOOLEAN_PARAMETER_VALUE_H
#include <sqlpp11/data_types/parameter_value.h> #include <sqlpp11/data_types/parameter_value.h>
#include <sqlpp11/data_types/parameter_value_base.h> #include <sqlpp11/data_types/parameter_value_base.h>
@ -47,6 +47,6 @@ namespace sqlpp
target._bind_boolean_parameter(index, &_value, _is_null); target._bind_boolean_parameter(index, &_value, _is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/boolean/result_field.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_RESULT_FIELD_H #ifndef SQLPP11_DATA_TYPES_BOOLEAN_RESULT_FIELD_H
#define SQLPP_BOOLEAN_RESULT_FIELD_H #define SQLPP11_DATA_TYPES_BOOLEAN_RESULT_FIELD_H
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
#include <sqlpp11/result_field.h> #include <sqlpp11/result_field.h>
@ -51,6 +51,6 @@ namespace sqlpp
target._post_bind_boolean_result(index, &this->_value, &this->_is_null); target._post_bind_boolean_result(index, &this->_value, &this->_is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/boolean/wrap_operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_BOOLEAN_WRAP_OPERAND_H #ifndef SQLPP11_DATA_TYPES_BOOLEAN_WRAP_OPERAND_H
#define SQLPP_BOOLEAN_WRAP_OPERAND_H #define SQLPP11_DATA_TYPES_BOOLEAN_WRAP_OPERAND_H
#include <sqlpp11/wrap_operand.h> #include <sqlpp11/wrap_operand.h>
@ -38,6 +38,6 @@ namespace sqlpp
{ {
using type = boolean_operand; using type = boolean_operand;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_COLUMN_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_COLUMN_OPERATORS_H
#define SQLPP_COLUMN_OPERATORS_H #define SQLPP11_DATA_TYPES_COLUMN_OPERATORS_H
#include <sqlpp11/wrong.h> #include <sqlpp11/wrong.h>
@ -36,6 +36,6 @@ namespace sqlpp
{ {
static_assert(wrong_t<column_operators>::value, "Missing column operators for ValueType"); static_assert(wrong_t<column_operators>::value, "Missing column operators for ValueType");
}; };
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types/day_point.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DAY_POINT_H #ifndef SQLPP11_DATA_TYPES_DAY_POINT_H
#define SQLPP_DAY_POINT_H #define SQLPP11_DATA_TYPES_DAY_POINT_H
#include <sqlpp11/data_types/day_point/data_type.h> #include <sqlpp11/data_types/day_point/data_type.h>
#include <sqlpp11/data_types/day_point/operand.h> #include <sqlpp11/data_types/day_point/operand.h>

6
include/sqlpp11/data_types/day_point/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DAY_POINT_COLUMN_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_DAY_POINT_COLUMN_OPERATORS_H
#define SQLPP_DAY_POINT_COLUMN_OPERATORS_H #define SQLPP11_DATA_TYPES_DAY_POINT_COLUMN_OPERATORS_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/assignment.h> #include <sqlpp11/assignment.h>
@ -40,5 +40,5 @@ namespace sqlpp
template <typename T> template <typename T>
using _is_valid_operand = is_valid_operand<day_point, T>; using _is_valid_operand = is_valid_operand<day_point, T>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/day_point/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DAY_POINT_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_DAY_POINT_DATA_TYPE_H
#define SQLPP_DAY_POINT_DATA_TYPE_H #define SQLPP11_DATA_TYPES_DAY_POINT_DATA_TYPE_H
#include <sqlpp11/chrono.h> #include <sqlpp11/chrono.h>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -44,5 +44,5 @@ namespace sqlpp
}; };
using date = day_point; using date = day_point;
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/day_point/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DAY_POINT_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_DAY_POINT_EXPRESSION_OPERATORS_H
#define SQLPP_DAY_POINT_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_DAY_POINT_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_operators.h> #include <sqlpp11/expression_operators.h>
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
@ -38,5 +38,5 @@ namespace sqlpp
struct expression_operators<Expression, day_point> : public basic_expression_operators<Expression> struct expression_operators<Expression, day_point> : public basic_expression_operators<Expression>
{ {
}; };
} } // namespace sqlpp
#endif #endif

10
include/sqlpp11/data_types/day_point/operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DAY_POINT_OPERAND_H #ifndef SQLPP11_DATA_TYPES_DAY_POINT_OPERAND_H
#define SQLPP_DAY_POINT_OPERAND_H #define SQLPP11_DATA_TYPES_DAY_POINT_OPERAND_H
#include <date.h> #include <date.h>
#include <sqlpp11/chrono.h> #include <sqlpp11/chrono.h>
@ -45,9 +45,7 @@ namespace sqlpp
using _value_t = ::sqlpp::chrono::day_point; using _value_t = ::sqlpp::chrono::day_point;
day_point_operand() : _t{} day_point_operand() = default;
{
}
day_point_operand(_value_t t) : _t(t) day_point_operand(_value_t t) : _t(t)
{ {
@ -80,5 +78,5 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/day_point/parameter_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DAY_POINT_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_DAY_POINT_PARAMETER_VALUE_H
#define SQLPP_DAY_POINT_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_DAY_POINT_PARAMETER_VALUE_H
#include <sqlpp11/data_types/parameter_value.h> #include <sqlpp11/data_types/parameter_value.h>
#include <sqlpp11/data_types/parameter_value_base.h> #include <sqlpp11/data_types/parameter_value_base.h>
@ -49,5 +49,5 @@ namespace sqlpp
target._bind_date_parameter(index, &_value, _is_null); target._bind_date_parameter(index, &_value, _is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/day_point/result_field.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DAY_POINT_RESULT_FIELD_H #ifndef SQLPP11_DATA_TYPES_DAY_POINT_RESULT_FIELD_H
#define SQLPP_DAY_POINT_RESULT_FIELD_H #define SQLPP11_DATA_TYPES_DAY_POINT_RESULT_FIELD_H
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
#include <sqlpp11/result_field.h> #include <sqlpp11/result_field.h>
@ -68,5 +68,5 @@ namespace sqlpp
} }
return os; return os;
} }
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/day_point/wrap_operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_DAY_POINT_WRAP_OPERAND_H #ifndef SQLPP11_DATA_TYPES_DAY_POINT_WRAP_OPERAND_H
#define SQLPP_DAY_POINT_WRAP_OPERAND_H #define SQLPP11_DATA_TYPES_DAY_POINT_WRAP_OPERAND_H
#include <utility> #include <utility>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -41,5 +41,5 @@ namespace sqlpp
{ {
using type = day_point_operand; using type = day_point_operand;
}; };
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types/floating_point.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_FLOATING_POINT_H #ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_H
#define SQLPP_FLOATING_POINT_H #define SQLPP11_DATA_TYPES_FLOATING_POINT_H
#include <sqlpp11/data_types/floating_point/data_type.h> #include <sqlpp11/data_types/floating_point/data_type.h>
#include <sqlpp11/data_types/floating_point/operand.h> #include <sqlpp11/data_types/floating_point/operand.h>

6
include/sqlpp11/data_types/floating_point/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_FLOATING_POINT_COLUMN_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_COLUMN_OPERATORS_H
#define SQLPP_FLOATING_POINT_COLUMN_OPERATORS_H #define SQLPP11_DATA_TYPES_FLOATING_POINT_COLUMN_OPERATORS_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/assignment.h> #include <sqlpp11/assignment.h>
@ -76,5 +76,5 @@ namespace sqlpp
return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}}; return {*static_cast<const Column*>(this), {*static_cast<const Column*>(this), rhs{t}}};
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/floating_point/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_FLOATING_POINT_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_DATA_TYPE_H
#define SQLPP_FLOATING_POINT_DATA_TYPE_H #define SQLPP11_DATA_TYPES_FLOATING_POINT_DATA_TYPE_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -39,5 +39,5 @@ namespace sqlpp
template <typename T> template <typename T>
using _is_valid_operand = is_numeric_t<T>; using _is_valid_operand = is_numeric_t<T>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/floating_point/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_FLOATING_POINT_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_EXPRESSION_OPERATORS_H
#define SQLPP_FLOATING_POINT_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_FLOATING_POINT_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_return_types.h> #include <sqlpp11/expression_return_types.h>
#include <sqlpp11/operand_check.h> #include <sqlpp11/operand_check.h>
@ -82,5 +82,5 @@ namespace sqlpp
using check = consistent_t; using check = consistent_t;
using type = unary_minus_t<floating_point, wrap_operand_t<T>>; using type = unary_minus_t<floating_point, wrap_operand_t<T>>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/floating_point/operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_FLOATING_POINT_OPERAND_H #ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_OPERAND_H
#define SQLPP_FLOATING_POINT_OPERAND_H #define SQLPP11_DATA_TYPES_FLOATING_POINT_OPERAND_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/alias_operators.h> #include <sqlpp11/alias_operators.h>
@ -75,5 +75,5 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/floating_point/parameter_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_FLOATING_POINT_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_PARAMETER_VALUE_H
#define SQLPP_FLOATING_POINT_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_FLOATING_POINT_PARAMETER_VALUE_H
#include <sqlpp11/data_types/parameter_value.h> #include <sqlpp11/data_types/parameter_value.h>
#include <sqlpp11/data_types/parameter_value_base.h> #include <sqlpp11/data_types/parameter_value_base.h>
@ -49,5 +49,5 @@ namespace sqlpp
target._bind_floating_point_parameter(index, &_value, _is_null); target._bind_floating_point_parameter(index, &_value, _is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/floating_point/result_field.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_FLOATING_POINT_RESULT_FIELD_H #ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_RESULT_FIELD_H
#define SQLPP_FLOATING_POINT_RESULT_FIELD_H #define SQLPP11_DATA_TYPES_FLOATING_POINT_RESULT_FIELD_H
#include <sqlpp11/exception.h> #include <sqlpp11/exception.h>
#include <sqlpp11/result_field.h> #include <sqlpp11/result_field.h>
@ -52,5 +52,5 @@ namespace sqlpp
target._post_bind_floating_point_result(index, &this->_value, &this->_is_null); target._post_bind_floating_point_result(index, &this->_value, &this->_is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/floating_point/wrap_operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_FLOATING_POINT_WRAP_OPERAND_H #ifndef SQLPP11_DATA_TYPES_FLOATING_POINT_WRAP_OPERAND_H
#define SQLPP_FLOATING_POINT_WRAP_OPERAND_H #define SQLPP11_DATA_TYPES_FLOATING_POINT_WRAP_OPERAND_H
#include <utility> #include <utility>
#include <sqlpp11/wrap_operand.h> #include <sqlpp11/wrap_operand.h>
@ -39,5 +39,5 @@ namespace sqlpp
{ {
using type = floating_point_operand; using type = floating_point_operand;
}; };
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types/integral.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_INTEGRAL_H #ifndef SQLPP11_DATA_TYPES_INTEGRAL_H
#define SQLPP_INTEGRAL_H #define SQLPP11_DATA_TYPES_INTEGRAL_H
#include <sqlpp11/data_types/integral/data_type.h> #include <sqlpp11/data_types/integral/data_type.h>
#include <sqlpp11/data_types/integral/operand.h> #include <sqlpp11/data_types/integral/operand.h>

6
include/sqlpp11/data_types/integral/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_INTEGRAL_COLUMN_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_INTEGRAL_COLUMN_OPERATORS_H
#define SQLPP_INTEGRAL_COLUMN_OPERATORS_H #define SQLPP11_DATA_TYPES_INTEGRAL_COLUMN_OPERATORS_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/assignment.h> #include <sqlpp11/assignment.h>
@ -77,6 +77,6 @@ namespace sqlpp
return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}}; return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}};
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/integral/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_INTEGRAL_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_INTEGRAL_DATA_TYPE_H
#define SQLPP_INTEGRAL_DATA_TYPE_H #define SQLPP11_DATA_TYPES_INTEGRAL_DATA_TYPE_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -44,5 +44,5 @@ namespace sqlpp
using smallint = integral; using smallint = integral;
using integer = integral; using integer = integral;
using bigint = integral; using bigint = integral;
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/integral/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_INTEGRAL_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_INTEGRAL_EXPRESSION_OPERATORS_H
#define SQLPP_INTEGRAL_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_INTEGRAL_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_return_types.h> #include <sqlpp11/expression_return_types.h>
#include <sqlpp11/operand_check.h> #include <sqlpp11/operand_check.h>
@ -132,5 +132,5 @@ namespace sqlpp
using check = consistent_t; using check = consistent_t;
using type = bitwise_or_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>; using type = bitwise_or_t<wrap_operand_t<L>, integral, wrap_operand_t<R>>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/integral/operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_INTEGRAL_OPERAND_H #ifndef SQLPP11_DATA_TYPES_INTEGRAL_OPERAND_H
#define SQLPP_INTEGRAL_OPERAND_H #define SQLPP11_DATA_TYPES_INTEGRAL_OPERAND_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/alias_operators.h> #include <sqlpp11/alias_operators.h>
@ -77,6 +77,6 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/integral/parameter_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_INTEGRAL_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_INTEGRAL_PARAMETER_VALUE_H
#define SQLPP_INTEGRAL_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_INTEGRAL_PARAMETER_VALUE_H
#include <sqlpp11/data_types/parameter_value.h> #include <sqlpp11/data_types/parameter_value.h>
#include <sqlpp11/data_types/parameter_value_base.h> #include <sqlpp11/data_types/parameter_value_base.h>
@ -47,5 +47,5 @@ namespace sqlpp
target._bind_integral_parameter(index, &_value, _is_null); target._bind_integral_parameter(index, &_value, _is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/integral/result_field.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_INTEGRAL_RESULT_FIELD_H #ifndef SQLPP11_DATA_TYPES_INTEGRAL_RESULT_FIELD_H
#define SQLPP_INTEGRAL_RESULT_FIELD_H #define SQLPP11_DATA_TYPES_INTEGRAL_RESULT_FIELD_H
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
#include <sqlpp11/result_field.h> #include <sqlpp11/result_field.h>
@ -51,5 +51,5 @@ namespace sqlpp
target._post_bind_integral_result(index, &this->_value, &this->_is_null); target._post_bind_integral_result(index, &this->_value, &this->_is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

10
include/sqlpp11/data_types/integral/wrap_operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_INTEGRAL_WRAP_OPERAND_H #ifndef SQLPP11_DATA_TYPES_INTEGRAL_WRAP_OPERAND_H
#define SQLPP_INTEGRAL_WRAP_OPERAND_H #define SQLPP11_DATA_TYPES_INTEGRAL_WRAP_OPERAND_H
#include <utility> #include <utility>
#include <sqlpp11/wrap_operand.h> #include <sqlpp11/wrap_operand.h>
@ -35,9 +35,11 @@ namespace sqlpp
struct integral_operand; struct integral_operand;
template <typename T> template <typename T>
struct wrap_operand<T, typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and not std::is_unsigned<T>::value>::type> struct wrap_operand<T,
typename std::enable_if<std::is_integral<T>::value and not std::is_same<bool, T>::value and
not std::is_unsigned<T>::value>::type>
{ {
using type = integral_operand; using type = integral_operand;
}; };
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types/no_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_NO_VALUE_H #ifndef SQLPP11_DATA_TYPES_NO_VALUE_H
#define SQLPP_NO_VALUE_H #define SQLPP11_DATA_TYPES_NO_VALUE_H
#include <sqlpp11/data_types/no_value/data_type.h> #include <sqlpp11/data_types/no_value/data_type.h>
#include <sqlpp11/data_types/no_value/operand.h> #include <sqlpp11/data_types/no_value/operand.h>

6
include/sqlpp11/data_types/no_value/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_NO_VALUE_COLUMN_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_NO_VALUE_COLUMN_OPERATORS_H
#define SQLPP_NO_VALUE_COLUMN_OPERATORS_H #define SQLPP11_DATA_TYPES_NO_VALUE_COLUMN_OPERATORS_H
#include <sqlpp11/data_types/column_operators.h> #include <sqlpp11/data_types/column_operators.h>
@ -37,5 +37,5 @@ namespace sqlpp
struct column_operators<Base, no_value_t> struct column_operators<Base, no_value_t>
{ {
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/no_value/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_NO_VALUE_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_NO_VALUE_DATA_TYPE_H
#define SQLPP_NO_VALUE_DATA_TYPE_H #define SQLPP11_DATA_TYPES_NO_VALUE_DATA_TYPE_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -39,6 +39,6 @@ namespace sqlpp
template <typename T> template <typename T>
using _is_valid_operand = wrong_t<T>; using _is_valid_operand = wrong_t<T>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/no_value/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_NO_VALUE_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_NO_VALUE_EXPRESSION_OPERATORS_H
#define SQLPP_NO_VALUE_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_NO_VALUE_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_return_types.h> #include <sqlpp11/expression_return_types.h>
#include <sqlpp11/expression_operators.h> #include <sqlpp11/expression_operators.h>
@ -37,6 +37,6 @@ namespace sqlpp
struct expression_operators<Expression, no_value_t> : public basic_expression_operators<Expression> struct expression_operators<Expression, no_value_t> : public basic_expression_operators<Expression>
{ {
}; };
} } // namespace sqlpp
#endif #endif

9
include/sqlpp11/data_types/no_value/operand.h
View File

@ -24,12 +24,7 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_NO_VALUE_OPERAND_H #ifndef SQLPP11_DATA_TYPES_NO_VALUE_OPERAND_H
#define SQLPP_NO_VALUE_OPERAND_H #define SQLPP11_DATA_TYPES_NO_VALUE_OPERAND_H
namespace sqlpp
{
// There is no no_value operand
}
#endif #endif

9
include/sqlpp11/data_types/no_value/parameter_value.h
View File

@ -24,12 +24,7 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_NO_VALUE_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_NO_VALUE_PARAMETER_VALUE_H
#define SQLPP_NO_VALUE_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_NO_VALUE_PARAMETER_VALUE_H
namespace sqlpp
{
// There is no no_value parameter
}
#endif #endif

13
include/sqlpp11/data_types/no_value/result_field.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_NO_VALUE_RESULT_FIELD_H #ifndef SQLPP11_DATA_TYPES_NO_VALUE_RESULT_FIELD_H
#define SQLPP_NO_VALUE_RESULT_FIELD_H #define SQLPP11_DATA_TYPES_NO_VALUE_RESULT_FIELD_H
#include <sqlpp11/result_field.h> #include <sqlpp11/result_field.h>
#include <sqlpp11/data_types/no_value/data_type.h> #include <sqlpp11/data_types/no_value/data_type.h>
@ -37,12 +37,12 @@ namespace sqlpp
struct result_field_t<Db, field_spec_t<NameType, no_value_t, CanBeNull, NullIsTrivialValue>> struct result_field_t<Db, field_spec_t<NameType, no_value_t, CanBeNull, NullIsTrivialValue>>
{ {
template <typename Target> template <typename Target>
void _bind(Target&, size_t) void _bind(Target& /*unused*/, size_t /*unused*/)
{ {
} }
template <typename Target> template <typename Target>
void _post_bind(Target&, size_t) void _post_bind(Target& /*unused*/, size_t /*unused*/)
{ {
} }
@ -62,11 +62,12 @@ namespace sqlpp
template <typename Db, typename NameType, bool CanBeNull, bool NullIsTrivialValue> template <typename Db, typename NameType, bool CanBeNull, bool NullIsTrivialValue>
inline std::ostream& operator<<( inline std::ostream& operator<<(
std::ostream& os, const result_field_t<Db, field_spec_t<NameType, no_value_t, CanBeNull, NullIsTrivialValue>>&) std::ostream& os,
const result_field_t<Db, field_spec_t<NameType, no_value_t, CanBeNull, NullIsTrivialValue>>& /*unused*/)
{ {
os << "NULL"; os << "NULL";
return os; return os;
} }
} } // namespace sqlpp
#endif #endif

9
include/sqlpp11/data_types/no_value/wrap_operand.h
View File

@ -24,12 +24,7 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_NO_VALUE_WRAP_OPERAND_H #ifndef SQLPP11_DATA_TYPES_NO_VALUE_WRAP_OPERAND_H
#define SQLPP_NO_VALUE_WRAP_OPERAND_H #define SQLPP11_DATA_TYPES_NO_VALUE_WRAP_OPERAND_H
namespace sqlpp
{
// There is no no_value operand
}
#endif #endif

6
include/sqlpp11/data_types/parameter_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_PARAMETER_VALUE_H
#define SQLPP_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_PARAMETER_VALUE_H
#include <sqlpp11/wrong.h> #include <sqlpp11/wrong.h>
@ -36,6 +36,6 @@ namespace sqlpp
{ {
static_assert(wrong_t<parameter_value_t>::value, "Missing parameter value type for ValueType"); static_assert(wrong_t<parameter_value_t>::value, "Missing parameter value type for ValueType");
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/parameter_value_base.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_PARAMETER_VALUE_BASE_H #ifndef SQLPP11_DATA_TYPES_PARAMETER_VALUE_BASE_H
#define SQLPP_PARAMETER_VALUE_BASE_H #define SQLPP11_DATA_TYPES_PARAMETER_VALUE_BASE_H
#include <sqlpp11/data_types/parameter_value.h> #include <sqlpp11/data_types/parameter_value.h>
#include <sqlpp11/tvin.h> #include <sqlpp11/tvin.h>
@ -94,5 +94,5 @@ namespace sqlpp
_cpp_storage_type _value; _cpp_storage_type _value;
bool _is_null; bool _is_null;
}; };
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types/text.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TEXT_H #ifndef SQLPP11_DATA_TYPES_TEXT_H
#define SQLPP_TEXT_H #define SQLPP11_DATA_TYPES_TEXT_H
#include <sqlpp11/data_types/text/data_type.h> #include <sqlpp11/data_types/text/data_type.h>
#include <sqlpp11/data_types/text/operand.h> #include <sqlpp11/data_types/text/operand.h>

6
include/sqlpp11/data_types/text/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TEXT_COLUMN_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_TEXT_COLUMN_OPERATORS_H
#define SQLPP_TEXT_COLUMN_OPERATORS_H #define SQLPP11_DATA_TYPES_TEXT_COLUMN_OPERATORS_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/assignment.h> #include <sqlpp11/assignment.h>
@ -53,5 +53,5 @@ namespace sqlpp
concat_t<Column, wrap_operand_t<T>>{*static_cast<const Column*>(this), rhs{t}}}; concat_t<Column, wrap_operand_t<T>>{*static_cast<const Column*>(this), rhs{t}}};
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/text/concat.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_CONCAT_H #ifndef SQLPP11_DATA_TYPES_TEXT_CONCAT_H
#define SQLPP_CONCAT_H #define SQLPP11_DATA_TYPES_TEXT_CONCAT_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/char_sequence.h> #include <sqlpp11/char_sequence.h>
@ -98,6 +98,6 @@ namespace sqlpp
return {args...}; return {args...};
} }
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/text/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TEXT_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_TEXT_DATA_TYPE_H
#define SQLPP_TEXT_DATA_TYPE_H #define SQLPP11_DATA_TYPES_TEXT_DATA_TYPE_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -45,5 +45,5 @@ namespace sqlpp
using char_ = text; using char_ = text;
using binary = text; using binary = text;
using varbinary = text; using varbinary = text;
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/text/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TEXT_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_TEXT_EXPRESSION_OPERATORS_H
#define SQLPP_TEXT_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_TEXT_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_operators.h> #include <sqlpp11/expression_operators.h>
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
@ -76,5 +76,5 @@ namespace sqlpp
using check = consistent_t; using check = consistent_t;
using type = concat_t<wrap_operand_t<L>, wrap_operand_t<R>>; using type = concat_t<wrap_operand_t<L>, wrap_operand_t<R>>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/text/like.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_LIKE_H #ifndef SQLPP11_DATA_TYPES_TEXT_LIKE_H
#define SQLPP_LIKE_H #define SQLPP11_DATA_TYPES_TEXT_LIKE_H
#include <sqlpp11/expression_operators.h> #include <sqlpp11/expression_operators.h>
#include <sqlpp11/alias_operators.h> #include <sqlpp11/alias_operators.h>
@ -93,6 +93,6 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

13
include/sqlpp11/data_types/text/operand.h
View File

@ -24,10 +24,11 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TEXT_OPERAND_H #ifndef SQLPP11_DATA_TYPES_TEXT_OPERAND_H
#define SQLPP_TEXT_OPERAND_H #define SQLPP11_DATA_TYPES_TEXT_OPERAND_H
#include <string> #include <string>
#include <utility>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/alias_operators.h> #include <sqlpp11/alias_operators.h>
#include <sqlpp11/serializer.h> #include <sqlpp11/serializer.h>
@ -44,11 +45,9 @@ namespace sqlpp
using _value_t = std::string; using _value_t = std::string;
text_operand() : _t{} text_operand() = default;
{
}
text_operand(_value_t t) : _t(t) text_operand(_value_t t) : _t(std::move(t))
{ {
} }
@ -78,5 +77,5 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/text/parameter_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TEXT_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_TEXT_PARAMETER_VALUE_H
#define SQLPP_TEXT_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_TEXT_PARAMETER_VALUE_H
#include <sqlpp11/data_types/parameter_value.h> #include <sqlpp11/data_types/parameter_value.h>
#include <sqlpp11/data_types/parameter_value_base.h> #include <sqlpp11/data_types/parameter_value_base.h>
@ -49,5 +49,5 @@ namespace sqlpp
target._bind_text_parameter(index, &_value, _is_null); target._bind_text_parameter(index, &_value, _is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

20
include/sqlpp11/data_types/text/result_field.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TEXT_RESULT_FIELD_H #ifndef SQLPP11_DATA_TYPES_TEXT_RESULT_FIELD_H
#define SQLPP_TEXT_RESULT_FIELD_H #define SQLPP11_DATA_TYPES_TEXT_RESULT_FIELD_H
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
#include <sqlpp11/result_field.h> #include <sqlpp11/result_field.h>
@ -48,9 +48,13 @@ namespace sqlpp
{ {
target._bind_text_result(index, &text, &len); target._bind_text_result(index, &text, &len);
if (text) if (text)
{
this->_value.assign(text, len); this->_value.assign(text, len);
}
else else
{
this->_value.assign(""); this->_value.assign("");
}
this->_is_null = (text == nullptr); this->_is_null = (text == nullptr);
} }
@ -59,9 +63,13 @@ namespace sqlpp
{ {
target._post_bind_text_result(index, &text, &len); target._post_bind_text_result(index, &text, &len);
if (text) if (text)
{
this->_value.assign(text, len); this->_value.assign(text, len);
}
else else
{
this->_value.assign(""); this->_value.assign("");
}
this->_is_null = (text == nullptr); this->_is_null = (text == nullptr);
} }
}; };
@ -74,10 +82,8 @@ namespace sqlpp
{ {
return os << "NULL"; return os << "NULL";
} }
else
{ return os << e.value();
return os << e.value();
}
} }
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/text/wrap_operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TEXT_WRAP_OPERAND_H #ifndef SQLPP11_DATA_TYPES_TEXT_WRAP_OPERAND_H
#define SQLPP_TEXT_WRAP_OPERAND_H #define SQLPP11_DATA_TYPES_TEXT_WRAP_OPERAND_H
#include <utility> #include <utility>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -42,5 +42,5 @@ namespace sqlpp
{ {
using type = text_operand; using type = text_operand;
}; };
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types/time_of_day.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_OF_DAY_H #ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_H
#define SQLPP_TIME_OF_DAY_H #define SQLPP11_DATA_TYPES_TIME_OF_DAY_H
#include <sqlpp11/data_types/time_of_day/data_type.h> #include <sqlpp11/data_types/time_of_day/data_type.h>
#include <sqlpp11/data_types/time_of_day/operand.h> #include <sqlpp11/data_types/time_of_day/operand.h>

6
include/sqlpp11/data_types/time_of_day/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_OF_DAY_COLUMN_OPERATOR_H #ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_COLUMN_OPERATORS_H
#define SQLPP_TIME_OF_DAY_COLUMN_OPERATOR_H #define SQLPP11_DATA_TYPES_TIME_OF_DAY_COLUMN_OPERATORS_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/assignment.h> #include <sqlpp11/assignment.h>
@ -40,5 +40,5 @@ namespace sqlpp
template <typename T> template <typename T>
using _is_valid_operand = is_valid_operand<time_of_day, T>; using _is_valid_operand = is_valid_operand<time_of_day, T>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_of_day/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_OF_DAY_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_DATA_TYPE_H
#define SQLPP_TIME_OF_DAY_DATA_TYPE_H #define SQLPP11_DATA_TYPES_TIME_OF_DAY_DATA_TYPE_H
#include <sqlpp11/chrono.h> #include <sqlpp11/chrono.h>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -40,5 +40,5 @@ namespace sqlpp
template <typename T> template <typename T>
using _is_valid_operand = is_time_of_day_t<T>; using _is_valid_operand = is_time_of_day_t<T>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_of_day/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_OF_DAY_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_EXPRESSION_OPERATORS_H
#define SQLPP_TIME_OF_DAY_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_TIME_OF_DAY_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_operators.h> #include <sqlpp11/expression_operators.h>
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
@ -39,5 +39,5 @@ namespace sqlpp
struct expression_operators<Expression, time_of_day> : public basic_expression_operators<Expression> struct expression_operators<Expression, time_of_day> : public basic_expression_operators<Expression>
{ {
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_of_day/operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_OF_DAY_OPERAND_H #ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_OPERAND_H
#define SQLPP_TIME_OF_DAY_OPERAND_H #define SQLPP11_DATA_TYPES_TIME_OF_DAY_OPERAND_H
#include <sqlpp11/chrono.h> #include <sqlpp11/chrono.h>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -79,5 +79,5 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_of_day/parameter_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_OF_DAY_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_PARAMETER_VALUE_H
#define SQLPP_TIME_OF_DAY_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_TIME_OF_DAY_PARAMETER_VALUE_H
#include <sqlpp11/data_types/parameter_value.h> #include <sqlpp11/data_types/parameter_value.h>
#include <sqlpp11/data_types/parameter_value_base.h> #include <sqlpp11/data_types/parameter_value_base.h>
@ -49,5 +49,5 @@ namespace sqlpp
target._bind_time_of_day_parameter(index, &_value, _is_null); target._bind_time_of_day_parameter(index, &_value, _is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_of_day/result_field.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_OF_DAY_RESULT_FIELD_H #ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_RESULT_FIELD_H
#define SQLPP_TIME_OF_DAY_RESULT_FIELD_H #define SQLPP11_DATA_TYPES_TIME_OF_DAY_RESULT_FIELD_H
#include <sqlpp11/chrono.h> #include <sqlpp11/chrono.h>
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
@ -68,5 +68,5 @@ namespace sqlpp
} }
return os; return os;
} }
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_of_day/wrap_operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_OF_DAY_WRAP_OPERAND_H #ifndef SQLPP11_DATA_TYPES_TIME_OF_DAY_WRAP_OPERAND_H
#define SQLPP_TIME_OF_DAY_WRAP_OPERAND_H #define SQLPP11_DATA_TYPES_TIME_OF_DAY_WRAP_OPERAND_H
#include <sqlpp11/wrap_operand.h> #include <sqlpp11/wrap_operand.h>
#include <sqlpp11/data_types/time_of_day/operand.h> #include <sqlpp11/data_types/time_of_day/operand.h>
@ -37,5 +37,5 @@ namespace sqlpp
{ {
using type = time_of_day_operand<std::chrono::duration<Rep, Period>>; using type = time_of_day_operand<std::chrono::duration<Rep, Period>>;
}; };
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types/time_point.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_POINT_H #ifndef SQLPP11_DATA_TYPES_TIME_POINT_H
#define SQLPP_TIME_POINT_H #define SQLPP11_DATA_TYPES_TIME_POINT_H
#include <sqlpp11/data_types/time_point/data_type.h> #include <sqlpp11/data_types/time_point/data_type.h>
#include <sqlpp11/data_types/time_point/operand.h> #include <sqlpp11/data_types/time_point/operand.h>

6
include/sqlpp11/data_types/time_point/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_POINT_COLUMN_OPERATOR_H #ifndef SQLPP11_DATA_TYPES_TIME_POINT_COLUMN_OPERATORS_H
#define SQLPP_TIME_POINT_COLUMN_OPERATOR_H #define SQLPP11_DATA_TYPES_TIME_POINT_COLUMN_OPERATORS_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/assignment.h> #include <sqlpp11/assignment.h>
@ -40,5 +40,5 @@ namespace sqlpp
template <typename T> template <typename T>
using _is_valid_operand = is_valid_operand<time_point, T>; using _is_valid_operand = is_valid_operand<time_point, T>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_point/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_POINT_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_TIME_POINT_DATA_TYPE_H
#define SQLPP_TIME_POINT_DATA_TYPE_H #define SQLPP11_DATA_TYPES_TIME_POINT_DATA_TYPE_H
#include <sqlpp11/chrono.h> #include <sqlpp11/chrono.h>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -40,5 +40,5 @@ namespace sqlpp
template <typename T> template <typename T>
using _is_valid_operand = is_day_or_time_point_t<T>; using _is_valid_operand = is_day_or_time_point_t<T>;
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_point/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_POINT_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_TIME_POINT_EXPRESSION_OPERATORS_H
#define SQLPP_TIME_POINT_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_TIME_POINT_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_operators.h> #include <sqlpp11/expression_operators.h>
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
@ -39,5 +39,5 @@ namespace sqlpp
struct expression_operators<Expression, time_point> : public basic_expression_operators<Expression> struct expression_operators<Expression, time_point> : public basic_expression_operators<Expression>
{ {
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_point/operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_POINT_OPERAND_H #ifndef SQLPP11_DATA_TYPES_TIME_POINT_OPERAND_H
#define SQLPP_TIME_POINT_OPERAND_H #define SQLPP11_DATA_TYPES_TIME_POINT_OPERAND_H
#include <sqlpp11/chrono.h> #include <sqlpp11/chrono.h>
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -82,5 +82,5 @@ namespace sqlpp
return context; return context;
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_point/parameter_value.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_POINT_PARAMETER_VALUE_H #ifndef SQLPP11_DATA_TYPES_TIME_POINT_PARAMETER_VALUE_H
#define SQLPP_TIME_POINT_PARAMETER_VALUE_H #define SQLPP11_DATA_TYPES_TIME_POINT_PARAMETER_VALUE_H
#include <sqlpp11/data_types/parameter_value.h> #include <sqlpp11/data_types/parameter_value.h>
#include <sqlpp11/data_types/parameter_value_base.h> #include <sqlpp11/data_types/parameter_value_base.h>
@ -49,5 +49,5 @@ namespace sqlpp
target._bind_date_time_parameter(index, &_value, _is_null); target._bind_date_time_parameter(index, &_value, _is_null);
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_point/result_field.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_POINT_RESULT_FIELD_H #ifndef SQLPP11_DATA_TYPES_TIME_POINT_RESULT_FIELD_H
#define SQLPP_TIME_POINT_RESULT_FIELD_H #define SQLPP11_DATA_TYPES_TIME_POINT_RESULT_FIELD_H
#include <sqlpp11/chrono.h> #include <sqlpp11/chrono.h>
#include <sqlpp11/basic_expression_operators.h> #include <sqlpp11/basic_expression_operators.h>
@ -71,5 +71,5 @@ namespace sqlpp
} }
return os; return os;
} }
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/time_point/wrap_operand.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_TIME_POINT_WRAP_OPERAND_H #ifndef SQLPP11_DATA_TYPES_TIME_POINT_WRAP_OPERAND_H
#define SQLPP_TIME_POINT_WRAP_OPERAND_H #define SQLPP11_DATA_TYPES_TIME_POINT_WRAP_OPERAND_H
#include <sqlpp11/wrap_operand.h> #include <sqlpp11/wrap_operand.h>
#include <sqlpp11/data_types/time_point/operand.h> #include <sqlpp11/data_types/time_point/operand.h>
@ -37,5 +37,5 @@ namespace sqlpp
{ {
using type = time_point_operand<Period>; using type = time_point_operand<Period>;
}; };
} } // namespace sqlpp
#endif #endif

4
include/sqlpp11/data_types/unsigned_integral.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_UNSIGNED_INTEGRAL_H #ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_H
#define SQLPP_UNSIGNED_INTEGRAL_H #define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_H
#include <sqlpp11/data_types/unsigned_integral/data_type.h> #include <sqlpp11/data_types/unsigned_integral/data_type.h>
#include <sqlpp11/data_types/unsigned_integral/operand.h> #include <sqlpp11/data_types/unsigned_integral/operand.h>

6
include/sqlpp11/data_types/unsigned_integral/column_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_UNSIGNED_INTEGRAL_COLUMN_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_COLUMN_OPERATORS_H
#define SQLPP_UNSIGNED_INTEGRAL_COLUMN_OPERATORS_H #define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_COLUMN_OPERATORS_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
#include <sqlpp11/assignment.h> #include <sqlpp11/assignment.h>
@ -77,6 +77,6 @@ namespace sqlpp
return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}}; return {*static_cast<const Column*>(this), {{*static_cast<const Column*>(this), rhs{t}}}};
} }
}; };
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/unsigned_integral/data_type.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_UNSIGNED_INTEGRAL_DATA_TYPE_H #ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_DATA_TYPE_H
#define SQLPP_UNSIGNED_INTEGRAL_DATA_TYPE_H #define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_DATA_TYPE_H
#include <sqlpp11/type_traits.h> #include <sqlpp11/type_traits.h>
@ -44,5 +44,5 @@ namespace sqlpp
using smallint_unsigned = unsigned_integral; using smallint_unsigned = unsigned_integral;
using integer_unsigned = unsigned_integral; using integer_unsigned = unsigned_integral;
using bigint_unsigned = unsigned_integral; using bigint_unsigned = unsigned_integral;
} } // namespace sqlpp
#endif #endif

6
include/sqlpp11/data_types/unsigned_integral/expression_operators.h
View File

@ -24,8 +24,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef SQLPP_UNSIGNED_INTEGRAL_EXPRESSION_OPERATORS_H #ifndef SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_EXPRESSION_OPERATORS_H
#define SQLPP_UNSIGNED_INTEGRAL_EXPRESSION_OPERATORS_H #define SQLPP11_DATA_TYPES_UNSIGNED_INTEGRAL_EXPRESSION_OPERATORS_H
#include <sqlpp11/expression_return_types.h> #include <sqlpp11/expression_return_types.h>
#include <sqlpp11/operand_check.h> #include <sqlpp11/operand_check.h>
@ -113,5 +113,5 @@ namespace sqlpp
using check = consistent_t; using check = consistent_t;
using type = bitwise_or_t<wrap_operand_t<L>, unsigned_integral, wrap_operand_t<R>>; using type = bitwise_or_t<wrap_operand_t<L>, unsigned_integral, wrap_operand_t<R>>;
}; };
} } // namespace sqlpp
#endif #endif

Some files were not shown because too many files have changed in this diff Show More