backend tests progress

include/matador/sql/connection.hpp

@@ -4,6 +4,7 @@
 #include "matador/sql/connection_info.hpp"
 #include "matador/sql/connection_impl.hpp"
 #include "matador/sql/dialect.hpp"
+#include "matador/sql/query_intermediates.hpp"
 #include "matador/sql/query_context.hpp"
 #include "matador/sql/query_result.hpp"
 #include "matador/sql/record.hpp"
@@ -18,12 +19,11 @@ namespace matador::sql {
 class connection
 {
 public:
-  explicit connection(connection_info info);
-  explicit connection(const std::string& dns);
+  explicit connection(connection_info info, const std::shared_ptr<table_repository> &repo = std::make_shared<table_repository>());
+  explicit connection(const std::string& dns, const std::shared_ptr<table_repository> &repo = std::make_shared<table_repository>());
   connection(const connection &x);
   connection& operator=(const connection &x);
   connection(connection &&x) noexcept = default;
-  connection& operator=(connection &&x) noexcept = default;
   ~connection();
 
   void open();
@@ -31,22 +31,41 @@ public:
   [[nodiscard]] bool is_open() const;
   [[nodiscard]] const connection_info& info() const;
 
+  query_create_intermediate create();
+  query_drop_intermediate drop();
+  template < class Type >
+  query_select_intermediate select();
+  query_select_intermediate select(std::initializer_list<column> columns);
+  query_insert_intermediate insert();
+  query_update_intermediate update(const std::string &table);
+  query_delete_intermediate remove();
+
   [[nodiscard]] record describe(const std::string &table_name) const;
   [[nodiscard]] bool exists(const std::string &schema_name, const std::string &table_name) const;
+  [[nodiscard]] bool exists(const std::string &table_name) const;
 
+  query_result<record> fetch(const query_context &q) const;
   [[nodiscard]] std::unique_ptr<query_result_impl> fetch(const std::string &sql) const;
   [[nodiscard]] size_t execute(const std::string &sql) const;
 
   statement prepare(query_context &&query) const;
 
   const class dialect& dialect() const;
+  std::shared_ptr<table_repository> tables() const;
 
 private:
   connection_info connection_info_;
   std::unique_ptr<connection_impl> connection_;
   utils::logger logger_;
   const class dialect &dialect_;
+  std::shared_ptr<table_repository> table_repository_;
 };
 
+template<class Type>
+query_select_intermediate connection::select()
+{
+  return query_select_intermediate{*this, column_generator::generate<Type>(*table_repository_)};
+}
+
 }
 #endif //QUERY_CONNECTION_HPP

include/matador/sql/dialect.hpp

@@ -30,6 +30,8 @@ public:
     COLUMNS,
     COLUMN,
     FROM,
+    JOIN,
+    ON,
     INTO,
     WHERE,
     WHERE_CLAUSE,
@@ -161,6 +163,8 @@ private:
     {token_t::COLUMNS,     "COLUMNS"},
     {token_t::COLUMN,      "COLUMN"},
     {token_t::FROM,        "FROM"},
+    {token_t::JOIN,        "INNER JOIN"},
+    {token_t::ON,          "ON"},
     {token_t::WHERE,       "WHERE"},
     {token_t::AND,         "AND"},
     {token_t::OR,          "OR"},

include/matador/sql/query_intermediates.hpp

@@ -19,15 +19,15 @@
 namespace matador::sql {
 
 class basic_condition;
-class session;
+class connection;
 
 class query_intermediate
 {
 public:
-  query_intermediate(session &db, query_builder &query);
+  query_intermediate(connection &db, query_builder &query);
 
 protected:
-  session &session_;
+  connection &connection_;
   query_builder &builder_;
 };
 
@@ -130,17 +130,17 @@ public:
 class query_start_intermediate
 {
 public:
-  explicit query_start_intermediate(session &s);
+  explicit query_start_intermediate(connection &s);
 
 protected:
-  session &session_;
+  connection &connection_;
   query_builder builder_;
 };
 
 class query_select_intermediate : public query_start_intermediate
 {
 public:
-  query_select_intermediate(session &s, const std::vector<column>& columns);
+  query_select_intermediate(connection &s, const std::vector<column>& columns);
 
   query_from_intermediate from(const std::string &table, const std::string &as = "");
 };
@@ -164,36 +164,38 @@ public:
   query_execute_finish values()
   {
     Type obj;
-    return {session_, builder_.values(as_placeholder(obj))};
+    return {connection_, builder_.values(as_placeholder(obj))};
   }
   template<class Type>
   query_execute_finish values(const Type &obj)
   {
-    return {session_, builder_.values(value_extractor::extract(obj))};
+    return {connection_, builder_.values(value_extractor::extract(obj))};
   }
 };
 
-class query_create_intermediate : query_start_intermediate
+class query_create_intermediate : public query_start_intermediate
 {
 public:
-  query_create_intermediate(session &s, table_repository &repo);
+  explicit query_create_intermediate(connection &db);
 
   query_execute_finish table(const std::string &table, std::initializer_list<column> columns);
   template<class Type>
   query_execute_finish table(const std::string &table_name)
   {
-    const auto &info = repository_.attach<Type>(table_name);
-    return {session_, builder_.table(table_name, info.prototype.columns())};
+    if (!tables()->exists<Type>()) {
+      tables()->attach<Type>(table_name);
+    }
+    return {connection_, builder_.table(table_name, column_generator::generate<Type>(*tables()))};
   }
 
 private:
-  table_repository &repository_;
+  std::shared_ptr<table_repository> tables() const;
 };
 
 class query_drop_intermediate : query_start_intermediate
 {
 public:
-  explicit query_drop_intermediate(session &s);
+  explicit query_drop_intermediate(connection &s);
 
   query_execute_finish table(const std::string &table);
 };
@@ -201,18 +203,18 @@ public:
 class query_insert_intermediate : public query_start_intermediate
 {
 public:
-  explicit query_insert_intermediate(session &s);
+  explicit query_insert_intermediate(connection &s);
 
   query_into_intermediate into(const std::string &table, std::initializer_list<std::string> column_names);
   template<class Type>
   query_into_intermediate into(const std::string &table)
   {
-    return {session_, builder_.into(table, column_name_generator::generate<Type>())};
+    return {connection_, builder_.into(table, column_name_generator::generate<Type>())};
   }
   template<class Type>
   query_execute_finish into(const std::string &table, const Type &obj)
   {
-    return {session_, builder_.into(table, column_name_generator::generate<Type>())
+    return {connection_, builder_.into(table, column_name_generator::generate<Type>())
                          .values(value_extractor::extract(obj))};
   }
 };
@@ -236,13 +238,13 @@ public:
 class query_update_intermediate : public query_start_intermediate
 {
 public:
-  query_update_intermediate(session &s, const std::string& table_name);
+  query_update_intermediate(connection &s, const std::string& table_name);
 
   query_set_intermediate set(std::initializer_list<key_value_pair> columns);
   template<class Type>
   query_set_intermediate set(const Type &obj)
   {
-    return {session_, builder_.set(key_value_generator::generate(obj))};
+    return {connection_, builder_.set(key_value_generator::generate(obj))};
   }
 };
 
@@ -257,7 +259,7 @@ public:
 class query_delete_intermediate : public query_start_intermediate
 {
 public:
-  explicit query_delete_intermediate(session &s);
+  explicit query_delete_intermediate(connection &s);
 
   query_delete_from_intermediate from(const std::string &table);
 };

include/matador/sql/record.hpp

@@ -68,6 +68,8 @@ public:
   [[nodiscard]] bool empty() const;
   void clear();
 
+  [[nodiscard]] bool unknown() const;
+
 private:
   void init();
   void add_to_map(column &col, size_t index);

include/matador/sql/session.hpp

@@ -20,15 +20,6 @@ class session
 public:
   explicit session(connection_pool<connection> &pool);
 
-  query_create_intermediate create();
-  query_drop_intermediate drop();
-  template < class Type >
-  query_select_intermediate select();
-  query_select_intermediate select(std::initializer_list<column> columns);
-  query_insert_intermediate insert();
-  query_update_intermediate update(const std::string &table);
-  query_delete_intermediate remove();
-
   [[nodiscard]] query_result<record> fetch(const query_context &q) const;
 //  [[nodiscard]] query_result<record> fetch(const std::string &sql) const;
   [[nodiscard]] size_t execute(const std::string &sql) const;
@@ -60,11 +51,5 @@ private:
   mutable std::unordered_map<std::string, record> prototypes_;
 };
 
-template<class Type>
-query_select_intermediate session::select()
-{
-  return query_select_intermediate{*this, column_generator::generate<Type>(table_repository_)};
-}
-
 }
 #endif //QUERY_SESSION_HPP

include/matador/sql/table_repository.hpp

@@ -44,11 +44,18 @@ public:
 
   [[nodiscard]] std::pair<std::string, std::string> reference(const std::type_index &ti) const;
 
+  template<typename Type>
+  [[nodiscard]] bool exists() const
+  {
+    return exists(std::type_index(typeid(Type)));
+  }
+
+  [[nodiscard]] bool exists(const std::type_index &ti) const;
+
 private:
   using repository = std::unordered_map<std::type_index, table_info>;
   repository repository_;
 };
-;
 
 }