From 4ae843b50269c9c96584ce3e8809a9d6c47288b2 Mon Sep 17 00:00:00 2001 From: rbock Date: Fri, 30 Oct 2015 16:12:17 +0100 Subject: [PATCH] Distributed floating point include --- include/sqlpp11/data_types/floating_point.h | 267 +----------------- .../floating_point/column_operators.h | 79 ++++++ .../data_types/floating_point/data_type.h | 44 +++ .../floating_point/expression_operators.h | 88 ++++++ .../data_types/floating_point/operand.h | 65 +++++ .../floating_point/parameter_type.h | 107 +++++++ .../data_types/floating_point/result_field.h | 108 +++++++ .../data_types/floating_point/serialize.h | 55 ++++ .../data_types/floating_point/wrap_operand.h | 43 +++ include/sqlpp11/wrap_operand.h | 50 ---- 10 files changed, 597 insertions(+), 309 deletions(-) create mode 100644 include/sqlpp11/data_types/floating_point/column_operators.h create mode 100644 include/sqlpp11/data_types/floating_point/data_type.h create mode 100644 include/sqlpp11/data_types/floating_point/expression_operators.h create mode 100644 include/sqlpp11/data_types/floating_point/operand.h create mode 100644 include/sqlpp11/data_types/floating_point/parameter_type.h create mode 100644 include/sqlpp11/data_types/floating_point/result_field.h create mode 100644 include/sqlpp11/data_types/floating_point/serialize.h create mode 100644 include/sqlpp11/data_types/floating_point/wrap_operand.h diff --git a/include/sqlpp11/data_types/floating_point.h b/include/sqlpp11/data_types/floating_point.h index 053b624d..e7c53bba 100644 --- a/include/sqlpp11/data_types/floating_point.h +++ b/include/sqlpp11/data_types/floating_point.h @@ -27,264 +27,13 @@ #ifndef SQLPP_FLOATING_POINT_H #define SQLPP_FLOATING_POINT_H -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include -namespace sqlpp -{ - // floating_point value type - struct floating_point - { - using _traits = make_traits; - using _tag = tag::is_floating_point; - using _cpp_value_type = double; - - template - using _is_valid_operand = is_numeric_t; - }; - - // floating_point parameter type - template <> - struct parameter_value_t - { - using _value_type = floating_point; - using _cpp_value_type = typename _value_type::_cpp_value_type; - - parameter_value_t() : _value(0), _is_null(true) - { - } - - parameter_value_t(const _cpp_value_type& val) : _value(val), _is_null(false) - { - } - - parameter_value_t& operator=(const _cpp_value_type& val) - { - _value = val; - _is_null = false; - return *this; - } - - parameter_value_t& operator=(const tvin_t>& t) - { - if (t._is_trivial()) - { - _value = 0; - _is_null = true; - } - else - { - _value = t._value._t; - _is_null = false; - } - return *this; - } - - parameter_value_t& operator=(const std::nullptr_t&) - { - _value = 0; - _is_null = true; - return *this; - } - - bool is_null() const - { - return _is_null; - } - - const _cpp_value_type& value() const - { - return _value; - } - - operator _cpp_value_type() const - { - return _value; - } - - template - void _bind(Target& target, size_t index) const - { - target._bind_floating_point_parameter(index, &_value, _is_null); - } - - private: - _cpp_value_type _value; - bool _is_null; - }; - - // floating_point expression operators - template - struct expression_operators : public basic_expression_operators - { - template - using _is_valid_operand = is_valid_operand; - - template - plus_t> operator+(T t) const - { - using rhs = wrap_operand_t; - static_assert(_is_valid_operand::value, "invalid rhs operand"); - - return {*static_cast(this), rhs{t}}; - } - - template - minus_t> operator-(T t) const - { - using rhs = wrap_operand_t; - static_assert(_is_valid_operand::value, "invalid rhs operand"); - - return {*static_cast(this), rhs{t}}; - } - - template - multiplies_t> operator*(T t) const - { - using rhs = wrap_operand_t; - - return {*static_cast(this), rhs{t}}; - } - - template - divides_t> operator/(T t) const - { - using rhs = wrap_operand_t; - - return {*static_cast(this), rhs{t}}; - } - - unary_plus_t operator+() const - { - return {*static_cast(this)}; - } - - unary_minus_t operator-() const - { - return {*static_cast(this)}; - } - }; - - // floating_point column operators - template - struct column_operators - { - template - using _is_valid_operand = is_valid_operand; - - template - auto operator+=(T t) const -> assignment_t>> - { - using rhs = wrap_operand_t; - static_assert(_is_valid_operand::value, "invalid rhs assignment operand"); - - return {*static_cast(this), {*static_cast(this), rhs{t}}}; - } - - template - auto operator-=(T t) const -> assignment_t>> - { - using rhs = wrap_operand_t; - static_assert(_is_valid_operand::value, "invalid rhs assignment operand"); - - return {*static_cast(this), {*static_cast(this), rhs{t}}}; - } - - template - auto operator/=(T t) const -> assignment_t>> - { - using rhs = wrap_operand_t; - static_assert(_is_valid_operand::value, "invalid rhs assignment operand"); - - return {*static_cast(this), {*static_cast(this), rhs{t}}}; - } - - template - auto operator*=(T t) const -> assignment_t>> - { - using rhs = wrap_operand_t; - static_assert(_is_valid_operand::value, "invalid rhs assignment operand"); - - return {*static_cast(this), {*static_cast(this), rhs{t}}}; - } - }; - // floating_point result field - template - struct result_field_t - : public result_field_methods_t> - { - static_assert(std::is_same, floating_point>::value, "field type mismatch"); - using _cpp_value_type = typename floating_point::_cpp_value_type; - - result_field_t() : _is_valid(false), _is_null(true), _value(0) - { - } - - void _validate() - { - _is_valid = true; - } - - void _invalidate() - { - _is_valid = false; - _is_null = true; - _value = 0; - } - - bool is_null() const - { - if (not _is_valid) - throw exception("accessing is_null in non-existing row"); - return _is_null; - } - - bool _is_trivial() const - { - if (not _is_valid) - throw exception("accessing is_null in non-existing row"); - - return value() == 0; - } - - _cpp_value_type value() const - { - if (not _is_valid) - throw exception("accessing value in non-existing row"); - - if (_is_null) - { - if (enforce_null_result_treatment_t::value and not null_is_trivial_value_t::value) - { - throw exception("accessing value of NULL field"); - } - else - { - return 0; - } - } - return _value; - } - - template - void _bind(Target& target, size_t i) - { - target._bind_floating_point_result(i, &_value, &_is_null); - } - - private: - bool _is_valid; - bool _is_null; - _cpp_value_type _value; - }; - - template - inline std::ostream& operator<<(std::ostream& os, const result_field_t& e) - { - return serialize(e, os); - } -} #endif diff --git a/include/sqlpp11/data_types/floating_point/column_operators.h b/include/sqlpp11/data_types/floating_point/column_operators.h new file mode 100644 index 00000000..dd3cda2b --- /dev/null +++ b/include/sqlpp11/data_types/floating_point/column_operators.h @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2013-2015, 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 SQLPP_FLOATING_POINT_COLUMN_OPERATORS_H +#define SQLPP_FLOATING_POINT_COLUMN_OPERATORS_H + +#include +#include +#include + +namespace sqlpp +{ + template + struct column_operators + { + template + using _is_valid_operand = is_valid_operand; + + template + auto operator+=(T t) const -> assignment_t>> + { + using rhs = wrap_operand_t; + static_assert(_is_valid_operand::value, "invalid rhs assignment operand"); + + return {*static_cast(this), {*static_cast(this), rhs{t}}}; + } + + template + auto operator-=(T t) const -> assignment_t>> + { + using rhs = wrap_operand_t; + static_assert(_is_valid_operand::value, "invalid rhs assignment operand"); + + return {*static_cast(this), {*static_cast(this), rhs{t}}}; + } + + template + auto operator/=(T t) const -> assignment_t>> + { + using rhs = wrap_operand_t; + static_assert(_is_valid_operand::value, "invalid rhs assignment operand"); + + return {*static_cast(this), {*static_cast(this), rhs{t}}}; + } + + template + auto operator*=(T t) const -> assignment_t>> + { + using rhs = wrap_operand_t; + static_assert(_is_valid_operand::value, "invalid rhs assignment operand"); + + return {*static_cast(this), {*static_cast(this), rhs{t}}}; + } + }; +} +#endif diff --git a/include/sqlpp11/data_types/floating_point/data_type.h b/include/sqlpp11/data_types/floating_point/data_type.h new file mode 100644 index 00000000..d4c43887 --- /dev/null +++ b/include/sqlpp11/data_types/floating_point/data_type.h @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2013-2015, 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 SQLPP_FLOATING_POINT_DATA_TYPE_H +#define SQLPP_FLOATING_POINT_DATA_TYPE_H + +#include + +namespace sqlpp +{ + struct floating_point + { + using _traits = make_traits; + using _tag = tag::is_floating_point; + using _cpp_value_type = double; + + template + using _is_valid_operand = is_numeric_t; + }; +} +#endif diff --git a/include/sqlpp11/data_types/floating_point/expression_operators.h b/include/sqlpp11/data_types/floating_point/expression_operators.h new file mode 100644 index 00000000..773eebca --- /dev/null +++ b/include/sqlpp11/data_types/floating_point/expression_operators.h @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2013-2015, 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 SQLPP_FLOATING_POINT_EXPRESSION_OPERATORS_H +#define SQLPP_FLOATING_POINT_EXPRESSION_OPERATORS_H + +#include +#include +#include +#include + +namespace sqlpp +{ + template + struct expression_operators : public basic_expression_operators + { + template + using _is_valid_operand = is_valid_operand; + + template + plus_t> operator+(T t) const + { + using rhs = wrap_operand_t; + static_assert(_is_valid_operand::value, "invalid rhs operand"); + + return {*static_cast(this), rhs{t}}; + } + + template + minus_t> operator-(T t) const + { + using rhs = wrap_operand_t; + static_assert(_is_valid_operand::value, "invalid rhs operand"); + + return {*static_cast(this), rhs{t}}; + } + + template + multiplies_t> operator*(T t) const + { + using rhs = wrap_operand_t; + + return {*static_cast(this), rhs{t}}; + } + + template + divides_t> operator/(T t) const + { + using rhs = wrap_operand_t; + + return {*static_cast(this), rhs{t}}; + } + + unary_plus_t operator+() const + { + return {*static_cast(this)}; + } + + unary_minus_t operator-() const + { + return {*static_cast(this)}; + } + }; +} +#endif diff --git a/include/sqlpp11/data_types/floating_point/operand.h b/include/sqlpp11/data_types/floating_point/operand.h new file mode 100644 index 00000000..e13d890f --- /dev/null +++ b/include/sqlpp11/data_types/floating_point/operand.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2013-2015, 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 SQLPP_FLOATING_POINT_OPERAND_H +#define SQLPP_FLOATING_POINT_OPERAND_H + +#include +#include + +namespace sqlpp +{ + struct floating_point_operand : public alias_operators + { + using _traits = make_traits; + using _nodes = detail::type_vector<>; + using _is_aggregate_expression = std::true_type; + + using _value_t = double; + + floating_point_operand() : _t{} + { + } + + floating_point_operand(_value_t t) : _t(t) + { + } + + floating_point_operand(const floating_point_operand&) = default; + floating_point_operand(floating_point_operand&&) = default; + floating_point_operand& operator=(const floating_point_operand&) = default; + floating_point_operand& operator=(floating_point_operand&&) = default; + ~floating_point_operand() = default; + + bool _is_trivial() const + { + return _t == 0; + } + + _value_t _t; + }; +} +#endif diff --git a/include/sqlpp11/data_types/floating_point/parameter_type.h b/include/sqlpp11/data_types/floating_point/parameter_type.h new file mode 100644 index 00000000..9a6b0e97 --- /dev/null +++ b/include/sqlpp11/data_types/floating_point/parameter_type.h @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2013-2015, 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 SQLPP_FLOATING_POINT_PARAMETER_TYPE_H +#define SQLPP_FLOATING_POINT_PARAMETER_TYPE_H + +#include +#include +#include +#include +#include + +namespace sqlpp +{ + template <> + struct parameter_value_t + { + using _value_type = floating_point; + using _cpp_value_type = typename _value_type::_cpp_value_type; + + parameter_value_t() : _value(0), _is_null(true) + { + } + + parameter_value_t(const _cpp_value_type& val) : _value(val), _is_null(false) + { + } + + parameter_value_t& operator=(const _cpp_value_type& val) + { + _value = val; + _is_null = false; + return *this; + } + + parameter_value_t& operator=(const tvin_t>& t) + { + if (t._is_trivial()) + { + _value = 0; + _is_null = true; + } + else + { + _value = t._value._t; + _is_null = false; + } + return *this; + } + + parameter_value_t& operator=(const std::nullptr_t&) + { + _value = 0; + _is_null = true; + return *this; + } + + bool is_null() const + { + return _is_null; + } + + const _cpp_value_type& value() const + { + return _value; + } + + operator _cpp_value_type() const + { + return _value; + } + + template + void _bind(Target& target, size_t index) const + { + target._bind_floating_point_parameter(index, &_value, _is_null); + } + + private: + _cpp_value_type _value; + bool _is_null; + }; +} +#endif diff --git a/include/sqlpp11/data_types/floating_point/result_field.h b/include/sqlpp11/data_types/floating_point/result_field.h new file mode 100644 index 00000000..f5e93119 --- /dev/null +++ b/include/sqlpp11/data_types/floating_point/result_field.h @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2013-2015, 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 SQLPP_FLOATING_POINT_RESULT_FIELD_H +#define SQLPP_FLOATING_POINT_RESULT_FIELD_H + +#include +#include +#include +#include +#include +#include + +namespace sqlpp +{ + template + struct result_field_t + : public result_field_methods_t> + { + static_assert(std::is_same, floating_point>::value, "field type mismatch"); + using _cpp_value_type = typename floating_point::_cpp_value_type; + + result_field_t() : _is_valid(false), _is_null(true), _value(0) + { + } + + void _validate() + { + _is_valid = true; + } + + void _invalidate() + { + _is_valid = false; + _is_null = true; + _value = 0; + } + + bool is_null() const + { + if (not _is_valid) + throw exception("accessing is_null in non-existing row"); + return _is_null; + } + + bool _is_trivial() const + { + if (not _is_valid) + throw exception("accessing is_null in non-existing row"); + + return value() == 0; + } + + _cpp_value_type value() const + { + if (not _is_valid) + throw exception("accessing value in non-existing row"); + + if (_is_null) + { + if (enforce_null_result_treatment_t::value and not null_is_trivial_value_t::value) + { + throw exception("accessing value of NULL field"); + } + else + { + return 0; + } + } + return _value; + } + + template + void _bind(Target& target, size_t i) + { + target._bind_floating_point_result(i, &_value, &_is_null); + } + + private: + bool _is_valid; + bool _is_null; + _cpp_value_type _value; + }; +} +#endif diff --git a/include/sqlpp11/data_types/floating_point/serialize.h b/include/sqlpp11/data_types/floating_point/serialize.h new file mode 100644 index 00000000..018b6a71 --- /dev/null +++ b/include/sqlpp11/data_types/floating_point/serialize.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2013-2015, 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 SQLPP_FLOATING_POINT_SERIALIZE_H +#define SQLPP_FLOATING_POINT_SERIALIZE_H + +#include +#include +#include + +namespace sqlpp +{ + template + struct serializer_t + { + using _serialize_check = consistent_t; + using Operand = floating_point_operand; + + static Context& _(const Operand& t, Context& context) + { + context << t._t; + return context; + } + }; + + template + inline std::ostream& operator<<(std::ostream& os, const result_field_t& e) + { + return serialize(e, os); + } +} +#endif diff --git a/include/sqlpp11/data_types/floating_point/wrap_operand.h b/include/sqlpp11/data_types/floating_point/wrap_operand.h new file mode 100644 index 00000000..2c38b8ea --- /dev/null +++ b/include/sqlpp11/data_types/floating_point/wrap_operand.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2013-2015, 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 SQLPP_FLOATING_POINT_WRAP_OPERAND_H +#define SQLPP_FLOATING_POINT_WRAP_OPERAND_H + +#include +#include + +namespace sqlpp +{ + struct floating_point_operand; + + template + struct wrap_operand::value>::type> + { + using type = floating_point_operand; + }; +} +#endif diff --git a/include/sqlpp11/wrap_operand.h b/include/sqlpp11/wrap_operand.h index dfd4b73e..ac93c00f 100644 --- a/include/sqlpp11/wrap_operand.h +++ b/include/sqlpp11/wrap_operand.h @@ -50,7 +50,6 @@ namespace sqlpp namespace sqlpp { struct integral; - struct floating_point; struct text; struct day_point_operand : public alias_operators @@ -144,49 +143,6 @@ namespace sqlpp } }; - struct floating_point_operand : public alias_operators - { - using _traits = make_traits; - using _nodes = detail::type_vector<>; - using _is_aggregate_expression = std::true_type; - - using _value_t = double; - - floating_point_operand() : _t{} - { - } - - floating_point_operand(_value_t t) : _t(t) - { - } - - floating_point_operand(const floating_point_operand&) = default; - floating_point_operand(floating_point_operand&&) = default; - floating_point_operand& operator=(const floating_point_operand&) = default; - floating_point_operand& operator=(floating_point_operand&&) = default; - ~floating_point_operand() = default; - - bool _is_trivial() const - { - return _t == 0; - } - - _value_t _t; - }; - - template - struct serializer_t - { - using _serialize_check = consistent_t; - using Operand = floating_point_operand; - - static Context& _(const Operand& t, Context& context) - { - context << t._t; - return context; - } - }; - struct text_operand : public alias_operators { using _traits = make_traits; @@ -242,12 +198,6 @@ namespace sqlpp using type = day_point_operand; }; - template - struct wrap_operand::value>::type> - { - using type = floating_point_operand; - }; - template struct wrap_operand< T,