Merge branch 'release/0.58'

Author: rbock

.travis.yml

@@ -13,6 +13,7 @@ compiler:
 
 env:
   - CONFIG=Release
+  - CONFIG=Release TESTS_CXX_STD=17
   #- CONFIG=Debug
 
 notifications:
@@ -37,7 +38,8 @@ before_script:
          sudo apt-get install python-pyparsing;
      fi
    - if [[ "$CXX" = "g++" && "$CONFIG" = "Debug" && "$TRAVIS_OS_NAME" = "linux" ]]; then export CXXFLAGS="--coverage"; fi
-   - cmake .. -DCMAKE_BUILD_TYPE=$CONFIG -DCMAKE_PREFIX_PATH=$PWD/../date
+   - if [[ -n "${TESTS_CXX_STD:-}" && "$TRAVIS_OS_NAME" = "osx" ]]; then ADD_OPTS="-DSQLPP11_TESTS_CXX_STD=$TESTS_CXX_STD"; fi
+   - cmake .. -DCMAKE_BUILD_TYPE=$CONFIG -DCMAKE_PREFIX_PATH=$PWD/../date $ADD_OPTS
 
 script:
    - cmake --build . --config $CONFIG

include/sqlpp11/char_sequence.h

@@ -54,18 +54,19 @@ namespace sqlpp
     }
   };
 
-  template <std::size_t N, const char (&s)[N], typename T>
+  template <std::size_t N, const char* s, typename T>
   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, std::size_t... i>
   struct make_char_sequence_impl<N, s, sqlpp::detail::index_sequence<i...>>
   {
     using type = char_sequence<s[i]...>;
   };
 
-  template <std::size_t N, const char (&Input)[N]>
+  template <std::size_t N, const char* Input>
   using make_char_sequence =
       typename make_char_sequence_impl<N, Input, sqlpp::detail::make_index_sequence<N - 1>>::type;
+
 }  // namespace sqlpp
 
 #endif

include/sqlpp11/data_types/blob/result_field.h

@@ -33,6 +33,7 @@
 #include <sqlpp11/data_types/blob/data_type.h>
 #include <sqlpp11/field_spec.h>
 #include <ostream>
+#include <string>
 
 namespace sqlpp
 {
@@ -76,7 +77,9 @@ namespace sqlpp
     }
     else
     {
-      return os << e.value();
+      std::vector<uint8_t> value = e.value();
+      std::string value_str(value.begin(), value.end());
+      return os << value_str;
     }
   }
 }  // namespace sqlpp

include/sqlpp11/data_types/text/operand.h

@@ -29,6 +29,9 @@
 
 #include <string>
 #include <utility>
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/alias_operators.h>
 #include <sqlpp11/serializer.h>
@@ -50,6 +53,16 @@ namespace sqlpp
     text_operand(_value_t t) : _t(std::move(t))
     {
     }
+#if __cplusplus >= 201703L
+    // allow construction from an std::string_view
+    text_operand(std::string_view t) : _t(t)
+    {
+    }
+    // additional const char* overload, required to disambiguate
+    text_operand(const char* t) : _t(t)
+    {
+    }
+#endif
 
     text_operand(const text_operand&) = default;
     text_operand(text_operand&&) = default;

include/sqlpp11/data_types/text/wrap_operand.h

@@ -28,17 +28,26 @@
 #define SQLPP11_DATA_TYPES_TEXT_WRAP_OPERAND_H
 
 #include <utility>
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/wrap_operand.h>
 
 namespace sqlpp
 {
   struct text_operand;
 
+#if __cplusplus >= 201703L
+  using checked_type = std::string_view;
+#else
+  using checked_type = std::string;
+#endif
+
   template <typename T>
   struct wrap_operand<
       T,
-      typename std::enable_if<std::is_convertible<T, std::string>::value and not is_result_field_t<T>::value>::type>
+      typename std::enable_if<std::is_convertible<T, checked_type>::value and not is_result_field_t<T>::value>::type>
   {
     using type = text_operand;
   };

include/sqlpp11/group_by.h

@@ -102,7 +102,7 @@ namespace sqlpp
       template <typename Expression>
       void _add_impl(Expression expression, const std::true_type& /*unused*/)
       {
-        return _data._dynamic_expressions.emplace_back(expression);
+        _data._dynamic_expressions.emplace_back(expression);
       }
 
       template <typename Expression>

include/sqlpp11/having.h

@@ -103,7 +103,7 @@ namespace sqlpp
       template <typename Expr>
       void _add_impl(Expr expression, const std::true_type& /*unused*/)
       {
-        return _data._dynamic_expressions.emplace_back(expression);
+        _data._dynamic_expressions.emplace_back(expression);
       }
 
       template <typename Expr>

include/sqlpp11/insert_value.h

@@ -30,6 +30,7 @@
 #include <sqlpp11/default_value.h>
 #include <sqlpp11/null.h>
 #include <sqlpp11/tvin.h>
+#include <sqlpp11/value_or_null.h>
 #include <sqlpp11/type_traits.h>
 #include <sqlpp11/serializer.h>
 #include <sqlpp11/detail/type_set.h>
@@ -64,6 +65,7 @@ namespace sqlpp
     using _pure_value_t = typename value_type_of<Column>::_cpp_value_type;
     using _wrapped_value_t = wrap_operand_t<_pure_value_t>;
     using _tvin_t = tvin_t<_wrapped_value_t>;
+    using _value_or_null_t = value_or_null_t<typename Column::_traits::_value_type>;
 
     insert_value_t(rhs_wrap_t<_wrapped_value_t, _trivial_value_is_null> rhs)
         : _is_null(rhs._is_null()), _is_default(rhs._is_default()), _value(rhs._expr._t)
@@ -85,6 +87,11 @@ namespace sqlpp
     {
     }
 
+    insert_value_t(const rhs_wrap_t<_value_or_null_t, _trivial_value_is_null>& rhs)
+        : _is_null(rhs._expr._is_null), _is_default(false), _value{rhs._expr._value}
+    {
+    }
+
     insert_value_t(const insert_value_t&) = default;
     insert_value_t(insert_value_t&&) = default;
     insert_value_t& operator=(const insert_value_t&) = default;

include/sqlpp11/insert_value_list.h

@@ -627,17 +627,17 @@ namespace sqlpp
       context << " (";
       interpret_tuple(t._columns, ",", context);
       context << ")";
-      context << " VALUES ";
       bool first = true;
       for (const auto& row : t._insert_values)
       {
-        if (not first)
+        if (first)
         {
-          context << ',';
+          context << " VALUES ";
+          first = false;
         }
         else
         {
-          first = false;
+          context << ',';
         }
         context << '(';
         interpret_tuple(row, ",", context);
@@ -669,14 +669,18 @@ namespace sqlpp
           context << ',';
         }
         interpret_list(t._dynamic_columns, ',', context);
-        context << ") VALUES(";
-        interpret_tuple(t._values, ",", context);
-        if (sizeof...(Assignments) and not t._dynamic_values.empty())
+        context << ")";
+        if (sizeof...(Assignments) or not t._dynamic_values.empty())
         {
-          context << ',';
+          context << " VALUES(";
+          interpret_tuple(t._values, ",", context);
+          if (sizeof...(Assignments) and not t._dynamic_values.empty())
+          {
+            context << ',';
+          }
+          interpret_list(t._dynamic_values, ',', context);
+          context << ")";
         }
-        interpret_list(t._dynamic_values, ',', context);
-        context << ")";
       }
       return context;
     }

include/sqlpp11/order_by.h

@@ -100,7 +100,7 @@ namespace sqlpp
       template <typename Expression>
       void _add_impl(Expression expression, const std::true_type& /*unused*/)
       {
-        return _data._dynamic_expressions.emplace_back(expression);
+        _data._dynamic_expressions.emplace_back(expression);
       }
 
       template <typename Expression>