added more tests

include/matador/object/attribute_definition.hpp

@@ -0,0 +1,174 @@
+#ifndef QUERY_COLUMN_DEFINITION_HPP
+#define QUERY_COLUMN_DEFINITION_HPP
+
+#include "matador/utils/basic_type_converter.hpp"
+#include "matador/utils/basic_types.hpp"
+#include "matador/utils/default_type_traits.hpp"
+#include "matador/utils/field_attributes.hpp"
+#include "matador/utils/value.hpp"
+
+#include <vector>
+
+namespace matador::object {
+
+enum class null_option : uint8_t {
+  NULLABLE, NOT_NULL
+};
+
+class attribute_definition {
+public:
+  explicit attribute_definition(const char *name); // NOLINT(*-explicit-constructor)
+  explicit attribute_definition(std::string name); // NOLINT(*-explicit-constructor)
+
+  attribute_definition(const attribute_definition&) = default;
+  attribute_definition& operator=(const attribute_definition&) = default;
+  attribute_definition(attribute_definition&&) noexcept = default;
+  attribute_definition& operator=(attribute_definition&&) noexcept = default;
+
+  template<typename Type>
+  explicit attribute_definition(std::string name, const utils::field_attributes& attr)
+  : attribute_definition(std::move(name), utils::data_type_traits<Type>::type(attr.size()), attr)
+  {}
+
+  template<typename Type>
+  attribute_definition(std::string name, const Type &, const utils::field_attributes& attr, null_option null_opt)
+  : attribute_definition(std::move(name), utils::data_type_traits<Type>::type(attr.size()), attr, null_opt)
+  {}
+
+  template<size_t SIZE>
+  attribute_definition(std::string name, const char (&)[SIZE], const utils::field_attributes& attr, const null_option null_opt)
+  : attribute_definition(std::move(name), utils::data_type_traits<const char*>::type(attr.size()), attr, null_opt)
+  {}
+
+  attribute_definition(std::string name, utils::basic_type type, const utils::field_attributes&, null_option null_opt, size_t index = 0);
+
+  template<typename Type>
+  attribute_definition(std::string name, std::string ref_table, std::string ref_column, const utils::field_attributes& attr, null_option null_opt)
+  : attribute_definition(std::move(name), utils::data_type_traits<Type>::type(attr.size()), ref_table, ref_column, attr, null_opt)
+  {}
+
+  attribute_definition(std::string name, utils::basic_type type, size_t index, std::string ref_table, std::string ref_column, const utils::field_attributes& attr, null_option null_opt);
+
+  [[nodiscard]] const std::string& name() const;
+  [[nodiscard]] std::string full_name() const;
+  [[nodiscard]] std::string table_name() const;
+  [[nodiscard]] int index() const;
+  [[nodiscard]] const utils::field_attributes& attributes() const;
+  [[nodiscard]] bool is_nullable() const;
+  [[nodiscard]] utils::basic_type type() const;
+  [[nodiscard]] const std::string& ref_table() const;
+  [[nodiscard]] const std::string& ref_column() const;
+  [[nodiscard]] bool is_foreign_reference() const;
+
+  [[nodiscard]] bool is_integer() const;
+  [[nodiscard]] bool is_floating_point() const;
+  [[nodiscard]] bool is_bool() const;
+  [[nodiscard]] bool is_string() const;
+  [[nodiscard]] bool is_varchar() const;
+  [[nodiscard]] bool is_date() const;
+  [[nodiscard]] bool is_time() const;
+  [[nodiscard]] bool is_blob() const;
+  [[nodiscard]] bool is_null() const;
+
+  void type(utils::basic_type type);
+
+  template< typename Type >
+  [[nodiscard]] bool is_type_of() const {
+    return std::holds_alternative<Type>(value_);
+  }
+
+  [[nodiscard]] std::string str() const;
+
+  template<typename Type>
+  void set(const Type &value, const utils::field_attributes &attr = utils::null_attributes)
+  {
+    attributes_ = attr;
+    value_ = value;
+  }
+
+  void set(const std::string &value, const utils::field_attributes &attr)
+  {
+    value_ = value;
+    attributes_ = attr;
+  }
+
+  void set(const char *value, const utils::field_attributes &attr)
+  {
+    value_ = std::string(value);
+    attributes_ = attr;
+  }
+
+  template<class Type>
+  std::optional<Type> as() const
+  {
+    return value_.as<Type>();
+  }
+
+  friend std::ostream& operator<<(std::ostream &out, const attribute_definition &col);
+
+private:
+  template<class Operator>
+  void process(Operator &op)
+  {
+    op.on_attribute(name_.c_str(), value_, attributes_);
+  }
+
+  using data_type_index = std::vector<utils::basic_type>;
+
+private:
+  static const data_type_index data_type_index_;
+
+  std::string name_;
+  std::string table_;
+  int index_{-1};
+  utils::field_attributes attributes_;
+  null_option null_option_{null_option::NOT_NULL};
+  utils::value value_;
+  std::string ref_table_;
+  std::string ref_column_;
+};
+
+/**
+ * User defined literal to have a shortcut creating a column object
+ * @param name Name of the column
+ * @param type
+ * @param attr Length of the column name
+ * @param null_opt
+ * @return A column object with given name
+ */
+attribute_definition make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr = utils::null_attributes, null_option null_opt = null_option::NOT_NULL);
+
+template < typename Type >
+attribute_definition make_column(const std::string &name, utils::field_attributes attr = utils::null_attributes, null_option null_opt = null_option::NOT_NULL)
+{
+    return make_column(name, utils::data_type_traits<Type>::type(0), attr, null_opt);
+}
+template <>
+attribute_definition make_column<std::string>(const std::string &name, utils::field_attributes attr, null_option null_opt);
+
+template < typename Type >
+attribute_definition make_pk_column(const std::string &name, size_t size = 0)
+{
+    return make_column<Type>(name, { size, utils::constraints::PRIMARY_KEY });
+}
+
+template <>
+attribute_definition make_pk_column<std::string>(const std::string &name, size_t size);
+
+template < typename Type >
+attribute_definition make_fk_column(const std::string &name, size_t size, const std::string &ref_table, const std::string &ref_column)
+{
+    return {name, utils::data_type_traits<Type>::type(size), ref_table, ref_column, { size, utils::constraints::FOREIGN_KEY }};
+}
+
+template < typename Type >
+[[maybe_unused]] attribute_definition make_fk_column(const std::string &name, const std::string &ref_table, const std::string &ref_column)
+{
+    return {name, utils::data_type_traits<Type>::type(0), 0, ref_table, ref_column, { 0, utils::constraints::FOREIGN_KEY }, null_option::NOT_NULL};
+}
+
+template <>
+attribute_definition make_fk_column<std::string>(const std::string &name, size_t size, const std::string &ref_table, const std::string &ref_column);
+
+}
+#endif //QUERY_COLUMN_DEFINITION_HPP

include/matador/object/attribute_definition_generator.hpp

@@ -0,0 +1,132 @@
+#ifndef QUERY_COLUMN_DEFINITION_GENERATOR_HPP
+#define QUERY_COLUMN_DEFINITION_GENERATOR_HPP
+
+#include "attribute_definition.hpp"
+
+#include "matador/utils/access.hpp"
+#include "matador/utils/data_type_traits.hpp"
+#include "matador/utils/field_attributes.hpp"
+#include "matador/utils/foreign_attributes.hpp"
+
+#include <typeindex>
+#include <vector>
+
+namespace matador::object {
+
+class schema;
+
+class fk_attribute_generator
+{
+public:
+  fk_attribute_generator() = default;
+
+  template<class Type>
+  attribute_definition generate(const char *id, Type &x, const std::string &ref_table, const std::string &ref_column)
+  {
+    access::process(*this, x);
+    return attribute_definition{id, type_, 0, ref_table, ref_column, {utils::constraints::FOREIGN_KEY }, null_option::NOT_NULL};
+  }
+
+  template<typename ValueType>
+  void on_primary_key(const char *, ValueType &/*pk*/, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr)
+  {
+    type_ = utils::data_type_traits<ValueType>::type(0);
+  }
+  void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t size);
+  void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
+  template < class Type >
+  void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  template<class Pointer>
+  void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
+  template<class Pointer>
+  void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
+  template<class ContainerType>
+  void on_has_many(ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
+  template<class ContainerType>
+  void on_has_many_to_many(const char *id, ContainerType &c, 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 &c, const utils::foreign_attributes &/*attr*/) {}
+
+private:
+  utils::basic_type type_{};
+};
+
+class attribute_definition_generator final {
+private:
+  attribute_definition_generator(std::vector<attribute_definition> &columns, const schema &repo);
+
+public:
+  ~attribute_definition_generator() = default;
+
+  template < class Type >
+  static std::vector<attribute_definition> generate(const schema &repo)
+  {
+    std::vector<attribute_definition> columns;
+    attribute_definition_generator gen(columns, repo);
+    Type obj;
+    access::process(gen, obj);
+    return std::move(columns);
+  }
+
+  template < class V >
+  void on_primary_key(const char *, V &x, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr);
+  void on_primary_key(const char *id, std::string &pk, size_t size);
+  void on_revision(const char *id, unsigned long long &rev);
+
+  template<typename Type>
+  void on_attribute(const char *id, Type &x, const utils::field_attributes &attr = utils::null_attributes);
+
+  template<typename Type>
+  void on_attribute(const char *id, std::optional<Type> &x, const utils::field_attributes &attr = utils::null_attributes);
+
+  template<class Pointer>
+  void on_belongs_to(const char *id, Pointer &x, const utils::foreign_attributes &/*attr*/)
+  {
+    const auto [ref_table, ref_column] = determine_foreign_ref(std::type_index(typeid(typename Pointer::value_type)));
+    columns_.push_back(fk_column_generator_.generate(id, *x, ref_table, ref_column));
+  }
+  template<class Pointer>
+  void on_has_one(const char *id, Pointer &x, const utils::foreign_attributes &/*attr*/)
+  {
+    const auto [ref_table, ref_column] = determine_foreign_ref(std::type_index(typeid(typename Pointer::value_type)));
+    columns_.push_back(fk_column_generator_.generate(id, *x, ref_table, ref_column));
+  }
+  template<class ContainerType>
+  void on_has_many(ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
+  template<class ContainerType>
+  void on_has_many_to_many(const char *id, ContainerType &c, 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 &c, const utils::foreign_attributes &/*attr*/) {}
+
+private:
+  std::pair<std::string, std::string> determine_foreign_ref(const std::type_index &ti);
+
+private:
+  size_t index_ = 0;
+  std::vector<attribute_definition> &columns_;
+  const schema &repo_;
+
+  fk_attribute_generator fk_column_generator_;
+};
+
+template<typename V>
+void attribute_definition_generator::on_primary_key(const char *id, V &x, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>*)
+{
+  on_attribute(id, x, { utils::constraints::PRIMARY_KEY });
+}
+
+template<typename Type>
+void attribute_definition_generator::on_attribute(const char *id, Type &x, const utils::field_attributes &attr)
+{
+  columns_.emplace_back(id, x, attr, null_option::NOT_NULL);
+}
+
+template<typename Type>
+void attribute_definition_generator::on_attribute(const char *id, std::optional<Type> &x, const utils::field_attributes &attr)
+{
+  columns_.emplace_back(id, utils::data_type_traits<Type>::type(attr.size()), attr, null_option::NULLABLE);
+}
+
+}
+#endif //QUERY_COLUMN_DEFINITION_GENERATOR_HPP

include/matador/object/basic_object_info.hpp

@@ -1,6 +1,8 @@
 #ifndef BASIC_PROTOTYPE_INFO_HPP
 #define BASIC_PROTOTYPE_INFO_HPP
 
+#include "matador/object/object_definition.hpp"
+
 #include <string>
 #include <typeindex>
 
@@ -14,35 +16,18 @@ public:
 
   [[nodiscard]] std::type_index type_index() const;
   [[nodiscard]] std::string name() const;
+  [[nodiscard]] const object_definition& definition() const;
 
 protected:
-  basic_object_info(schema_node &node, std::type_index type_index);
+  basic_object_info(schema_node &node, std::type_index type_index, object_definition &&definition);
 
 protected:
   schema_node &node_;        /**< prototype node of the represented object type */
   std::type_index type_index_; /**< type index of the represented object type */
+  object_definition definition_;
 };
 
-template<typename Type>
-class object_info final : public basic_object_info {
-public:
-  explicit object_info(schema_node &node)
-  : basic_object_info(node, typeid(Type)) {}
-
-  const Type &prototype() const { return prototype_; }
-
-private:
-  Type prototype_;
-};
-
-template<typename Type>
-using object_info_ref = std::reference_wrapper<const object_info<Type>>;
-
-namespace detail {
-struct null_type {};
-}
-
-using null_info = object_info<detail::null_type>;
+using basic_object_info_ref = std::reference_wrapper<const basic_object_info>;
 
 }
 

include/matador/object/many_to_many_relation.hpp

@@ -0,0 +1,37 @@
+#ifndef QUERY_HAS_MANY_TO_MANY_RELATION_HPP
+#define QUERY_HAS_MANY_TO_MANY_RELATION_HPP
+
+#include "matador/object/object_ptr.hpp"
+
+#include "matador/utils/access.hpp"
+#include "matador/utils/foreign_attributes.hpp"
+
+namespace matador::object {
+
+template < class LocalType, class ForeignType >
+class many_to_many_relation {
+public:
+    many_to_many_relation() = default;
+    many_to_many_relation(std::string local_name, std::string remote_name)
+    : local_name_(std::move(local_name))
+    , remote_name_(std::move(remote_name)) {}
+
+    template<class Operator>
+    void process(Operator &op) {
+        namespace field = matador::access;
+        field::belongs_to(op, local_name_.c_str(), local_, utils::default_foreign_attributes);
+        field::belongs_to(op, remote_name_.c_str(), remote_, utils::default_foreign_attributes);
+    }
+
+    object_ptr<LocalType> local() const { return local_; }
+    object_ptr<LocalType> remote() const { return remote_; }
+
+private:
+    std::string local_name_;
+    std::string remote_name_;
+    object_ptr<LocalType> local_;
+    object_ptr<ForeignType> remote_;
+};
+
+}
+#endif //QUERY_HAS_MANY_TO_MANY_RELATION_HPP

include/matador/object/object_definition.hpp

@@ -0,0 +1,70 @@
+#ifndef QUERY_TABLE_DEFINITION_HPP
+#define QUERY_TABLE_DEFINITION_HPP
+
+#include "matador/object/attribute_definition.hpp"
+
+#include <unordered_map>
+
+namespace matador::object {
+
+class object_definition final {
+private:
+  using column_by_index = std::vector<object::attribute_definition>;
+  using column_index_pair = std::pair<std::reference_wrapper<object::attribute_definition>, column_by_index::difference_type>;
+  using column_by_name_map = std::unordered_map<std::string, column_index_pair>;
+
+public:
+  using iterator = column_by_index::iterator;
+  using const_iterator = column_by_index::const_iterator;
+
+  object_definition() = default;
+  object_definition(std::initializer_list<object::attribute_definition> columns);
+  explicit object_definition(const std::vector<object::attribute_definition> &columns);
+  object_definition(const object_definition &x);
+  object_definition& operator=(const object_definition &x);
+  object_definition(object_definition&&) noexcept = default;
+  object_definition& operator=(object_definition&&) noexcept = default;
+  ~object_definition() = default;
+
+  [[nodiscard]] bool has_primary_key() const;
+  [[nodiscard]] std::optional<object::attribute_definition> primary_key() const;
+
+  template < typename Type >
+  void append(const std::string &name, long size = -1) {
+    append(make_column<Type>(name, size));
+  }
+  void append(attribute_definition col);
+
+  [[nodiscard]] const std::vector<object::attribute_definition>& columns() const;
+
+  [[nodiscard]] const attribute_definition& at(const std::string &name) const;
+  [[nodiscard]] const attribute_definition& at(size_t index) const;
+
+  iterator find(const std::string &column_name);
+  [[nodiscard]] const_iterator find(const std::string &column_name) const;
+
+  iterator begin();
+  [[nodiscard]] const_iterator begin() const;
+  [[nodiscard]] const_iterator cbegin() const;
+
+  iterator end();
+  [[nodiscard]] const_iterator end() const;
+  [[nodiscard]] const_iterator cend() const;
+
+  [[nodiscard]] size_t size() const;
+  [[nodiscard]] bool empty() const;
+  void clear();
+
+private:
+  void init();
+  void add_to_map(attribute_definition &col, size_t index);
+
+private:
+  column_by_index columns_;
+  column_by_name_map columns_by_name_;
+
+  int pk_index_{-1};
+};
+
+}
+#endif //QUERY_TABLE_DEFINITION_HPP

include/matador/object/object_info.hpp

@@ -0,0 +1,34 @@
+#ifndef OBJECT_INFO_HPP
+#define OBJECT_INFO_HPP
+
+#include "matador/object/basic_object_info.hpp"
+#include "matador/object/object_definition.hpp"
+
+namespace matador::object {
+
+class schema_node;
+
+template<typename Type>
+class object_info final : public basic_object_info {
+public:
+    explicit object_info(schema_node &node, object_definition &&definition)
+    : basic_object_info(node, typeid(Type), std::move(definition)) {}
+
+    const Type &prototype() const { return prototype_; }
+
+private:
+    Type prototype_;
+};
+
+template<typename Type>
+using object_info_ref = std::reference_wrapper<const object_info<Type>>;
+
+namespace detail {
+struct null_type {};
+}
+
+using null_info = object_info<detail::null_type>;
+
+}
+
+#endif //OBJECT_INFO_HPP

include/matador/object/object_ptr.hpp

@@ -5,6 +5,7 @@ namespace matador::object {
 template <typename Type>
 class object_ptr {
 public:
+    using value_type = Type;
     Type* operator->() { return ptr; };
     Type& operator*() { return *ptr; };
 

include/matador/object/schema.hpp

@@ -93,6 +93,18 @@ public:
       return utils::ok(result.value()->info<Type>());
   }
 
+  template <typename Type>
+  [[nodiscard]] utils::result<basic_object_info_ref, utils::error> basic_info() const {
+      auto result = find_node(std::type_index(typeid(Type)));
+      if (!result) {
+          return utils::failure(result.err());
+      }
+
+      return utils::ok(basic_object_info_ref{result.value()->basic_info()});
+  }
+
+  [[nodiscard]] utils::result<std::pair<std::string, std::string>, utils::error> reference(const std::type_index &type_index) const;
+
 private:
   using node_ptr = std::shared_ptr<schema_node>;
   using t_node_map = std::unordered_map<std::string, node_ptr>;

include/matador/object/schema_node.hpp

@@ -1,13 +1,14 @@
 #ifndef SCHEMA_NODE_HPP
 #define SCHEMA_NODE_HPP
 
-#include "matador/object/basic_object_info.hpp"
+#include "matador/object/attribute_definition_generator.hpp"
+#include "matador/object/object_info.hpp"
 
 #include <memory>
-#include <string>
 
 namespace matador::object {
 
+class basic_object_info;
 class schema;
 
 class schema_node final {
@@ -28,24 +29,11 @@ public:
   [[nodiscard]] std::string name() const;
   [[nodiscard]] std::type_index type_index() const;
 
-  /**
-   * Appends the given prototype node as a sibling
-   * on the same level.
-   *
-   * @param sibling The new sibling node.
-   */
-  void append(const std::shared_ptr<schema_node> &sibling);
-
-  /**
-   * Inserts the given node to the list of children.
-   *
-   * @param child The child node to add.
-   */
-  void insert(const std::shared_ptr<schema_node> &child);
-
   [[nodiscard]] node_ptr next() const;
   [[nodiscard]] node_ptr prev() const;
 
+  [[nodiscard]] const basic_object_info& basic_info() const;
+
   template <typename Type>
   object_info_ref<Type> info() const {
       return std::ref(static_cast<const object_info<Type>&>(*info_));
@@ -56,7 +44,7 @@ private:
   template < typename Type >
   schema_node(schema& tree, std::string name, Type *obj)
   : schema_(tree)
-  , info_(std::make_unique<object_info<Type>>(*this))
+  , info_(std::make_unique<object_info<Type>>(*this, object_definition(attribute_definition_generator::generate<Type>(schema_))))
   , first_child_(std::shared_ptr<schema_node>(new schema_node(tree)))
   , last_child_(std::shared_ptr<schema_node>(new schema_node(tree)))
   , name_(std::move(name)) {
@@ -69,7 +57,7 @@ private:
   friend class schema;
   friend class const_schema_node_iterator;
 
-  schema &schema_;
+  object::schema &schema_;
   std::unique_ptr<basic_object_info> info_;
 
   std::shared_ptr<schema_node> parent_;