From 9e4660c4ee8ca45449a8bd83ddf60d6f79c5b0f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sascha=20K=C3=BChl?= <skuehl1972@gmail.com>
Date: Fri, 3 Apr 2026 19:46:53 +0200
Subject: [PATCH] removed unused on_attribute overloads

---
 backends/postgres/src/postgres_connection.cpp |  2 +-
 demo/object.cpp                               |  2 +-
 include/matador/object/attribute.hpp          |  6 +-
 .../matador/object/foreign_node_completer.hpp |  6 +-
 .../matador/object/join_columns_collector.hpp |  4 +-
 include/matador/object/object_generator.hpp   | 12 ++--
 include/matador/object/pk_field_locator.hpp   |  4 +-
 .../matador/object/primary_key_resolver.hpp   |  4 +-
 include/matador/object/relation_completer.hpp | 12 ++--
 include/matador/orm/session.hpp               | 10 +--
 include/matador/query/basic_schema.hpp        |  4 +-
 .../matador/query/dependency_collector.hpp    |  6 +-
 include/matador/query/fk_value_extractor.hpp  |  6 +-
 include/matador/query/generator.hpp           | 14 ++--
 .../matador/query/insert_query_builder.hpp    | 16 ++---
 include/matador/query/key_value_generator.hpp |  4 +-
 include/matador/query/schema.hpp              |  4 +-
 .../matador/query/select_query_builder.hpp    |  4 +-
 include/matador/query/value_extractor.hpp     |  8 +--
 include/matador/sql/generator.hpp             |  4 +-
 .../sql/internal/identifier_reader.hpp        |  4 +-
 .../sql/internal/object_result_binder.hpp     | 26 +++----
 include/matador/sql/internal/pk_reader.hpp    |  4 +-
 .../sql/internal/query_result_impl.hpp        | 10 +--
 .../sql/internal/query_result_pk_resolver.hpp |  6 +-
 .../matador/sql/object_parameter_binder.hpp   | 10 +--
 include/matador/sql/object_pk_binder.hpp      | 10 +--
 include/matador/utils/access.hpp              | 69 ++++---------------
 include/matador/utils/field_attributes.hpp    |  2 +-
 .../matador/utils/primary_key_accessor.hpp    | 12 ++--
 .../matador/utils/primary_key_attribute.hpp   |  2 +-
 source/core/object/object_generator.cpp       |  2 +-
 test/models/coordinate.hpp                    |  2 +-
 33 files changed, 126 insertions(+), 165 deletions(-)

diff --git a/backends/postgres/src/postgres_connection.cpp b/backends/postgres/src/postgres_connection.cpp
index 4e004b9..dd280f5 100644
--- a/backends/postgres/src/postgres_connection.cpp
+++ b/backends/postgres/src/postgres_connection.cpp
@@ -281,7 +281,7 @@ utils::result<std::vector<object::attribute>, utils::error> postgres_connection:
       null_opt = object::null_option_type::NotNull;
     }
     // f.default_value(res->column(4));
-    prototype.emplace_back(name, type, utils::null_attributes, null_opt);
+    prototype.emplace_back(name, type, utils::NullAttributes, null_opt);
   }
 
   return utils::ok(prototype);
diff --git a/demo/object.cpp b/demo/object.cpp
index 094976b..d58a0a9 100644
--- a/demo/object.cpp
+++ b/demo/object.cpp
@@ -29,7 +29,7 @@ public:
   attribute() = default;
   attribute(std::string name,
             utils::basic_type type,
-            const utils::field_attributes& opts = utils::null_attributes,
+            const utils::field_attributes& opts = utils::NullAttributes,
             null_option_type null_opt = null_option_type::NotNull)
   : name_(std::move(name)), type_(type), options_(opts), null_option_type_(null_opt) {}
 
diff --git a/include/matador/object/attribute.hpp b/include/matador/object/attribute.hpp
index 27b778b..cf35aeb 100644
--- a/include/matador/object/attribute.hpp
+++ b/include/matador/object/attribute.hpp
@@ -28,7 +28,7 @@ public:
   attribute() = default;
   attribute(std::string name,
             utils::basic_type type,
-            const utils::field_attributes &attr = utils::null_attributes,
+            const utils::field_attributes &attr = utils::NullAttributes,
             null_option_type null_opt = null_option_type::NotNull);
 
   [[nodiscard]] const std::string& name() const;
@@ -39,9 +39,9 @@ public:
   [[nodiscard]] bool is_nullable() const;
   [[nodiscard]] utils::basic_type type() const;
   [[nodiscard]] std::shared_ptr<object> owner() const;
-  void change_type(utils::basic_type type, const utils::field_attributes &attr = utils::null_attributes);
+  void change_type(utils::basic_type type, const utils::field_attributes &attr = utils::NullAttributes);
   template < typename Type >
-  void change_type(const utils::field_attributes &attr = utils::null_attributes) {
+  void change_type(const utils::field_attributes &attr = utils::NullAttributes) {
       type_ = utils::data_type_traits<Type>::type(attr.size());
   }
 
diff --git a/include/matador/object/foreign_node_completer.hpp b/include/matador/object/foreign_node_completer.hpp
index 9a2f488..d2718fc 100644
--- a/include/matador/object/foreign_node_completer.hpp
+++ b/include/matador/object/foreign_node_completer.hpp
@@ -39,12 +39,12 @@ public:
   }
 
   template<class PrimaryKeyType>
-  static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute & /*attr*/ = utils::default_pk_attributes) {}
+  static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute & /*attr*/) {}
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template<typename AttributeType>
-  static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/) {}
   template<typename AttributeType>
-  static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/) {}
   template<class ForeignPointerType>
   void on_belongs_to(const char *id, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/);
   template<class ForeignPointerType>
diff --git a/include/matador/object/join_columns_collector.hpp b/include/matador/object/join_columns_collector.hpp
index c45fb6f..e3758fe 100644
--- a/include/matador/object/join_columns_collector.hpp
+++ b/include/matador/object/join_columns_collector.hpp
@@ -25,10 +25,10 @@ public:
         return join_columns_;
     }
     template < class V >
-    static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
+    static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/) {}
     static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
     template<typename Type>
-    static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+    static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/) {}
     template<class Pointer>
     static void on_belongs_to(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
     template<class Pointer>
diff --git a/include/matador/object/object_generator.hpp b/include/matador/object/object_generator.hpp
index a1eb8ed..fa8b226 100644
--- a/include/matador/object/object_generator.hpp
+++ b/include/matador/object/object_generator.hpp
@@ -25,13 +25,13 @@ public:
     }
 
     template<typename ValueType>
-    void on_primary_key(const char *, ValueType &/*pk*/, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
+    void on_primary_key(const char *, ValueType &/*pk*/, const utils::primary_key_attribute& attr) {
         type_ = utils::data_type_traits<ValueType>::type(attr.size());
     }
     static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
     template < class Type >
-    static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
-    static void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+    static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) {}
+    static void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/) {}
     template<class Pointer>
     static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
     template<class Pointer>
@@ -75,14 +75,14 @@ public:
     }
 
     template < class Type >
-    void on_primary_key(const char *, Type &x, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
+    void on_primary_key(const char *, Type &x, const utils::primary_key_attribute& attr);
     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);
+    void on_attribute(const char *id, Type &x, const utils::field_attributes &attr);
 
     template<typename Type>
-    void on_attribute(const char *id, std::optional<Type> &x, const utils::field_attributes &attr = utils::null_attributes);
+    void on_attribute(const char *id, std::optional<Type> &x, const utils::field_attributes &attr);
 
     template<class Pointer>
     void on_belongs_to(const char *id, Pointer &x, const utils::foreign_attributes &/*attr*/) {
diff --git a/include/matador/object/pk_field_locator.hpp b/include/matador/object/pk_field_locator.hpp
index ec1bffd..4e28d31 100644
--- a/include/matador/object/pk_field_locator.hpp
+++ b/include/matador/object/pk_field_locator.hpp
@@ -35,7 +35,7 @@ struct pk_field_locator {
   : base(&obj) {}
 
   template <typename PrimaryKeyType>
-  void on_primary_key(const char *, PrimaryKeyType &pk, const utils::primary_key_attribute & = utils::default_pk_attributes) {
+  void on_primary_key(const char *, PrimaryKeyType &pk, const utils::primary_key_attribute & /*attr*/) {
     // Offset bestimmen
     const auto* obj_bytes = reinterpret_cast<std::uint8_t*>(base);
     const auto* pk_bytes = reinterpret_cast<std::uint8_t*>(&pk);
@@ -113,7 +113,7 @@ struct pk_field_locator {
   }
   static void on_revision(const char *, std::uint64_t &) {}
   template <typename V>
-  static void on_attribute(const char *, V &, const utils::field_attributes & = matador::utils::null_attributes) {}
+  static void on_attribute(const char *, V &, const utils::field_attributes &/*attr*/) {}
   template <typename Pointer>
   static void on_belongs_to(const char *, Pointer &, const utils::foreign_attributes &) {}
   template <typename Pointer>
diff --git a/include/matador/object/primary_key_resolver.hpp b/include/matador/object/primary_key_resolver.hpp
index 4f1f75a..f0b9beb 100644
--- a/include/matador/object/primary_key_resolver.hpp
+++ b/include/matador/object/primary_key_resolver.hpp
@@ -44,7 +44,7 @@ public:
   }
 
   template < class Type >
-  void on_primary_key(const char *id, Type &pk, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, Type &pk, const utils::primary_key_attribute& attr) {
     primary_key_info_.pk_column_name = id;
     primary_key_info_.type = utils::data_type_traits<Type>::type(attr.size());
     primary_key_info_.pk = pk;
@@ -52,7 +52,7 @@ public:
 
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template<typename Type>
-  static void on_attribute(const char * /*id*/, Type &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*val*/, const utils::field_attributes &/*attr*/) {}
   template<class Pointer>
   static void on_belongs_to(const char * /*id*/, Pointer &/*val*/, const utils::foreign_attributes &/*attr*/) {}
   template<class Pointer>
diff --git a/include/matador/object/relation_completer.hpp b/include/matador/object/relation_completer.hpp
index 675e1b8..58b20e5 100644
--- a/include/matador/object/relation_completer.hpp
+++ b/include/matador/object/relation_completer.hpp
@@ -29,12 +29,12 @@ public:
     }
 
     template<class PrimaryKeyType>
-    static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
+    static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/) {}
     static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
     template<typename AttributeType>
-    static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+    static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/) {}
     template<typename AttributeType>
-    static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+    static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/) {}
 
     template<class ForeignPointerType>
     void on_belongs_to(const char *id, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/) {
@@ -103,12 +103,12 @@ public:
   }
 
   template<class PrimaryKeyType>
-  static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
+  static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/) {}
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template<typename AttributeType>
-  static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/) {}
   template<typename AttributeType>
-  static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/) {}
 
   template<class ForeignPointerType>
   void on_belongs_to(const char *id, ForeignPointerType &obj, const utils::foreign_attributes &attr);
diff --git a/include/matador/orm/session.hpp b/include/matador/orm/session.hpp
index 39680b1..010c1b4 100644
--- a/include/matador/orm/session.hpp
+++ b/include/matador/orm/session.hpp
@@ -179,7 +179,7 @@ public:
   }
 
   template<class Type>
-  void on_primary_key(const char * /*id*/, Type &x, const utils::primary_key_attribute & /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char * /*id*/, Type &x, const utils::primary_key_attribute & /*attr*/) {
     stmt_.bind(binding_position_, x);
   }
 
@@ -187,17 +187,17 @@ public:
   }
 
   template<class Type>
-  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) {}
   template<class Pointer>
-  static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+  static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
   template<class Pointer>
-  static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+  static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
 
   template<class ContainerType>
   static void on_has_many(const char * /*id*/,
                           ContainerType &/*c*/,
                           const char * /*join_column*/,
-                          const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+                          const utils::foreign_attributes &/*attr*/) {}
 
   template<class ContainerType>
   static void on_has_many_to_many(const char * /*id*/,
diff --git a/include/matador/query/basic_schema.hpp b/include/matador/query/basic_schema.hpp
index 7dd8665..d7c3224 100644
--- a/include/matador/query/basic_schema.hpp
+++ b/include/matador/query/basic_schema.hpp
@@ -41,12 +41,12 @@ public:
     return generator_type_;
   }
   template<class V>
-  void on_primary_key(const char * /*id*/, V &/*pk*/, const utils::primary_key_attribute &attr = utils::default_pk_attributes) {
+  void on_primary_key(const char * /*id*/, V &/*pk*/, const utils::primary_key_attribute &attr) {
     generator_type_ = attr.generator();
   }
   static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
   template<typename T>
-  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes & = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes &/*attr*/) {}
   template<class P>
   static void on_belongs_to(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
   template<class P>
diff --git a/include/matador/query/dependency_collector.hpp b/include/matador/query/dependency_collector.hpp
index ddfa8ea..70696bc 100644
--- a/include/matador/query/dependency_collector.hpp
+++ b/include/matador/query/dependency_collector.hpp
@@ -60,15 +60,15 @@ struct dependency_collector {
   std::vector<fk_ref> refs;
 
   template<class V>
-  static void on_primary_key(const char*, V&, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
+  static void on_primary_key(const char*, V&, const utils::primary_key_attribute& /*attr*/) {}
 
   static void on_revision(const char*, std::uint64_t&) {}
 
   template<class V>
-  static void on_attribute(const char*, V&, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char*, V&, const utils::field_attributes &/*attr*/) {}
 
   template<class Pointer>
-  void on_belongs_to(const char* id, Pointer& p, utils::foreign_attributes &attr) {
+  void on_belongs_to(const char* id, Pointer& p, utils::foreign_attributes &/*attr*/) {
     // Erwartung: Pointer verhält sich wie matador::object::object_ptr<T>
     // also: p.get() liefert raw ptr, und Pointer::value_type / element_type ist T.
     auto* raw = p.get();
diff --git a/include/matador/query/fk_value_extractor.hpp b/include/matador/query/fk_value_extractor.hpp
index a54fb32..bab6eb8 100644
--- a/include/matador/query/fk_value_extractor.hpp
+++ b/include/matador/query/fk_value_extractor.hpp
@@ -25,13 +25,13 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *, ValueType &pk, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char *, ValueType &pk, const utils::primary_key_attribute& /*attr*/) {
     value_ = pk;
   }
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template < class Type >
-  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
-  static void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) {}
+  static void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/) {}
   template<class Pointer>
   static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
   template<class Pointer>
diff --git a/include/matador/query/generator.hpp b/include/matador/query/generator.hpp
index ec26449..112659f 100644
--- a/include/matador/query/generator.hpp
+++ b/include/matador/query/generator.hpp
@@ -64,13 +64,13 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/) {
       push(id);
   }
   void on_revision(const char *id, uint64_t &/*rev*/);
 
   template<typename Type>
-  void on_attribute(const char *id, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
+  void on_attribute(const char *id, Type &, const utils::field_attributes &/*attr*/) {
       push(id);
   }
 
@@ -105,7 +105,7 @@ public:
   }
 
   template<class CollectionType>
-  void on_has_many(const char * /*id*/, CollectionType &, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<!object::is_object_ptr<typename CollectionType::value_type>::value> * = nullptr) {
+  void on_has_many(const char * /*id*/, CollectionType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/, std::enable_if_t<!object::is_object_ptr<typename CollectionType::value_type>::value> * = nullptr) {
   }
 
   template<class ContainerType>
@@ -170,13 +170,13 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char * /*id*/, V &/*x*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char * /*id*/, V &/*x*/, const utils::primary_key_attribute& /*attr*/) {
     result_.emplace_back(utils::_);
   }
   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) {
+  void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) {
     result_.emplace_back(utils::_);
   }
 
@@ -228,13 +228,13 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/) {
     push_back(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) {
+  void on_attribute(const char *id, Type &x, const utils::field_attributes &/*attr*/) {
     push_back(id, x);
   }
 
diff --git a/include/matador/query/insert_query_builder.hpp b/include/matador/query/insert_query_builder.hpp
index 9287b27..cc50353 100644
--- a/include/matador/query/insert_query_builder.hpp
+++ b/include/matador/query/insert_query_builder.hpp
@@ -13,14 +13,14 @@ struct pk_setter {
   std::uint64_t value;
 
   template<class V>
-  void on_primary_key(const char *id, V &pk, const utils::primary_key_attribute & = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, V &pk, const utils::primary_key_attribute &/*attr*/) {
     if (id != nullptr && name == id) {
       pk = static_cast<V>(value);
     }
   }
   static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
   template<typename T>
-  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes & = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes &/*attr*/) {}
   template<class P>
   static void on_belongs_to(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
   template<class P>
@@ -38,7 +38,7 @@ struct pk_unset_checker {
   bool unset{true};
 
   template<class V>
-  void on_primary_key(const char *id, V &pk, const utils::primary_key_attribute & = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, V &pk, const utils::primary_key_attribute &/*attr*/) {
     if (id != nullptr && name == id) {
       // Your convention: 0 means unset for integer PKs
       unset = (static_cast<std::uint64_t>(pk) == 0ULL);
@@ -46,7 +46,7 @@ struct pk_unset_checker {
   }
   static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
   template<typename T>
-  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes & = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes &/*attr*/) {}
   template<class P>
   static void on_belongs_to(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
   template<class P>
@@ -63,12 +63,12 @@ struct pk_value_extractor {
   std::uint64_t value{0};
 
   template<class V>
-  void on_primary_key(const char * /*id*/, V &pk, const utils::primary_key_attribute & = utils::default_pk_attributes) {
+  void on_primary_key(const char * /*id*/, V &pk, const utils::primary_key_attribute &/*attr*/) {
     value = static_cast<std::uint64_t>(pk);
   }
   static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
   template<typename T>
-  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes & = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, T &, const utils::field_attributes &/*attr*/) {}
   template<class P>
   static void on_belongs_to(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
   template<class P>
@@ -123,11 +123,11 @@ public:
   }
 
   template < class V >
-  static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
+  static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/) {}
   static void on_revision(const char *id, uint64_t &/*rev*/);
 
   template<typename Type>
-  static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/) {}
 
   template<class Pointer>
   void on_belongs_to(const char * /*id*/, Pointer &obj, const utils::foreign_attributes &attr) {
diff --git a/include/matador/query/key_value_generator.hpp b/include/matador/query/key_value_generator.hpp
index b849aee..66e2acd 100644
--- a/include/matador/query/key_value_generator.hpp
+++ b/include/matador/query/key_value_generator.hpp
@@ -27,13 +27,13 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/) {
     result_.emplace_back(id, x);
   }
   void on_revision(const char *id, uint64_t &/*rev*/) const;
 
   template<typename Type>
-  void on_attribute(const char *id, Type &x, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
+  void on_attribute(const char *id, Type &x, const utils::field_attributes &/*attr*/) {
     result_.emplace_back(id, x);
   }
 
diff --git a/include/matador/query/schema.hpp b/include/matador/query/schema.hpp
index 862ab71..5d8101a 100644
--- a/include/matador/query/schema.hpp
+++ b/include/matador/query/schema.hpp
@@ -61,10 +61,10 @@ public:
   {}
 
   template<typename ValueType>
-  static void on_primary_key(const char * /*id*/, ValueType &/*value*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
+  static void on_primary_key(const char * /*id*/, ValueType &/*value*/, const utils::primary_key_attribute& /*attr*/) {}
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template<class Type>
-  static void on_attribute(const char * /*id*/, Type &/*value*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*value*/, const utils::field_attributes &/*attr*/) {}
   template<class Pointer>
   static void on_belongs_to(const char * /*id*/, Pointer & /*x*/, const utils::foreign_attributes &/*attr*/) {}
   template<class Pointer>
diff --git a/include/matador/query/select_query_builder.hpp b/include/matador/query/select_query_builder.hpp
index 6cf9c1a..ba859a1 100644
--- a/include/matador/query/select_query_builder.hpp
+++ b/include/matador/query/select_query_builder.hpp
@@ -90,7 +90,7 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/) {
     push(id);
     if (!is_root_entity()) {
       return;
@@ -101,7 +101,7 @@ public:
   void on_revision(const char *id, uint64_t &/*rev*/);
 
   template<typename Type>
-  void on_attribute(const char *id, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes)
+  void on_attribute(const char *id, Type &, const utils::field_attributes &/*attr*/)
   {
     push(id);
   }
diff --git a/include/matador/query/value_extractor.hpp b/include/matador/query/value_extractor.hpp
index d64b12e..61543ae 100644
--- a/include/matador/query/value_extractor.hpp
+++ b/include/matador/query/value_extractor.hpp
@@ -26,16 +26,16 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *, ValueType &x, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
+  void on_primary_key(const char *, ValueType &x, const utils::primary_key_attribute& attr) {
     utils::data_type_traits<ValueType>::bind_value(*this, 0, x, attr.size());
   }
   void on_revision(const char *id, uint64_t &rev);
   template < class Type >
-  void on_attribute(const char *, Type &x, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
+  void on_attribute(const char *, Type &x, const utils::field_attributes &/*attr*/) {
     utils::data_type_traits<Type>::bind_value(*this, 0, x);
   }
-  void on_attribute(const char *id, char *x, const utils::field_attributes &/*attr*/ = utils::null_attributes);
-  void on_attribute(const char *id, std::string &x, const utils::field_attributes &/*attr*/ = utils::null_attributes);
+  void on_attribute(const char *id, char *x, const utils::field_attributes &/*attr*/);
+  void on_attribute(const char *id, std::string &x, const utils::field_attributes &/*attr*/);
 
   template<class Type, template < class ... > class Pointer>
   void on_belongs_to(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/) {
diff --git a/include/matador/sql/generator.hpp b/include/matador/sql/generator.hpp
index 316cedc..e3fc989 100644
--- a/include/matador/sql/generator.hpp
+++ b/include/matador/sql/generator.hpp
@@ -45,7 +45,7 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/) {
       if (has_many_to_many_) {
           return;
       }
@@ -54,7 +54,7 @@ public:
   void on_revision(const char *id, uint64_t &/*rev*/);
 
   template<typename Type>
-  void on_attribute(const char *id, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
+  void on_attribute(const char *id, Type &, const utils::field_attributes &/*attr*/) {
       if (has_many_to_many_) {
           return;
       }
diff --git a/include/matador/sql/internal/identifier_reader.hpp b/include/matador/sql/internal/identifier_reader.hpp
index b95f013..c67e9c3 100644
--- a/include/matador/sql/internal/identifier_reader.hpp
+++ b/include/matador/sql/internal/identifier_reader.hpp
@@ -23,14 +23,14 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr) {
     utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_, value, attr.size());
     identifier_ = value;
   }
 
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template < class Type >
-  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) {}
   template < class Pointer >
   static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
   template < class Pointer >
diff --git a/include/matador/sql/internal/object_result_binder.hpp b/include/matador/sql/internal/object_result_binder.hpp
index 32a463c..6a16587 100644
--- a/include/matador/sql/internal/object_result_binder.hpp
+++ b/include/matador/sql/internal/object_result_binder.hpp
@@ -28,21 +28,21 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
+  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr);
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
 
   template < class Type >
-  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) {}
   template < class Pointer >
-  static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+  static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
   template < class Pointer >
-  static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+  static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
 
   template<class ContainerType>
   static void on_has_many(const char * /*id*/,
                           ContainerType &/*c*/,
                           const char * /*join_column*/,
-                          const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+                          const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
   static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
@@ -74,32 +74,32 @@ public:
   void reset();
 
   template < class Type >
-  void on_primary_key(const char *id, Type &val, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, Type &val, const utils::primary_key_attribute& attr) {
     utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val, attr.size());
   }
   void on_revision(const char *id, uint64_t &/*rev*/);
 
   template<typename Type>
-  void on_attribute(const char *id, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
+  void on_attribute(const char *id, Type &val, const utils::field_attributes &/*attr*/) {
     utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val);
   }
-  void on_attribute(const char *id, char *value, const utils::field_attributes &attr = utils::null_attributes);
-  void on_attribute(const char *id, std::string &value, const utils::field_attributes &attr = utils::null_attributes);
-  void on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr = utils::null_attributes);
+  void on_attribute(const char *id, char *value, const utils::field_attributes &attr);
+  void on_attribute(const char *id, std::string &value, const utils::field_attributes &attr);
+  void on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr);
 
   template<class Type, template < class ... > class Pointer>
-  void on_belongs_to(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {
+  void on_belongs_to(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/) {
     fk_result_binder_.bind(*x, id, index_++, *binder_);
   }
   template<class Type, template < class ... > class Pointer>
-  void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {
+  void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/) {
     fk_result_binder_.bind(*x, id, index_++, *binder_);
   }
   template<class ContainerType>
   static void on_has_many(const char * /*id*/,
                           ContainerType &/*c*/,
                           const char * /*join_column*/,
-                          const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+                          const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
   static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
diff --git a/include/matador/sql/internal/pk_reader.hpp b/include/matador/sql/internal/pk_reader.hpp
index b476a5f..32ab34a 100644
--- a/include/matador/sql/internal/pk_reader.hpp
+++ b/include/matador/sql/internal/pk_reader.hpp
@@ -15,13 +15,13 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
+  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr);
   void on_revision(const char * /*id*/, uint64_t &/*rev*/) {
     ++column_index_;
   }
 
   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*/, Type &/*x*/, const utils::field_attributes &/*attr*/) {
     ++column_index_;
   }
 
diff --git a/include/matador/sql/internal/query_result_impl.hpp b/include/matador/sql/internal/query_result_impl.hpp
index a7e5252..dabfd63 100644
--- a/include/matador/sql/internal/query_result_impl.hpp
+++ b/include/matador/sql/internal/query_result_impl.hpp
@@ -41,7 +41,7 @@ public:
                     size_t column_index = 0);
 
   template<typename ValueType>
-  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
+  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr) {
     utils::data_type_traits<ValueType>::read_value(*reader_, id, column_index_++, value, attr.size());
     if (type_stack_.size() == 1) {
       last_pk_ = current_pk_;
@@ -52,13 +52,13 @@ public:
   void on_revision(const char *id, uint64_t &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, Type &x, const utils::field_attributes &/*attr*/) {
     utils::data_type_traits<Type>::read_value(*reader_, id, column_index_++, x);
   }
 
-  void on_attribute(const char *id, char *value, const utils::field_attributes &attr = utils::null_attributes);
-  void on_attribute(const char *id, std::string &value, const utils::field_attributes &attr = utils::null_attributes);
-  void on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr = utils::null_attributes);
+  void on_attribute(const char *id, char *value, const utils::field_attributes &attr);
+  void on_attribute(const char *id, std::string &value, const utils::field_attributes &attr);
+  void on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr);
 
   template<class Pointer>
   void on_belongs_to(const char * /*id*/, Pointer &x, const utils::foreign_attributes &attr) {
diff --git a/include/matador/sql/internal/query_result_pk_resolver.hpp b/include/matador/sql/internal/query_result_pk_resolver.hpp
index 0c296a5..e3941f4 100644
--- a/include/matador/sql/internal/query_result_pk_resolver.hpp
+++ b/include/matador/sql/internal/query_result_pk_resolver.hpp
@@ -28,7 +28,7 @@ public:
     }
 
     template<typename ValueType>
-    void on_primary_key(const char *id, ValueType &/*value*/, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
+    void on_primary_key(const char *id, ValueType &/*value*/, const utils::primary_key_attribute& attr) {
         if (!type_stack_.empty()) {
             return;
         }
@@ -39,8 +39,8 @@ public:
     void on_revision(const char * /*id*/, uint64_t &/*rev*/) { ++column_index_; }
 
     template < class Type >
-    void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) { ++column_index_; }
-    void on_attribute(const char *id, const utils::value &x, const utils::field_attributes &attr = utils::null_attributes);
+    void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) { ++column_index_; }
+    void on_attribute(const char *id, const utils::value &x, const utils::field_attributes &attr);
 
     template < class Pointer >
     void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &attr) { on_foreign_key<typename Pointer::value_type>(attr.fetch() ); }
diff --git a/include/matador/sql/object_parameter_binder.hpp b/include/matador/sql/object_parameter_binder.hpp
index 0c1c3db..8bfd036 100644
--- a/include/matador/sql/object_parameter_binder.hpp
+++ b/include/matador/sql/object_parameter_binder.hpp
@@ -18,29 +18,29 @@ public:
   [[nodiscard]] size_t current_index() const;
 
   template < class Type >
-  void on_primary_key(const char * /*id*/, Type &val, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
+  void on_primary_key(const char * /*id*/, Type &val, const utils::primary_key_attribute& attr) {
     utils::data_type_traits<Type>::bind_value(*binder_, index_++, val, attr.size());
   }
   void on_revision(const char *id, uint64_t &/*rev*/);
 
   template<typename Type>
-  void on_attribute(const char * /*id*/, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
+  void on_attribute(const char * /*id*/, Type &val, const utils::field_attributes &/*attr*/) {
     utils::data_type_traits<Type>::bind_value(*binder_, index_++, val);
   }
 
   template<class Type, template < class ... > class Pointer>
-  void on_belongs_to(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {
+  void on_belongs_to(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/) {
     pk_binder_.bind(*x, index_++, *binder_);
   }
   template<class Type, template < class ... > class Pointer>
-  void on_has_one(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {
+  void on_has_one(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/) {
     pk_binder_.bind(*x, index_++, *binder_);
   }
   template<class ContainerType>
   static void on_has_many(const char * /*id*/,
                           ContainerType &/*c*/,
                           const char * /*join_column*/,
-                          const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+                          const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
   static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
diff --git a/include/matador/sql/object_pk_binder.hpp b/include/matador/sql/object_pk_binder.hpp
index 32e4f62..eb23601 100644
--- a/include/matador/sql/object_pk_binder.hpp
+++ b/include/matador/sql/object_pk_binder.hpp
@@ -20,21 +20,21 @@ public:
     }
 
     template<typename ValueType>
-    void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
+    void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr);
     static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
 
     template < class Type >
-    static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+    static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) {}
     template < class Pointer >
-    static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+    static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
     template < class Pointer >
-    static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+    static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
 
     template<class ContainerType>
     static void on_has_many(const char * /*id*/,
                             ContainerType &/*c*/,
                             const char * /*join_column*/,
-                            const utils::foreign_attributes &/*attr*/ = utils::CascadeNoneFetchLazy) {}
+                            const utils::foreign_attributes &/*attr*/) {}
     template<class ContainerType>
     static void on_has_many_to_many(const char * /*id*/,
                                     ContainerType &/*c*/,
diff --git a/include/matador/utils/access.hpp b/include/matador/utils/access.hpp
index df38974..7034fcf 100644
--- a/include/matador/utils/access.hpp
+++ b/include/matador/utils/access.hpp
@@ -1,7 +1,10 @@
 #ifndef OOS_ACCESS_HPP
 #define OOS_ACCESS_HPP
 
-#include <cstdint>
+#include "matador/utils/primary_key_attribute.hpp"
+#include "matador/utils/field_attributes.hpp"
+#include "matador/utils/foreign_attributes.hpp"
+
 #include <optional>
 
 namespace matador {
@@ -29,108 +32,66 @@ template<class Base, class Derived, class Operator>
 void process_base(Operator &op, const Derived &object) {
   static_assert(!std::is_same_v<Base, Derived>, "class Base must not be of same type as class Derived");
   static_assert(std::is_base_of_v<Base, Derived>, "class Base must be base of class Derived");
-  process(op, static_cast<const Base&>(object));
+  op.on_base(static_cast<const Base&>(object));
 }
 
 template<class Base, class Derived, class Operator>
 void process_base(Operator &op, Derived &object) {
   static_assert(!std::is_same_v<Base, Derived>, "class Base must not be of same type as class Derived");
   static_assert(std::is_base_of_v<Base, Derived>, "class Base must be base of class Derived");
-  process(op, static_cast<Base&>(object));
+  op.on_base(static_cast<Base&>(object));
 }
 
 template< class Operator, class Type >
-void primary_key(Operator &op, const char *id, Type &value, const utils::primary_key_attribute &attr) {
+void primary_key(Operator &op, const char *id, Type &value, const utils::primary_key_attribute &attr = utils::DefaultPkAttributes) {
   op.on_primary_key(id, value, attr);
 }
 
-template< class Operator, class Type >
-void primary_key(Operator &op, const char *id, Type &value) {
-  op.on_primary_key(id, value);
-}
-
 template<class Operator>
 void revision(Operator &op, const char *id, uint64_t &value) {
   op.on_revision(id, value);
 }
 
 template<class Operator, class Type>
-void attribute(Operator &op, const char *id, Type &value, const utils::field_attributes &attr) {
+void attribute(Operator &op, const char *id, Type &value, const utils::field_attributes &attr = utils::NullAttributes) {
   op.on_attribute(id, value, attr);
 }
 
 template<class Operator, class Type>
-void attribute(Operator &op, const char *id, std::optional<Type> &value, const utils::field_attributes &attr) {
+void attribute(Operator &op, const char *id, std::optional<Type> &value, const utils::field_attributes &attr = utils::NullAttributes) {
   op.on_attribute(id, value, attr);
 }
 
 template<class Operator, class Type>
-void attribute(Operator &op, const char *id, Type &value) {
-  op.on_attribute(id, value);
-}
-
-template<class Operator, class Type>
-void has_one(Operator &op, const char *id, Type &value, const utils::foreign_attributes &attr) {
+void has_one(Operator &op, const char *id, Type &value, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
   op.on_has_one(id, value, attr);
 }
 
 template<class Operator, class Type>
-void has_one(Operator &op, const char *id, Type &value) {
-  op.on_has_one(id, value);
-}
-
-template<class Operator, class Type>
-void belongs_to(Operator &op, const char *id, Type &value, const utils::foreign_attributes &attr) {
+void belongs_to(Operator &op, const char *id, Type &value, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
   op.on_belongs_to(id, value, attr);
 }
 
-template<class Operator, class Type>
-void belongs_to(Operator &op, const char *id, Type &value) {
-  op.on_belongs_to(id, value);
-}
-
 template<class Operator, class Type, template<class ...> class ContainerType>
-void has_many(Operator &op, const char *id, ContainerType<Type> &c, const char *join_column, const utils::foreign_attributes &attr) {
+void has_many(Operator &op, const char *id, ContainerType<Type> &c, const char *join_column, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
   op.on_has_many(id, c, join_column, attr);
 }
 
 template<class Operator, class Type, template<class ...> class ContainerType>
-void has_many(Operator &op, const char *id, ContainerType<Type> &c, const char *join_column) {
-  op.on_has_many(id, c, join_column);
-}
-
-template<class Operator, class Type, template<class ...> class ContainerType>
-void has_many(Operator &op, const char *id, ContainerType<Type> &c, const utils::foreign_attributes &attr) {
+void has_many(Operator &op, const char *id, ContainerType<Type> &c, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
   op.on_has_many(id, c, attr);
 }
 
-template<class Operator, class Type, template<class ...> class ContainerType>
-void has_many(Operator &op, const char *id, ContainerType<Type> &c) {
-  op.on_has_many(id, c);
-}
-
 template<class Operator, class ContainerType>
-void has_many_to_many(Operator &op, const char *id, ContainerType &c, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr) {
+void has_many_to_many(Operator &op, const char *id, ContainerType &c, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
   op.on_has_many_to_many(id, c, join_column, inverse_join_column, attr);
 }
 
 template<class Operator, class ContainerType>
-void has_many_to_many(Operator &op, const char *id, ContainerType &c, const char *join_column, const char *inverse_join_column) {
-  op.on_has_many_to_many(id, c, join_column, inverse_join_column);
-}
-
-template<class Operator, class ContainerType>
-void has_many_to_many(Operator &op, const char *id, ContainerType &c, const utils::foreign_attributes &attr) {
+void has_many_to_many(Operator &op, const char *id, ContainerType &c, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
   op.on_has_many_to_many(id, c, attr);
 }
-
-template<class Operator, class ContainerType>
-void has_many_to_many(Operator &op, const char *id, ContainerType &c) {
-  op.on_has_many_to_many(id, c);
 }
-
-}
-
 }
 
 #endif //OOS_ACCESS_HPP
diff --git a/include/matador/utils/field_attributes.hpp b/include/matador/utils/field_attributes.hpp
index 6076c59..be8ccd0 100644
--- a/include/matador/utils/field_attributes.hpp
+++ b/include/matador/utils/field_attributes.hpp
@@ -74,7 +74,7 @@ private:
   constraints options_ = constraints::None;
 };
 
-const field_attributes null_attributes {};
+const field_attributes NullAttributes {};
 
 }
 #endif //MATADOR_FIELD_ATTRIBUTES_HPP
diff --git a/include/matador/utils/primary_key_accessor.hpp b/include/matador/utils/primary_key_accessor.hpp
index 113213f..6333a33 100644
--- a/include/matador/utils/primary_key_accessor.hpp
+++ b/include/matador/utils/primary_key_accessor.hpp
@@ -22,7 +22,7 @@ public:
   }
 
   template<typename PrimaryKeyType>
-  void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = default_pk_attributes) {
+  void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = DefaultPkAttributes) {
     const auto value = pk_.as<PrimaryKeyType>();
     if (!value) {
       // Todo: throw error
@@ -32,7 +32,7 @@ public:
   }
   static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
   template<typename T>
-  static void on_attribute(const char * /*id*/, T &, const field_attributes & = null_attributes) {}
+  static void on_attribute(const char * /*id*/, T &, const field_attributes & = NullAttributes) {}
   template<class P>
   static void on_belongs_to(const char * /*id*/, P &, const foreign_attributes & ) {}
   template<class P>
@@ -52,12 +52,12 @@ struct pk_unset_checker {
   bool unset{true};
 
   template<class PrimaryKeyType>
-  void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = default_pk_attributes) {
+  void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = DefaultPkAttributes) {
     unset = !identifier_type_traits<PrimaryKeyType>::is_valid(pk);
   }
   static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
   template<typename T>
-  static void on_attribute(const char * /*id*/, T &, const field_attributes & = null_attributes) {}
+  static void on_attribute(const char * /*id*/, T &, const field_attributes & = NullAttributes) {}
   template<class P>
   static void on_belongs_to(const char * /*id*/, P &, const foreign_attributes & ) {}
   template<class P>
@@ -74,12 +74,12 @@ struct primary_key_getter {
   std::uint64_t value{0};
 
   template<class PrimaryKeyType>
-  void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = default_pk_attributes) {
+  void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = DefaultPkAttributes) {
     pk_ = pk;
   }
   static void on_revision(const char * /*id*/, uint64_t & /*rev*/) {}
   template<typename T>
-  static void on_attribute(const char * /*id*/, T &, const field_attributes & = null_attributes) {}
+  static void on_attribute(const char * /*id*/, T &, const field_attributes & = NullAttributes) {}
   template<class P>
   static void on_belongs_to(const char * /*id*/, P &, const foreign_attributes & ) {}
   template<class P>
diff --git a/include/matador/utils/primary_key_attribute.hpp b/include/matador/utils/primary_key_attribute.hpp
index 42f5154..7d6159c 100644
--- a/include/matador/utils/primary_key_attribute.hpp
+++ b/include/matador/utils/primary_key_attribute.hpp
@@ -47,7 +47,7 @@ private:
   generator_type generator_ = generator_type::Manual;
 };
 
-const primary_key_attribute default_pk_attributes {};
+const primary_key_attribute DefaultPkAttributes {};
 
 }
 #endif //PRIMARY_KEY_ATTRIBUTE_HPP
diff --git a/source/core/object/object_generator.cpp b/source/core/object/object_generator.cpp
index 72f3580..531b083 100644
--- a/source/core/object/object_generator.cpp
+++ b/source/core/object/object_generator.cpp
@@ -21,7 +21,7 @@ std::shared_ptr<object> object_generator::acquire_object(basic_repository &repo,
 }
 
 void object_generator::on_revision(const char* id, uint64_t& rev) {
-  on_attribute(id, rev);
+    access::attribute(*this, id, rev);
 }
 
 void object_generator::create_pk_constraint(const std::string& name) const {
diff --git a/test/models/coordinate.hpp b/test/models/coordinate.hpp
index f8d2633..a41f007 100644
--- a/test/models/coordinate.hpp
+++ b/test/models/coordinate.hpp
@@ -14,7 +14,7 @@ struct coordinate {
 
 namespace matador::access {
 template<class Operator>
-void attribute(Operator &op, const char *id, test::coordinate &value, const utils::field_attributes &attr = utils::null_attributes) {
+void attribute(Operator &op, const char *id, test::coordinate &value, const utils::field_attributes &attr = utils::NullAttributes) {
   attribute(op, (std::string(id) + "_x").c_str(), value.x, attr);
   attribute(op, (std::string(id) + "_y").c_str(), value.y, attr);
   attribute(op, (std::string(id) + "_z").c_str(), value.z, attr);