added join_column_index and inverse_join_column_index to object and table classes

source/core/object/attribute.cpp

@@ -32,6 +32,10 @@ std::string attribute::full_name() const {
   return owner ? owner->name() + "." + name_ : name_;
 }
 
+size_t attribute::index() const {
+  return index_;
+}
+
 const utils::field_attributes &attribute::attributes() const {
   return options_;
 }

source/core/object/basic_object_info.cpp

@@ -21,11 +21,11 @@ std::shared_ptr<class object> basic_object_info::object() const {
   return object_;
 }
 
-const std::list<attribute>& basic_object_info::attributes() const {
+const std::vector<attribute>& basic_object_info::attributes() const {
   return object_->attributes();
 }
 
-const std::list<class restriction>& basic_object_info::constraints() const {
+const std::vector<class restriction>& basic_object_info::constraints() const {
   return object_->constraints();
 }
 
@@ -37,7 +37,7 @@ const utils::identifier& basic_object_info::primary_key() const {
   return object_->primary_key();
 }
 
-attribute* basic_object_info::primary_key_attribute() const {
+const attribute* basic_object_info::primary_key_attribute() const {
   return object_->primary_key_attribute();
 }
 

source/core/object/basic_repository.cpp

@@ -88,7 +88,7 @@ utils::result<basic_object_info_ref, utils::error> basic_repository::basic_info(
     return utils::ok(basic_object_info_ref{it->info()});
 }
 
-utils::result<attribute*, utils::error> basic_repository::primary_key_attribute(const std::type_index &ti) const {
+utils::result<const attribute*, utils::error> basic_repository::primary_key_attribute(const std::type_index &ti) const {
   const auto it = find_node(ti);
   if (it == end()) {
     return utils::failure(make_error(error_code::NodeNotFound, "Node '" + std::string(ti.name()) + "' not found."));

source/core/object/object.cpp

@@ -10,8 +10,8 @@ const attribute& object::create_attribute(std::string name, const std::shared_pt
   return obj->attributes_.emplace_back(std::move(attr));
 }
 
-attribute* object::primary_key_attribute() const {
-  return pk_attribute_;
+const attribute* object::primary_key_attribute() const {
+  return pk_column_index_ != -1 ? &attributes_.at(pk_column_index_) : nullptr;
 }
 
 const utils::identifier& object::primary_key() const {
@@ -19,7 +19,19 @@ const utils::identifier& object::primary_key() const {
 }
 
 bool object::has_primary_key() const {
-  return pk_attribute_ != nullptr;
+  return pk_column_index_ != -1;
+}
+
+bool object::is_relation_object() const {
+  return join_column_index_ != -1 && inverse_join_column_index_ != -1;
+}
+
+const attribute * object::join_attribute() const {
+  return join_column_index_ != -1 ? &attributes_.at(join_column_index_) : nullptr;
+}
+
+const attribute * object::inverse_join_attribute() const {
+  return inverse_join_column_index_ != -1 ? &attributes_.at(inverse_join_column_index_) : nullptr;
 }
 
 const std::string& object::name() const {
@@ -38,7 +50,7 @@ size_t object::attribute_count() const {
   return attributes_.size();
 }
 
-const std::list<attribute>& object::attributes() const {
+const std::vector<attribute>& object::attributes() const {
   return attributes_;
 }
 
@@ -50,7 +62,7 @@ size_t object::constraint_count() const {
   return constraints_.size();
 }
 
-const std::list<restriction>& object::constraints() const {
+const std::vector<restriction>& object::constraints() const {
   return constraints_;
 }
 

source/core/object/object_generator.cpp

@@ -5,54 +5,69 @@
 #include <algorithm>
 
 namespace matador::object {
-object_generator::object_generator(basic_repository& repo, const std::shared_ptr<object>& object)
+object_generator::object_generator(basic_repository &repo, const std::shared_ptr<object> &object)
 : repo_(repo)
-, object_(object) {}
-
-std::shared_ptr<object> object_generator::acquire_object(basic_repository &repo, const std::type_index &ti, const std::string& name) {
-    if (repo.has_object_for_type(ti)) {
-        auto obj = repo.object_for_type(ti);
-        repo.remove_object_for_type(ti);
-        obj->update_name(name);
-        return obj;
-    }
-
-    return repo.provide_object_in_advance(ti, std::make_shared<object>(name));
+, object_(object) {
 }
 
-void object_generator::on_revision(const char* id, uint64_t& rev) {
-    access::attribute(*this, id, rev);
+std::shared_ptr<object> object_generator::acquire_object(basic_repository &repo, const std::type_index &ti, const std::string &name) {
+  if (repo.has_object_for_type(ti)) {
+    auto obj = repo.object_for_type(ti);
+    repo.remove_object_for_type(ti);
+    obj->update_name(name);
+    return obj;
+  }
+
+  return repo.provide_object_in_advance(ti, std::make_shared<object>(name));
 }
 
-void object_generator::create_pk_constraint(const std::string& name) const {
-    const auto pk_attr = find_attribute_by_name(name);
-    if (pk_attr == std::end(object_->attributes_)) {
-      return;
-    }
-    restriction pk_constraint(*pk_attr);
-    pk_constraint.options_ |= utils::constraints::PrimaryKey;
-    pk_constraint.owner_ = object_;
-    object_->constraints_.emplace_back(std::move(pk_constraint));
+void object_generator::on_revision(const char *id, uint64_t &rev) {
+  access::attribute(*this, id, rev);
 }
 
-void object_generator::create_unique_constraint(const std::string& name) const {
-    const auto pk_attr = find_attribute_by_name(name);
-    if (pk_attr == std::end(object_->attributes_)) {
-        return;
-    }
-    restriction pk_constraint(*pk_attr);
-    pk_constraint.options_ |= utils::constraints::Unique;
-    pk_constraint.owner_ = object_;
+void object_generator::create_pk_constraint(const std::string &name) const {
+  const auto pk_attr = find_attribute_by_name(name);
+  if (pk_attr == std::end(object_->attributes_)) {
+    return;
+  }
+  restriction pk_constraint(*pk_attr);
+  pk_constraint.options_ |= utils::constraints::PrimaryKey;
+  pk_constraint.owner_ = object_;
+  object_->constraints_.emplace_back(std::move(pk_constraint));
 }
 
-std::list<attribute>::iterator object_generator::find_attribute_by_name(const std::string& name) const {
-    return std::find_if(std::begin(object_->attributes_), std::end(object_->attributes_), [&name](const attribute& elem) {
-      return elem.name() == name;
-    });
+void object_generator::create_unique_constraint(const std::string &name) const {
+  const auto pk_attr = find_attribute_by_name(name);
+  if (pk_attr == std::end(object_->attributes_)) {
+    return;
+  }
+  restriction pk_constraint(*pk_attr);
+  pk_constraint.options_ |= utils::constraints::Unique;
+  pk_constraint.owner_ = object_;
 }
 
-void object_generator::prepare_primary_key(attribute& ref, utils::identifier &&pk) const {
-    object_->pk_attribute_ = &ref;
-    object_->pk_identifier_ = std::move(pk);
+std::vector<attribute>::iterator object_generator::find_attribute_by_name(const std::string &name) const {
+  return std::find_if(std::begin(object_->attributes_), std::end(object_->attributes_), [&name](const attribute &elem) {
+    return elem.name() == name;
+  });
+}
+
+void object_generator::prepare_primary_key(const attribute &ref, utils::identifier &&pk) const {
+  object_->pk_column_index_ = static_cast<int>(ref.index_);
+  object_->pk_identifier_ = std::move(pk);
+}
+
+void object_generator::prepare_relation_table(const std::string &join_column, const std::string &inverse_join_column) const {
+  auto it = find_attribute_by_name(join_column);
+  if (it == std::end(object_->attributes_)) {
+    return;
+  }
+  object_->join_column_index_ = static_cast<int>(it->index_);
+
+  it = find_attribute_by_name(inverse_join_column);
+  if (it == std::end(object_->attributes_)) {
+    return;
+  }
+  object_->inverse_join_column_index_ = static_cast<int>(it->index_);
 }
 }

source/orm/query/intermediates/query_create_intermediate.cpp

@@ -58,10 +58,10 @@ executable_query query_create_table_columns_intermediate::constraints(const std:
 }
 
 query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::initializer_list<object::attribute> attributes) {
-  return columns(std::list(attributes));
+  return columns(std::vector(attributes));
 }
 
-query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list<object::attribute>& attributes) {
+query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::vector<object::attribute>& attributes) {
   std::list<table_column> columns;
   for (const auto& attr : attributes) {
     auto options = attr.attributes().options();

source/orm/query/schema.cpp

@@ -59,4 +59,7 @@ schema::iterator schema::insert_table(const std::type_index &ti, const object::r
   }
   return schema_nodes_.insert({ti, schema_node{table(node.name(), columns), std::move(pk_generator), node}}).first;
 }
+
+basic_schema::iterator schema::insert_relation_table(const std::type_index &ti, const object::repository_node &node) {
+}
 } // namespace matador::query