Merge branch 'develop' of https://github.com/rbock/sqlpp11 into develop

include/sqlpp11/connection_pool.h

@@ -1,28 +1,28 @@
 /*
-* Copyright (c) 2013 - 2017, Roland Bock, Frank Park
+ * Copyright (c) 2013 - 2017, Roland Bock, Frank Park
-* All rights reserved.
+ * All rights reserved.
-*
+ *
-* Redistribution and use in source and binary forms, with or without modification,
+ * Redistribution and use in source and binary forms, with or without modification,
-* are permitted provided that the following conditions are met:
+ * are permitted provided that the following conditions are met:
-*
+ *
-*   Redistributions of source code must retain the above copyright notice, this
+ *   Redistributions of source code must retain the above copyright notice, this
-*   list of conditions and the following disclaimer.
+ *   list of conditions and the following disclaimer.
-*
+ *
-*   Redistributions in binary form must reproduce the above copyright notice, this
+ *   Redistributions in binary form must reproduce the above copyright notice, this
-*   list of conditions and the following disclaimer in the documentation and/or
+ *   list of conditions and the following disclaimer in the documentation and/or
-*   other materials provided with the distribution.
+ *   other materials provided with the distribution.
-*
+ *
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * 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
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * 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
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+ */
 
 #ifndef SQLPP_CONNECTION_POOL_H
 #define SQLPP_CONNECTION_POOL_H
@@ -41,34 +41,38 @@ namespace sqlpp
 {
   namespace reconnect_policy
   {
-		struct auto_reconnect {
+    struct auto_reconnect
-			template<typename Connection>
+    {
+      template <typename Connection>
       void operator()(Connection* connection)
       {
-				if(!connection->is_valid())
+        if (!connection->is_valid())
-					connection->reconnect()
+          connection->reconnect();
+      }
+      template <typename Connection>
+      void clean(Connection* connection)
+      {
       }
-			template<typename Connection>
-			void clean(Connection* connection) {}
     };
 
-		using namespace std::chrono_literals;
     class periodic_reconnect
     {
     private:
       std::chrono::seconds revalidate_after;
-			std::unordered_map<void*,std::chrono::time_point<std::chrono::system_clock> > last_checked;
+      std::unordered_map<void*, std::chrono::time_point<std::chrono::system_clock>> last_checked;
 
     public:
-			periodic_reconnect(const std::chrono::seconds r = 28800s) //default wait_timeout in MySQL
+      periodic_reconnect(const std::chrono::seconds r = std::chrono::seconds(28800))  // default wait_timeout in MySQL
-				: revalidate_after(r), last_checked() {}
+          : revalidate_after(r), last_checked()
+      {
+      }
 
-			template<typename Connection>
+      template <typename Connection>
       void operator()(Connection* con)
       {
         auto last = last_checked.find(con);
         auto now = std::chrono::system_clock::now();
-				if(last == last_checked.end())
+        if (last == last_checked.end())
         {
           if (!con->is_valid())
           {
@@ -76,7 +80,7 @@ namespace sqlpp
           }
           last_checked.emplace_hint(last, con, now);
         }
-				else if(now - last->second > revalidate_after)
+        else if (now - last->second > revalidate_after)
         {
           if (!con->is_valid())
           {
@@ -85,27 +89,34 @@ namespace sqlpp
           last = now;
         }
       }
-			template<typename Connection>
+      template <typename Connection>
-			void clean(Connection* con) {
+      void clean(Connection* con)
+      {
         auto itr = last_checked.find(con);
-				if(itr != last_checked.end())
+        if (itr != last_checked.end())
         {
           last_checked.erase(itr);
         }
       }
     };
 
-		struct never_reconnect {
+    struct never_reconnect
-			template<typename Connection>
+    {
-			void operator()(Connection*) {}
+      template <typename Connection>
-			template<typename Connection>
+      void operator()(Connection*)
-			void clean(Connection*) {}
+      {
+      }
+      template <typename Connection>
+      void clean(Connection*)
+      {
+      }
     };
   }
 
   template <typename Connection_config,
             typename Reconnect_policy = reconnect_policy::auto_reconnect,
-		typename Connection = typename std::enable_if<std::is_class<Connection_config::connection>::value, Connection_config::connection>::type>
+            typename Connection = typename std::enable_if<std::is_class<typename Connection_config::connection>::value,
+                                                          typename Connection_config::connection>::type>
   class connection_pool
   {
     friend pool_connection<Connection_config, Reconnect_policy, Connection>;
@@ -146,12 +157,17 @@ namespace sqlpp
 
   public:
     connection_pool(const std::shared_ptr<Connection_config>& config, size_t pool_size)
-			: config(config), maximum_pool_size(pool_size), reconnect_policy(Reconnect_policy()) {}
+        : config(config), maximum_pool_size(pool_size), reconnect_policy(Reconnect_policy())
+    {
+    }
     ~connection_pool() = default;
     connection_pool(const connection_pool&) = delete;
     connection_pool(connection_pool&& other)
-			: config(std::move(other.config)), maximum_pool_size(std::move(other.maximum_pool_size)),
+        : config(std::move(other.config)),
-			reconnect_policy(std::move(other.reconnect_policy)) {}
+          maximum_pool_size(std::move(other.maximum_pool_size)),
+          reconnect_policy(std::move(other.reconnect_policy))
+    {
+    }
     connection_pool& operator=(const connection_pool&) = delete;
     connection_pool& operator=(connection_pool&&) = delete;
 
@@ -167,7 +183,8 @@ namespace sqlpp
 
       try
       {
-				return pool_connection<Connection_config, Reconnect_policy, Connection>(std::move(std::make_unique<Connection>(config)), this);
+        auto c = std::unique_ptr<Connection>(new Connection(*(config.get())));
+        return pool_connection<Connection_config, Reconnect_policy, Connection>(c, this);
       }
       catch (const sqlpp::exception& e)
       {
@@ -178,12 +195,12 @@ namespace sqlpp
     }
   };
 
-	template<typename Connection_config,
+  template <typename Connection_config,
             typename Reconnect_policy = reconnect_policy::auto_reconnect,
-		typename Connection = typename std::enable_if<std::is_class<Connection_config::connection>::value,Connection_config::connection>::type>
+            typename Connection = typename std::enable_if<std::is_class<typename Connection_config::connection>::value,
+                                                          typename Connection_config::connection>::type>
   connection_pool<Connection_config, Reconnect_policy, Connection> make_connection_pool(
-		const std::shared_ptr<Connection_config>& config,
+      const std::shared_ptr<Connection_config>& config, size_t max_pool_size)
-		size_t max_pool_size)
   {
     return connection_pool<Connection_config, Reconnect_policy, Connection>(config, max_pool_size);
   }

include/sqlpp11/pool_connection.h

@@ -1,28 +1,28 @@
 /*
-* Copyright (c) 2013 - 2017, Roland Bock, Frank Park
+ * Copyright (c) 2013 - 2017, Roland Bock, Frank Park
-* All rights reserved.
+ * All rights reserved.
-*
+ *
-* Redistribution and use in source and binary forms, with or without modification,
+ * Redistribution and use in source and binary forms, with or without modification,
-* are permitted provided that the following conditions are met:
+ * are permitted provided that the following conditions are met:
-*
+ *
-*   Redistributions of source code must retain the above copyright notice, this
+ *   Redistributions of source code must retain the above copyright notice, this
-*   list of conditions and the following disclaimer.
+ *   list of conditions and the following disclaimer.
-*
+ *
-*   Redistributions in binary form must reproduce the above copyright notice, this
+ *   Redistributions in binary form must reproduce the above copyright notice, this
-*   list of conditions and the following disclaimer in the documentation and/or
+ *   list of conditions and the following disclaimer in the documentation and/or
-*   other materials provided with the distribution.
+ *   other materials provided with the distribution.
-*
+ *
-* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * 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
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * 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
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
+ */
 
 #ifndef SQLPP_POOL_CONNECTION_H
 #define SQLPP_POOL_CONNECTION_H
@@ -31,7 +31,12 @@
 
 namespace sqlpp
 {
-	template <typename Connection_config, typename Reconnect_policy, typename Connection,
+  template <typename Connection_config, typename Reconnect_policy, typename Connection>
+  class connection_pool;
+
+  template <typename Connection_config,
+            typename Reconnect_policy,
+            typename Connection,
             typename Connection_pool = connection_pool<Connection_config, Reconnect_policy, Connection>>
   struct pool_connection
   {
@@ -41,33 +46,36 @@ namespace sqlpp
 
   public:
     pool_connection(std::unique_ptr<Connection>& connection, Connection_pool* origin)
-			: _impl(std::move(connection)), origin(origin) {}
+        : _impl(std::move(connection)), origin(origin)
+    {
+    }
 
     ~pool_connection()
     {
       origin->free_connection(_impl);
     }
 
-		template<typename... Args>
+    template <typename... Args>
-		auto operator()(Args&&... args) -> decltype(_impl->args(std::forward<Args>(args)...))
+    auto operator()(Args&&... args) -> decltype((*_impl)(std::forward<Args>(args)...))
     {
-			return _impl->args(std::forward<Args>(args)...);
+      return (*_impl)(std::forward<Args>(args)...);
     }
 
     template <typename T>
-		auto operator()(const T& t) -> decltype(_impl->run(t))
+    auto operator()(const T& t) -> decltype((*_impl)(t))
     {
-			return _impl->run(t);
+      return (*_impl)(t);
     }
 
     Connection* operator->()
     {
-			return &_impl;
+      return _impl.get();
     }
 
     pool_connection(const pool_connection&) = delete;
-		pool_connection(pool_connection&& other)
+    pool_connection(pool_connection&& other) : _impl(std::move(other._impl)), origin(other.origin)
-			: _impl(std::move(other._impl)), origin(other.origin) {}
+    {
+    }
     pool_connection& operator=(const pool_connection&) = delete;
     pool_connection& operator=(pool_connection&&) = delete;
   };

include/sqlpp11/result.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013-2015, Roland Bock
+ * Copyright (c) 2013-2017, Roland Bock, Aaron Bishop
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modification,
@@ -38,6 +38,25 @@ namespace sqlpp
     using type = std::input_iterator_tag;
   };
 
+  namespace detail
+  {
+    template<class DbResult, class = void>
+    struct result_has_size : std::false_type {};
+
+    template<class DbResult>
+    struct result_has_size<DbResult, void_t<decltype(std::declval<DbResult>().size())>>
+      : std::true_type {};
+
+    template<class DbResult, class = void>
+    struct result_size_type { using type = void; };
+
+    template<class DbResult>
+    struct result_size_type<DbResult, void_t<decltype(std::declval<DbResult>().size())>>
+    {
+      using type = decltype(std::declval<DbResult>().size());
+    };
+  }
+
   template <typename DbResult, typename ResultRow>
   class result_t
   {
@@ -139,6 +158,13 @@ namespace sqlpp
     {
       _result.next(_result_row);
     }
+
+    template<class Size = typename detail::result_size_type<DbResult>::type>
+    Size size() const
+    {
+      static_assert(detail::result_has_size<DbResult>::value, "Underlying connector does not support size()");
+      return _result.size();
+    }
   };
 }  // namespace sqlpp
 

test_types/result_row.cpp

@@ -73,6 +73,14 @@ namespace
       static_assert(not sqlpp::can_be_null_t<decltype(x.delta)>::value, "right side of (inner) join cannot be null");
       static_assert(not sqlpp::can_be_null_t<decltype(x.s)>::value, "constant non-null value can not be null");
     }
+    {
+      MockSizeDb db2;
+      auto&& result = db2(select(bar.alpha, foo.delta, bar.gamma, seven)
+                             .from(bar.join(foo).on(foo.omega > bar.alpha))
+                             .unconditionally());
+      result.size();
+      static_assert(std::is_same<size_t, decltype(result.size())>::value, "MockSizeDb size() isn't size_t");
+    }
 
     // Inner join
     {

tests/MockDb.h

@@ -288,4 +288,206 @@ struct MockDbT : public sqlpp::connection
 using MockDb = MockDbT<false>;
 using EnforceDb = MockDbT<true>;
 
+
+struct MockSizeDb : public sqlpp::connection
+{
+  using _traits = MockDb::_traits;
+
+  using _serializer_context_t = MockDb::_serializer_context_t;
+
+  using _interpreter_context_t = _serializer_context_t;
+
+  _serializer_context_t get_serializer_context()
+  {
+    return {};
+  }
+
+  template <typename T>
+  static _serializer_context_t& _serialize_interpretable(const T& t, _serializer_context_t& context)
+  {
+    sqlpp::serialize(t, context);
+    return context;
+  }
+
+  template <typename T>
+  static _serializer_context_t& _interpret_interpretable(const T& t, _interpreter_context_t& context)
+  {
+    sqlpp::serialize(t, context);
+    return context;
+  }
+
+  class result_t : public MockDb::result_t
+  {
+  public:
+    size_t size() const { return 0; }
+  };
+
+  // Directly executed statements start here
+  template <typename T>
+  auto _run(const T& t, ::sqlpp::consistent_t) -> decltype(t._run(*this))
+  {
+    return t._run(*this);
+  }
+
+  template <typename Check, typename T>
+  auto _run(const T& t, Check) -> Check;
+
+  template <typename T>
+  auto operator()(const T& t) -> decltype(this->_run(t, sqlpp::run_check_t<_serializer_context_t, T>{}))
+  {
+    return _run(t, sqlpp::run_check_t<_serializer_context_t, T>{});
+  }
+
+  size_t execute(const std::string&)
+  {
+    return 0;
+  }
+
+  template <
+      typename Statement,
+      typename Enable = typename std::enable_if<not std::is_convertible<Statement, std::string>::value, void>::type>
+  size_t execute(const Statement& x)
+  {
+    _serializer_context_t context;
+    ::sqlpp::serialize(x, context);
+    std::cout << "Running execute call with\n" << context.str() << std::endl;
+    return execute(context.str());
+  }
+
+  template <typename Insert>
+  size_t insert(const Insert& x)
+  {
+    _serializer_context_t context;
+    ::sqlpp::serialize(x, context);
+    std::cout << "Running insert call with\n" << context.str() << std::endl;
+    return 0;
+  }
+
+  template <typename Update>
+  size_t update(const Update& x)
+  {
+    _serializer_context_t context;
+    ::sqlpp::serialize(x, context);
+    std::cout << "Running update call with\n" << context.str() << std::endl;
+    return 0;
+  }
+
+  template <typename Remove>
+  size_t remove(const Remove& x)
+  {
+    _serializer_context_t context;
+    ::sqlpp::serialize(x, context);
+    std::cout << "Running remove call with\n" << context.str() << std::endl;
+    return 0;
+  }
+
+  template <typename Select>
+  result_t select(const Select& x)
+  {
+    _serializer_context_t context;
+    ::sqlpp::serialize(x, context);
+    std::cout << "Running select call with\n" << context.str() << std::endl;
+    return {};
+  }
+
+  // Prepared statements start here
+  using _prepared_statement_t = std::nullptr_t;
+
+  template <typename T>
+  auto _prepare(const T& t, ::sqlpp::consistent_t) -> decltype(t._prepare(*this))
+  {
+    return t._prepare(*this);
+  }
+
+  template <typename Check, typename T>
+  auto _prepare(const T& t, Check) -> Check;
+
+  template <typename T>
+  auto prepare(const T& t) -> decltype(this->_prepare(t, sqlpp::prepare_check_t<_serializer_context_t, T>{}))
+  {
+    return _prepare(t, sqlpp::prepare_check_t<_serializer_context_t, T>{});
+  }
+
+  template <typename Statement>
+  _prepared_statement_t prepare_execute(Statement& x)
+  {
+    _serializer_context_t context;
+    ::sqlpp::serialize(x, context);
+    std::cout << "Running prepare execute call with\n" << context.str() << std::endl;
+    return nullptr;
+  }
+
+  template <typename Insert>
+  _prepared_statement_t prepare_insert(Insert& x)
+  {
+    _serializer_context_t context;
+    ::sqlpp::serialize(x, context);
+    std::cout << "Running prepare insert call with\n" << context.str() << std::endl;
+    return nullptr;
+  }
+
+  template <typename PreparedExecute>
+  size_t run_prepared_execute(const PreparedExecute&)
+  {
+    return 0;
+  }
+
+  template <typename PreparedInsert>
+  size_t run_prepared_insert(const PreparedInsert&)
+  {
+    return 0;
+  }
+
+  template <typename Select>
+  _prepared_statement_t prepare_select(Select& x)
+  {
+    _serializer_context_t context;
+    ::sqlpp::serialize(x, context);
+    std::cout << "Running prepare select call with\n" << context.str() << std::endl;
+    return nullptr;
+  }
+
+  template <typename PreparedSelect>
+  result_t run_prepared_select(PreparedSelect&)
+  {
+    return {};
+  }
+
+  auto attach(std::string name) -> ::sqlpp::schema_t
+  {
+    return {name};
+  }
+
+  void start_transaction()
+  {
+      _mock_data._last_isolation_level = _mock_data._default_isolation_level;
+  }
+
+  void start_transaction(sqlpp::isolation_level level)
+  {
+    _mock_data._last_isolation_level = level;
+  }
+
+  void set_default_isolation_level(sqlpp::isolation_level level)
+  {
+      _mock_data._default_isolation_level = level;
+  }
+
+  sqlpp::isolation_level get_default_isolation_level()
+  {
+      return _mock_data._default_isolation_level;
+  }
+
+  void rollback_transaction(bool)
+  {}
+
+  void commit_transaction()
+  {}
+
+  void report_rollback_failure(std::string)
+  {}
+
+  // temporary data store to verify the expected results were produced
+  InternalMockData _mock_data;
+};
 #endif