removed the value field from attribute_definition because it's a definition and should not hold a value.

source/core/object/attribute_definition.cpp

@@ -22,42 +22,44 @@ attribute_definition::attribute_definition(std::string name,
 , table_(std::move(table_name))
 , index_(0)
 , attributes_(attr)
-, value_(type, attr.size()) {
+, type_(type){
 }
 
-attribute_definition::attribute_definition(std::string name, const utils::basic_type type,
-                                           const utils::field_attributes &attr, const null_option null_opt,
-                                           const size_t index)
+attribute_definition::attribute_definition(std::string name,
+                                           const utils::basic_type type,
+                                           const utils::field_attributes &attr,
+                                           const null_option null_opt,
+                                           const int index)
 : name_(std::move(name))
 , index_(index)
 , attributes_(attr)
 , null_option_(null_opt)
-, value_(type, attr.size()) {
+, type_(type) {
 }
 
 attribute_definition::attribute_definition(std::string name,
                                            std::string table_name,
                                            const utils::basic_type type,
                                            const utils::field_attributes &attr, const null_option null_opt,
-                                           const size_t index)
+                                           const int index)
 : name_(std::move(name))
 , table_(std::move(table_name))
 , index_(index)
 , attributes_(attr)
 , null_option_(null_opt)
-, value_(type, attr.size()) {
+, type_(type) {
 }
 
 attribute_definition::attribute_definition(std::string name,
                                            const utils::basic_type type,
-                                           const size_t index,
+                                           const int index,
                                            const std::shared_ptr<attribute_definition> &ref_column,
                                            const utils::field_attributes &attr, const null_option null_opt)
 : name_(std::move(name))
 , index_(index)
 , attributes_(attr)
 , null_option_(null_opt)
-, value_(type, attr.size())
+, type_(type)
 , reference_column_(ref_column) {
 }
 
@@ -98,7 +100,12 @@ bool attribute_definition::is_nullable() const {
 }
 
 utils::basic_type attribute_definition::type() const {
-  return value_.type();
+  return type_;
+}
+
+void attribute_definition::change_type(const utils::basic_type type, const utils::field_attributes& attr) {
+    attributes_ = attr;
+    type_ = type;
 }
 
 std::shared_ptr<attribute_definition> attribute_definition::reference_column() const {
@@ -110,52 +117,39 @@ bool attribute_definition::is_foreign_reference() const {
 }
 
 bool attribute_definition::is_integer() const {
-  return value_.is_integer();
+  return type_ >= utils::basic_type::type_int8 && type_ <= utils::basic_type::type_uint64;
 }
 
 bool attribute_definition::is_floating_point() const {
-  return value_.is_floating_point();
+  return type_ == utils::basic_type::type_float || type_ == utils::basic_type::type_double;
 }
 
 bool attribute_definition::is_bool() const {
-  return value_.is_bool();
+  return type_ == utils::basic_type::type_bool;
 }
 
 bool attribute_definition::is_string() const {
-  return value_.is_string();
+  return type_ == utils::basic_type::type_text;
 }
 
 bool attribute_definition::is_varchar() const {
-  return value_.is_varchar();
+  return type_ == utils::basic_type::type_varchar;
 }
 
 bool attribute_definition::is_date() const {
-  return value_.is_date();
+  return type_ == utils::basic_type::type_date;
 }
 
 bool attribute_definition::is_time() const {
-  return value_.is_time();
+  return type_ == utils::basic_type::type_time;
 }
 
 bool attribute_definition::is_blob() const {
-  return value_.is_blob();
+  return type_ == utils::basic_type::type_blob;
 }
 
 bool attribute_definition::is_null() const {
-  return value_.is_null();
-}
-
-void attribute_definition::type(const utils::basic_type type) {
-  value_.type(type);
-}
-
-std::string attribute_definition::str() const {
-  return value_.str();
-}
-
-std::ostream &operator<<(std::ostream &out, const attribute_definition &col) {
-  out << col.str();
-  return out;
+  return type_ == utils::basic_type::type_null;
 }
 
 attribute_definition make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr,

source/core/object/repository_node.cpp

@@ -112,7 +112,7 @@ std::shared_ptr<attribute_definition> repository_node::determine_reference_colum
     tree.missing_references_.erase(it);
     ref_column->name(pk_info.pk_column_name);
     ref_column->table_name(name);
-    ref_column->type(pk_info.type);
+    ref_column->change_type(pk_info.type);
     ref_column->attributes() = utils::constraints::FOREIGN_KEY;
 
     if (name.empty()) {

source/core/utils/value.cpp

@@ -7,18 +7,15 @@ namespace detail {
 
 void initialize_by_basic_type(basic_type type, database_type &val);
 
-size_t determine_size(const std::string &val)
-{
+size_t determine_size(const std::string &val) {
   return val.size();
 }
 
-size_t determine_size(const char *val)
-{
+size_t determine_size(const char *val) {
   return strlen(val);
 }
 
-size_t determine_size(const blob &val)
-{
+size_t determine_size(const blob &val) {
   return val.size();
 }
 

source/orm/orm/session.cpp

@@ -101,7 +101,7 @@ utils::result<sql::query_result<sql::record>, utils::error> session::fetch_all(c
   // adjust columns from given query
   for (auto &col: q.prototype) {
     if (const auto rit = it->second.find(col.name()); rit != it->second.end()) {
-      const_cast<object::attribute_definition &>(col).type(rit->type());
+      const_cast<object::attribute_definition &>(col).change_type(rit->type());
     }
   }
   auto res = fetch(q);

source/orm/query/query_compiler.cpp

@@ -39,7 +39,7 @@ std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const
     ctx.column_aliases.insert({column_table->has_alias() ? column_table->alias() : column_table->name() + "." + col.column_name(), col.alias()});
     if (col.is_function()) {
       ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.column_name());
-      ctx.prototype.back().type(utils::basic_type::type_int32);
+      ctx.prototype.back().change_type(utils::basic_type::type_int32);
     } else {
         ctx.prototype.emplace_back(col.column_name());
     }

source/orm/sql/connection.cpp

@@ -229,7 +229,7 @@ utils::result<std::unique_ptr<statement_impl>, utils::error> connection::perform
           [&col](const auto &value) { return value.name() == col.name(); }
         );
         if (col.type() == utils::basic_type::type_null && rit != result->end()) {
-          const_cast<object::attribute_definition&>(col).type(rit->type());
+          const_cast<object::attribute_definition&>(col).change_type(rit->type());
         }
       }
     }