preparations for object_generator (generating objects with attributes and constraints)

2025-11-23 15:58:14 +01:00
parent 19b0adf737
commit e67c0f39a3
23 changed files with 468 additions and 69 deletions
@@ -1,4 +1,5 @@
-add_executable(demo main.cpp)
+add_executable(demo main.cpp
+  object.cpp)
 target_link_libraries(demo PRIVATE
  matador-core
  matador-orm
@@ -23,3 +24,9 @@ target_link_libraries(work PRIVATE
 )

 add_dependencies(work matador-postgres)
+
+add_executable(object object.cpp)
+target_link_libraries(object PRIVATE
+  matador-core
+  ${CMAKE_DL_LIBS}
+)
@@ -0,0 +1,233 @@
+#include "matador/utils/basic_types.hpp"
+#include "matador/utils/constraints.hpp"
+#include "matador/utils/field_attributes.hpp"
+
+#include <string>
+#include <vector>
+
+
+namespace object {
+
+namespace utils = matador::utils;
+
+class object;
+
+enum class null_option_type : uint8_t {
+  Nullable,
+  NotNull
+};
+
+class attribute {
+public:
+  explicit attribute(std::string name); // NOLINT(*-explicit-constructor)
+
+  attribute(const attribute&) = default;
+  attribute& operator=(const attribute&) = default;
+  attribute(attribute&&) noexcept = default;
+  attribute& operator=(attribute&&) noexcept = default;
+
+  attribute() = default;
+  attribute(std::string name,
+            utils::basic_type type,
+            const utils::field_attributes& opts = utils::null_attributes,
+            null_option_type null_opt = null_option_type::NotNull)
+  : name_(std::move(name)), type_(type), options_(opts), null_option_type_(null_opt) {}
+
+  [[nodiscard]] const std::string& name() const { return name_; }
+  void name(const std::string& n) { name_ = n; }
+  [[nodiscard]] const utils::field_attributes& options() const { return options_; }
+  [[nodiscard]] utils::field_attributes& options();
+
+  [[nodiscard]] bool is_nullable() const { return null_option_type_ == null_option_type::Nullable; }
+  [[nodiscard]] utils::basic_type type() const { return type_; }
+
+  [[nodiscard]] bool is_integer() const { return type_ >= utils::basic_type::type_int8 && type_ <= utils::basic_type::type_uint64; }
+  [[nodiscard]] bool is_floating_point() const { return type_ == utils::basic_type::type_float || type_ == utils::basic_type::type_double; }
+  [[nodiscard]] bool is_bool() const { return type_ == utils::basic_type::type_bool; }
+  [[nodiscard]] bool is_string() const { return type_ == utils::basic_type::type_text; }
+  [[nodiscard]] bool is_varchar() const { return type_ == utils::basic_type::type_varchar; }
+  [[nodiscard]] bool is_date() const { return type_ == utils::basic_type::type_date; }
+  [[nodiscard]] bool is_time() const { return type_ == utils::basic_type::type_time; }
+  [[nodiscard]] bool is_blob() const { return type_ == utils::basic_type::type_blob; }
+  [[nodiscard]] bool is_null() const { return type_ == utils::basic_type::type_null; }
+
+private:
+  friend class object;
+
+  std::string name_;
+  std::string alias_;
+  utils::basic_type type_{utils::basic_type::type_null};
+  utils::field_attributes options_;
+  null_option_type null_option_type_{null_option_type::NotNull};
+
+  object* parent_{nullptr};
+};
+
+class constraint {
+public:
+  constraint() = default;
+
+  explicit constraint(std::string name) : name_(std::move(name)) {}
+  [[nodiscard]] const std::string& name() const { return name_; }
+
+private:
+  friend class object;
+
+  std::string name_;
+  std::string attribute_name_;
+  utils::constraints options_{utils::constraints::None};
+
+  object* parent_{nullptr};
+  attribute* attribute_{nullptr};
+};
+
+class object {
+public:
+  explicit object(std::string name, std::string alias = "");
+
+  void add_attribute(attribute attr) {
+    auto &ref = attributes_.emplace_back(std::move(attr));
+    ref.parent_ = this;
+  }
+
+  static const attribute& create_attribute(std::string name, object& obj) {
+    attribute attr{std::move(name)};
+    attr.parent_ = &obj;
+    return obj.attributes_.emplace_back(std::move(attr));
+  }
+
+  void add_constraint(constraint c) {
+    auto &ref = constraints_.emplace_back(std::move(c));
+    ref.parent_ = this;
+  }
+
+  [[nodiscard]] const std::string& name() const { return name_; }
+  [[nodiscard]] const std::string& alias() const { return alias_; }
+
+  [[nodiscard]] bool has_attributes() const { return attributes_.empty(); }
+  [[nodiscard]] size_t attribute_count() const { return attributes_.size(); }
+  [[nodiscard]] const std::vector<attribute>& attributes() const { return attributes_; }
+
+  [[nodiscard]] bool has_constraints() const { return constraints_.empty(); }
+  [[nodiscard]] size_t constraint_count() const { return constraints_.size(); }
+  [[nodiscard]] const std::vector<constraint>& constraints() const { return constraints_; }
+
+private:
+  std::string name_;
+  std::string alias_;
+
+  std::vector<attribute> attributes_;
+  std::vector<constraint> constraints_;
+};
+
+template<typename Type>
+class typed_object : public object {
+public:
+  using object::object;
+
+  Type as(std::string alias) { return Type{std::move(alias)}; }
+};
+
+struct column_builder {
+    explicit column_builder(std::string column_name)
+    : column_name( std::move(column_name) ) {
+    }
+
+    column_builder& not_null() {
+        return *this;
+    }
+
+    column_builder& primary_key() {
+        return *this;
+    }
+
+    operator attribute() const {
+        return attribute{column_name};
+    }
+
+    std::string column_name;
+};
+
+column_builder column(std::string name) {
+    return column_builder(std::move(name));
+}
+
+namespace matador::sql {
+struct constraint {
+    std::string name;
+};
+}
+
+struct constraint_builder {
+    constraint_builder& constraint(std::string name) {
+        constraint_name = std::move(name);
+        return *this;
+    }
+
+    constraint_builder& primary_key(std::string name) {
+        pk_column_name = std::move(name);
+        return *this;
+    }
+    constraint_builder& foreign_key(std::string name) {
+        fk_column_name = std::move(name);
+        return *this;
+    }
+
+    constraint_builder& references(std::string table, std::string column) {
+        this->table_name = std::move(table);
+        this->column_name = std::move(column);
+        return *this;
+    }
+
+    operator matador::sql::constraint() const {
+        return matador::sql::constraint{constraint_name};
+    }
+
+    std::string constraint_name;
+    std::string pk_column_name;
+    std::string fk_column_name;
+    std::string table_name;
+    std::string column_name;
+};
+
+constraint_builder constraint(std::string name) {
+    constraint_builder builder;
+    return builder.constraint(std::move(name));
+}
+
+template<typename Type>
+std::string column_prefix(typed_object<Type> *tab) {
+    if (!tab || tab->empty()) {
+        return "";
+    }
+    if (!tab->alias().empty()) {
+        return tab->alias();
+    }
+    return tab->name();
+}
+
+struct table_builder {
+    explicit table_builder(std::string name)
+    : table_name( std::move(name) ) {}
+
+    table_builder& as(std::string table_alias) {
+        this->alias = std::move(table_alias);
+        return *this;
+    }
+
+    operator object() const {
+        return object{table_name, alias};
+    }
+    std::string table_name;
+    std::string alias;
+};
+
+table_builder table(std::string name) {
+    return table_builder(std::move(name));
+}
+
+}
+
+int main() {
+
+}