orm schema class progress added SchemaTest.cpp

include/matador/orm/schema.hpp

@@ -9,9 +9,24 @@ class connection_pool;
 
 namespace matador::orm {
 
-class schema {
+class schema;
+
+using schema_ref = std::reference_wrapper<schema>;
+
+class schema_repository final {
 public:
-  explicit schema(const std::string &name);
+    utils::result<void, utils::error> add(const std::string &name, const schema &schema);
+    utils::result<void, utils::error> remove(const std::string &name);
+
+    [[nodiscard]] utils::result<schema_ref, utils::error> get(const std::string &name);
+
+private:
+    std::unordered_map<std::string, schema> schema_map_;
+};
+
+class schema final {
+public:
+  schema(sql::connection_pool &pool, const std::string &name);
 
   template<typename Type>
   [[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, const std::string &parent = "") {
@@ -23,12 +38,30 @@ public:
     return repo_.attach<Type, SuperType>(name);
   }
 
-  utils::result<void, utils::error> create(sql::connection_pool &pool) const;
+  utils::result<void, utils::error> create() const;
   utils::result<void, utils::error> drop() const;
 
+  template<typename Type>
+  utils::result<void, utils::error> drop_table();
+  utils::result<void, utils::error> drop_table(const std::string &table_name) const;
+
+  [[nodiscard]] utils::result<std::vector<object::attribute_definition>, utils::error> describe_table(const std::string &table_name) const;
+  [[nodiscard]] utils::result<bool, utils::error> table_exists(const std::string &table_name) const;
+
 private:
   object::repository repo_;
+  sql::connection_pool &pool_;
 };
 
+template<typename Type>
+utils::result<void, utils::error> schema::drop_table() {
+  auto info = repo_.info<Type>();
+  if (info) {
+    return drop_table(info->get().name());
+  }
+
+  return utils::failure(info.err());
+}
+
 }
 #endif //MATADOR_SCHEMA_HPP

include/matador/orm/session_insert_builder.hpp

@@ -1,131 +0,0 @@
-#ifndef SESSION_INSERT_BUILDER_HPP
-#define SESSION_INSERT_BUILDER_HPP
-
-#include "matador/orm/query_builder_exception.hpp"
-
-#include "matador/query/criteria.hpp"
-#include "matador/query/query_intermediates.hpp"
-
-#include "matador/object/repository.hpp"
-
-#include "matador/utils/cascade_type.hpp"
-#include "matador/utils/primary_key_attribute.hpp"
-
-namespace matador::orm {
-struct entity_insert_data {
-  sql::table table;
-  std::vector<std::string> columns{};
-  std::vector<utils::database_type> values{};
-};
-
-enum class insert_build_error : std::uint8_t {
-  Ok = 0,
-  UnknownType,
-  MissingPrimaryKey,
-  UnexpectedError
-};
-
-class insert_builder_exception final : public std::exception {
-public:
-  explicit insert_builder_exception(const insert_build_error error) : error_(error) {
-  }
-
-  [[nodiscard]] insert_build_error error() const { return error_; }
-
-private:
-  const insert_build_error error_;
-};
-
-class session_insert_builder final {
-public:
-  explicit session_insert_builder(const object::repository &scm)
-    : schema_(scm) {
-  }
-
-  template<class EntityType>
-  utils::result<std::vector<entity_insert_data>, insert_build_error> build(const EntityType &obj) {
-    auto info = schema_.info<EntityType>();
-    if (!info) {
-      return utils::failure(insert_build_error::UnknownType);
-    }
-    table_info_stack_.push({info.value()});
-    entity_insert_data_ = {{sql::table{info.value().get().name()}}};
-    // processed_tables_.insert({info->get().name(), entity_insert_data_.root_table});
-    try {
-      access::process(*this, obj);
-
-      return {utils::ok(std::move(entity_insert_data_))};
-    } catch (const insert_builder_exception &ex) {
-      return {utils::failure(ex.error())};
-    } catch (...) {
-      return {utils::failure(insert_build_error::UnexpectedError)};
-    }
-  }
-
-  template<class V>
-  void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
-    push(id, x);
-  }
-
-  void on_revision(const char *id, uint64_t &/*rev*/);
-
-  template<typename Type>
-  void on_attribute(const char *id, Type &x, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
-    push(id, x);
-  }
-
-  template<class Pointer>
-  void on_belongs_to(const char *id, Pointer &obj, const utils::foreign_attributes &attr) {
-    if (!utils::is_cascade_type_set(attr.cascade(), utils::cascade_type::INSERT)) {
-      return;
-    }
-
-  const auto info = schema_.info<typename Pointer::value_type::value_type>();
-    if (!info) {
-      throw query_builder_exception{query_build_error::UnknownType};
-    }
-  }
-
-  template<class Pointer>
-  void on_has_one(const char *id, Pointer &obj, const utils::foreign_attributes &attr) {
-    if (!utils::is_cascade_type_set(attr.cascade(), utils::cascade_type::INSERT)) {
-      return;
-    }
-
-    const auto info = schema_.info<typename Pointer::value_type::value_type>();
-    if (!info) {
-      throw query_builder_exception{query_build_error::UnknownType};
-    }
-
-  }
-
-  template<class ContainerType>
-  void on_has_many(const char * /*id*/, ContainerType &, const char *join_column,
-                   const utils::foreign_attributes &attr) {
-  }
-
-  template<class ContainerType>
-  void on_has_many_to_many(const char *id, ContainerType &/*cont*/, const char *join_column,
-                           const char *inverse_join_column, const utils::foreign_attributes &attr) {
-  }
-
-  template<class ContainerType>
-  void on_has_many_to_many(const char *id, ContainerType &/*cont*/, const utils::foreign_attributes &attr) {
-  }
-
-private:
-  void push(const std::string &column_name, const utils::database_type &value);
-
-private:
-  struct table_info {
-    std::reference_wrapper<const object::basic_object_info> info;
-  };
-
-  std::stack<table_info> table_info_stack_;
-  std::unordered_map<std::string, std::shared_ptr<sql::table> > processed_tables_;
-  const object::repository &schema_;
-  std::vector<entity_insert_data> entity_insert_data_;
-};
-}
-
-#endif //SESSION_INSERT_BUILDER_HPP