added session class

source/core/object/basic_object_info.cpp

@@ -1,5 +1,7 @@
 #include "matador/object/basic_object_info.hpp"
 
+#include "matador/object/schema_node.hpp"
+
 #include <algorithm>
 
 namespace matador::object {
@@ -8,6 +10,11 @@ basic_object_info::basic_object_info(schema_node &node, const std::type_index ty
 : node_(node)
 , type_index_(type_index) {}
 
-std::type_index basic_object_info::type_index() const { return type_index_; }
+std::type_index basic_object_info::type_index() const {
+    return type_index_;
+}
 
+std::string basic_object_info::name() const {
+    return node_.name();
+}
 } // namespace matador::object

source/orm/CMakeLists.txt

@@ -40,6 +40,7 @@ add_library(matador-orm STATIC
   ../../include/matador/query/query_intermediates.hpp
   ../../include/matador/query/query_part.hpp
   ../../include/matador/query/value_extractor.hpp
+  ../../include/matador/orm/session.hpp
   ../../include/matador/sql/abstract_sql_logger.hpp
   ../../include/matador/sql/backend_provider.hpp
   ../../include/matador/sql/column.hpp
@@ -102,6 +103,7 @@ add_library(matador-orm STATIC
   query/query_part.cpp
   query/query_update_intermediate.cpp
   query/value_extractor.cpp
+  orm/session.cpp
   sql/backend_provider.cpp
   sql/column.cpp
   sql/column_definition.cpp

source/orm/orm/session.cpp

@@ -0,0 +1,117 @@
+#include "matador/orm/session.hpp"
+
+#include "matador/sql/backend_provider.hpp"
+
+#include <stdexcept>
+
+namespace matador::orm {
+
+session::session(sql::connection_pool<sql::connection> &pool)
+: pool_(pool)
+, dialect_(sql::backend_provider::instance().connection_dialect(pool_.info().type))
+, schema_(std::make_unique<object::schema>(dialect_.default_schema_name())){}
+
+void session::create_schema()
+{
+  auto c = pool_.acquire();
+  for (const auto &t : *schema_) {
+    c->query(*schema_).create().table(t.second.name, t.second.prototype.columns()).execute();
+  }
+}
+
+void session::drop_table(const std::string &table_name)
+{
+  auto c = pool_.acquire();
+  if (!c.valid()) {
+    throw std::logic_error("no database connection available");
+  }
+
+  c->query(*schema_).drop().table(table_name).execute();
+}
+
+sql::query_result<sql::record> session::fetch(const query_context &q) const
+{
+  auto c = pool_.acquire();
+  if (!c.valid()) {
+    throw std::logic_error("no database connection available");
+  }
+  auto it = prototypes_.find(q.table.name);
+  if (it == prototypes_.end()) {
+    it = prototypes_.emplace(q.table.name, c->describe(q.table.name)).first;
+  }
+  // adjust columns from given query
+  for (auto &col : q.prototype) {
+    if (const auto rit = it->second.find(col.name()); col.type() == utils::basic_type::type_unknown && rit != it->second.end()) {
+      const_cast<sql::column_definition&>(col).type(rit->type());
+    }
+  }
+  auto res = c->fetch(q.sql);
+  return sql::query_result<sql::record>{std::move(res), q.prototype};
+}
+
+//query_result<record> session::fetch(const std::string &sql) const
+//{
+//  return query_result<record>(std::unique_ptr());
+//}
+
+size_t session::execute(const std::string &sql) const {
+  auto c = pool_.acquire();
+  if (!c.valid()) {
+    throw std::logic_error("no database connection available");
+  }
+  return c->execute(sql);
+}
+
+sql::statement session::prepare(query_context q) const
+{
+  auto c = pool_.acquire();
+  if (!c.valid()) {
+    throw std::logic_error("no database connection available");
+  }
+  return c->prepare(std::move(q));
+}
+
+std::vector<sql::column_definition> session::describe_table(const std::string &table_name) const
+{
+  auto c = pool_.acquire();
+  if (!c.valid()) {
+    throw std::logic_error("no database connection available");
+  }
+  return c->describe(table_name);
+}
+
+bool session::table_exists(const std::string &table_name) const
+{
+  auto c = pool_.acquire();
+  if (!c.valid()) {
+    throw std::logic_error("no database connection available");
+  }
+  return c->exists(dialect_.default_schema_name(), table_name);
+}
+
+const class dialect &session::dialect() const
+{
+  return dialect_;
+}
+
+std::unique_ptr<sql::query_result_impl> session::fetch(const std::string &sql) const
+{
+  auto c = pool_.acquire();
+  if (!c.valid()) {
+    throw std::logic_error("no database connection available");
+  }
+  return c->fetch(sql);
+}
+
+query_select session::build_select_query(sql::connection_ptr<sql::connection> &conn, entity_query_data &&data) const
+{
+  return conn->query(*schema_)
+    .select(data.columns)
+    .from(data.root_table_name)
+    .join_left(data.joins)
+    .where(std::move(data.where_clause))
+    .order_by({data.root_table_name, data.pk_column_})
+    .asc();
+}
+
+}