added sqlite connection class (progress)

include/matador/sql/connection.hpp

@@ -1,7 +1,7 @@
 #ifndef QUERY_CONNECTION_HPP
 #define QUERY_CONNECTION_HPP
 
-#include "matador/sql/connection_intermediates.hpp"
+#include "matador/sql/query_intermediates.hpp"
 #include "matador/sql/dialect.hpp"
 #include "matador/sql/query_builder.hpp"
 
@@ -12,20 +12,21 @@ namespace matador::sql {
 class connection
 {
 public:
-  connection();
-  query_create_intermediate create();
-  query_drop_intermediate drop();
-  query_select_intermediate select(std::initializer_list<std::string> column_names);
-  query_insert_intermediate insert();
-  query_update_intermediate update(const std::string &table);
-  query_delete_intermediate remove();
+  connection() = default;
+  explicit connection(std::string dns);
+
+  void open();
+  void close();
+  [[nodiscard]] bool is_open() const;
+
+  [[nodiscard]] const std::string& dns() const;
 
   query_result<record> fetch(const std::string &sql);
   std::pair<size_t, std::string> execute(const std::string &sql);
 
 private:
-  dialect dialect_;
-  query_builder query_;
+  std::string dns_;
+  bool is_open_{false};
 };
 
 }

include/matador/sql/connection_pool.hpp

@@ -0,0 +1,107 @@
+#ifndef QUERY_CONNECTION_POOL_HPP
+#define QUERY_CONNECTION_POOL_HPP
+
+#include <utility>
+#include <queue>
+#include <mutex>
+#include <string>
+#include <unordered_set>
+
+namespace matador::sql {
+
+template < class Connection >
+class connection_pool;
+
+template < class Connection >
+class connection_ptr
+{
+public:
+  connection_ptr(Connection *c, connection_pool<Connection> &pool)
+  : connection_(c), pool_(pool) {}
+  ~connection_ptr();
+  connection_ptr(const connection_ptr &) = delete;
+  connection_ptr& operator=(const connection_ptr &) = delete;
+  connection_ptr(connection_ptr &&) noexcept = default;
+  connection_ptr& operator=(connection_ptr &&) noexcept = default;
+
+  Connection* operator->() { return connection_; }
+  Connection& operator*() { return *connection_; }
+
+  [[nodiscard]] bool valid() const { return connection_ != nullptr; }
+
+private:
+  friend class connection_pool<Connection>;
+
+  Connection *connection_;
+  connection_pool<Connection> &pool_;
+};
+
+template < class Connection >
+class connection_pool
+{
+public:
+  connection_pool(const std::string &db, unsigned int count) {
+    connection_repo_.reserve(count);
+    for (auto i = 0U; i < count; ++i) {
+      connection_repo_.emplace_back(db + std::to_string(i+1));
+      idle_connections_.push(&connection_repo_.back());
+      idle_connections_.back()->open();
+    }
+  }
+
+  connection_ptr<Connection> acquire() {
+    std::lock_guard<std::mutex> guard(mutex_);
+    if (idle_connections_.empty()) {
+      return {nullptr, *this};
+    }
+
+    auto ptr = idle_connections_.front();
+    idle_connections_.pop();
+    inuse_connections_.insert(ptr);
+    return { ptr, *this };
+  }
+
+  void release(Connection *c) {
+    if (c == nullptr) {
+      return;
+    }
+    std::lock_guard<std::mutex> guard(mutex_);
+
+    if (inuse_connections_.erase(c) > 0) {
+      idle_connections_.push(c);
+    }
+  }
+
+  void release(connection_ptr<Connection> &c) {
+    release(c.connection_);
+    c.connection_ = nullptr;
+  }
+  
+  std::size_t size() const { return connection_repo_.size(); }
+  std::size_t idle() const {
+    std::lock_guard<std::mutex> guard(mutex_);
+    return idle_connections_.size();
+  }
+  std::size_t inuse() const {
+    std::lock_guard<std::mutex> guard(mutex_);
+    return inuse_connections_.size();
+  }
+
+private:
+  mutable std::mutex mutex_;
+  std::vector<Connection> connection_repo_;
+  using pointer = Connection*;
+  using connections = std::queue<pointer>;
+  using connection_set = std::unordered_set<pointer>;
+  connections idle_connections_;
+  connection_set inuse_connections_;
+};
+
+template<class Connection>
+connection_ptr<Connection>::~connection_ptr() {
+  pool_.release(connection_);
+}
+
+}
+
+#endif //QUERY_CONNECTION_POOL_HPP

include/matador/sql/query_intermediates.hpp

@@ -1,5 +1,5 @@
-#ifndef QUERY_CONNECTION_INTERMEDIATES_HPP
-#define QUERY_CONNECTION_INTERMEDIATES_HPP
+#ifndef QUERY_QUERY_INTERMEDIATES_HPP
+#define QUERY_QUERY_INTERMEDIATES_HPP
 
 #include "matador/sql/column.hpp"
 #include "matador/sql/key_value_pair.hpp"
@@ -11,20 +11,20 @@
 namespace matador::sql {
 
 class basic_condition;
-class connection;
+class session;
 class query_builder;
 
 class query_intermediate
 {
 public:
-  query_intermediate(connection &db, query_builder &query);
+  query_intermediate(session &db, query_builder &query);
 
 protected:
-  connection& db();
+  session& db();
   query_builder& query();
 
 private:
-  connection &db_;
+  session &db_;
   query_builder &query_;
 };
 
@@ -195,4 +195,4 @@ public:
 };
 
 }
-#endif //QUERY_CONNECTION_INTERMEDIATES_HPP
+#endif //QUERY_QUERY_INTERMEDIATES_HPP

include/matador/sql/session.hpp

@@ -0,0 +1,31 @@
+#ifndef QUERY_SESSION_HPP
+#define QUERY_SESSION_HPP
+
+#include "matador/sql/connection.hpp"
+#include "matador/sql/connection_pool.hpp"
+
+namespace matador::sql {
+
+class session
+{
+public:
+  explicit session(connection_pool<connection> &pool);
+
+  query_create_intermediate create();
+  query_drop_intermediate drop();
+  query_select_intermediate select(std::initializer_list<std::string> column_names);
+  query_insert_intermediate insert();
+  query_update_intermediate update(const std::string &table);
+  query_delete_intermediate remove();
+
+  query_result<record> fetch(const std::string &sql);
+  std::pair<size_t, std::string> execute(const std::string &sql);
+
+private:
+  connection_pool<connection> &pool_;
+  dialect dialect_;
+  query_builder query_;
+};
+
+}
+#endif //QUERY_SESSION_HPP