Removed fallback to Boost.PFR for query views

sqlite_orm's policy is to provide an API without external dependencies (even if implicit).

Author: trueqbit

dev/functional/config.h

@@ -4,7 +4,6 @@
 #include "platform_definitions.h"
 // pull in SQLite3 configuration early, such that version and feature macros are globally available in sqlite_orm
 #include "sqlite3_config.h"
-#include "pfr_config.h"
 
 #ifdef BUILD_SQLITE_ORM_MODULE
 #define SQLITE_ORM_EXPORT export
@@ -87,10 +86,7 @@
 
 #define SQLITE_ORM_WITH_CTE
 
-// note: PFR depends on `SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED` for field name determination
-#if (defined(SQLITE_ORM_CONSTEVAL_SUPPORTED) && defined(SQLITE_ORM_CLASSTYPE_TEMPLATE_ARGS_SUPPORTED)) &&              \
-    (defined(SQLITE_ORM_CPP20_CONCEPTS_SUPPORTED)) && (__cpp_lib_byte >= 201603L) &&                                   \
-    (defined(SQLITE_ORM_REFLECTION_SUPPORTED) || BOOST_PFR_ENABLED == 1)
+#if defined(SQLITE_ORM_REFLECTION_SUPPORTED)
 #define SQLITE_ORM_WITH_VIEW
 #endif
 

dev/functional/meta_util.h

@@ -3,7 +3,7 @@
 #ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #ifdef SQLITE_ORM_REFLECTION_SUPPORTED
 #include <meta>  //  std::meta::access_context, std::meta::nonstatic_data_members_of, std::meta::identifier_of
-#include <tuple>  //  std::tuple, std::get
+#include <tuple>  //  std::tuple
 #include <utility>  //  std::index_sequence, std::make_index_sequence
 #endif
 #endif

dev/functional/pfr_config.h

@@ -4,9 +4,6 @@
 #ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <type_traits>  //  std::is_member_object_pointer
 #include <utility>  //  std::move
-#if defined(SQLITE_ORM_WITH_VIEW) && (BOOST_PFR_ENABLED == 1)
-#include <cstddef>  //  std::byte
-#endif
 #endif
 
 #include "functional/gsl.h"
@@ -45,20 +42,6 @@ namespace sqlite_orm::internal {
                 (object.*column.setter)(std::move(value));
             };
         }
-
-#if defined(SQLITE_ORM_WITH_VIEW) && (BOOST_PFR_ENABLED == 1)
-        template<class C>
-            requires (is_column_pointer_v<C>)
-        void operator()(const column_field<C, empty_setter>& column) {
-            using field_type = field_type_t<column_field<C, empty_setter>>;
-            const auto rowExtractor = row_value_extractor<field_type>();
-            auto value = rowExtractor.extract(this->stmt, ++this->columnIndex);
-            // calculate absolute address of member from relative address
-            const std::byte* fieldAddress = (std::byte*)(uintptr_t(&object) + size_t(column.member_pointer.field));
-            field_type* field = (field_type*)fieldAddress;
-            *field = std::move(value);
-        }
-#endif
     };
 
     /**

dev/object_from_column_builder.h

@@ -4,15 +4,6 @@
 #ifdef SQLITE_ORM_WITH_VIEW
 #include <type_traits>  //  std::remove_cvref
 #include <utility>  // std::forward, std::move, std::index_sequence, std::make_index_sequence
-#include <cstddef>  //  std::byte
-#endif
-#endif
-
-#ifdef SQLITE_ORM_WITH_VIEW
-#ifndef SQLITE_ORM_REFLECTION_SUPPORTED
-#ifdef SQLITE_ORM_HAS_BOOST_PFR
-#include <boost/pfr.hpp>
-#endif
 #endif
 #endif
 
@@ -23,47 +14,6 @@
 #include "column.h"
 #include "table_base.h"
 
-#ifdef SQLITE_ORM_WITH_VIEW
-#ifdef SQLITE_ORM_REFLECTION_SUPPORTED
-#elif BOOST_PFR_ENABLED == 1
-namespace boost::pfr {
-    namespace detail {
-        namespace sequence_tuple {
-            template<std::size_t N, class W>
-            consteval auto get_nth_base(const base_from_member<N, W>& t) noexcept {
-                // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-                return t;
-            }
-
-            template<std::size_t N, class Tpl>
-            constexpr auto* get_nth_relative_address() noexcept {
-                // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
-                static_assert(N < Tpl::size_v);
-                using nth_type = decltype(get_nth_base<N>(std::declval<Tpl>()));
-                using field_type = decltype(nth_type::value);
-
-                return (field_type*)(std::byte*)
-                    // offsetof - the official one cannot be used because of some implementations using the compiler intrinsic builtin
-                    ((std::size_t)&reinterpret_cast<char const volatile&>((((Tpl*)0)->nth_type::value)));
-            }
-        }
-    }
-
-    template<class O, std::size_t I, class TS>
-    constexpr auto* get_relative_address() {
-        static_assert(sizeof(O) == sizeof(TS),
-                      "====================> Boost.PFR: Member sequence does not indicate correct size for struct "
-                      "type! Maybe the user-provided type is not a SimpleAggregate?");
-        static_assert(
-            alignof(O) == alignof(TS),
-            "====================> Boost.PFR: Member sequence does not indicate correct alignment for struct type!");
-
-        return detail::sequence_tuple::get_nth_relative_address<I, TS>();
-    }
-}
-#endif
-#endif
-
 namespace sqlite_orm::internal {
 #ifdef SQLITE_ORM_WITH_VIEW
     /**
@@ -93,7 +43,7 @@ namespace sqlite_orm::internal {
 #ifdef SQLITE_ORM_WITH_VIEW
 #ifdef SQLITE_ORM_REFLECTION_SUPPORTED
 namespace sqlite_orm::internal {
-    template<class O, class Select, std::size_t... I>
+    template<class O, class Select, size_t... I>
     auto make_view(std::string name, std::index_sequence<I...>, Select select) {
         constexpr auto memberNames = extract_member_names<O>();
         constexpr auto memberPointers = extract_member_pointers<O>();
@@ -110,107 +60,12 @@ namespace sqlite_orm::internal {
 }
 
 SQLITE_ORM_EXPORT namespace sqlite_orm {
-    template<class O, class Select>
-        requires (internal::is_select_expression_v<Select>)
-    auto make_view(std::string name, Select select) {
-        using namespace ::sqlite_orm::internal;
-
-        if constexpr (is_select_v<Select>) {
-            select.highest_level = true;
-        }
-        return internal::make_view<O>(std::move(name),
-                                      std::make_index_sequence<count_members<O>()>{},
-                                      std::move(select));
-    }
-}
-#elif BOOST_PFR_ENABLED == 1
-namespace sqlite_orm::internal {
     /**
-     *  Factory function for a column definition from a relative pointer to an object of the object to be mapped.
-     */
-    template<class C, class... Op>
-        requires (internal::is_column_pointer_v<C>)
-    internal::column_t<C, internal::empty_setter, Op...>
-    make_column(std::string name, C relativeField, Op... constraints) {
-        static_assert(polyfill::conjunction_v<internal::is_column_constraint<Op>...>, "Incorrect constraints pack");
-
-        // attention: do not use `std::make_tuple()` for constructing the tuple member `[[no_unique_address]] column_constraints::constraints`,
-        // as this will lead to UB with Clang on MinGW!
-        return {std::move(name), relativeField, {}, std::tuple<Op...>{std::move(constraints)...}};
-    }
-
-    /*  
-     *  A column field carrying a relative address to a member of an object.
+     *  Factory function for a view definition.
      *  
-     *  Internal note: According to my tests msvc or compilers in general have a hard time to use pointer-to-members at compile-time.
-     *  That's why we use a relative address.
+     *  The mapped object type is explicitly specified, columns and their names are deferred from the object type.
+     *  The object type must be an aggregate.
      */
-    template<class O, class F>
-    struct column_field<column_pointer<O, F*>, empty_setter> {
-        using member_pointer_t = F O::*;
-        using setter_type = empty_setter;
-        using object_type = O;
-        using field_type = F;
-
-        /**
-         *  Relative pointer to member (offset) used to read and write a field value.
-         */
-        const column_pointer<O, F*> member_pointer;
-
-        SQLITE_ORM_NOUNIQUEADDRESS
-        const empty_setter setter;
-
-        /**
-         *  Simplified interface for `NOT NULL` constraint
-         */
-        constexpr bool is_not_null() const {
-            return !type_is_nullable<field_type>::value;
-        }
-    };
-
-    template<class O, class F>
-    bool compare_fields(F O::* m, const column_pointer<O, F*>& relative) {
-        constexpr O* object = nullptr;
-        return &(object->*m) == relative.field;
-    }
-
-    template<class O, class F>
-    bool compare_fields(const column_pointer<O, F*>& relative, F O::* m) {
-        constexpr O* object = nullptr;
-        return relative.field == &(object->*m);
-    }
-
-    template<class O, size_t... I, class Select>
-    auto make_view(std::string name, std::index_sequence<I...>, Select select) {
-        namespace pfr = boost::pfr;
-        namespace pfrd = pfr::detail;
-        namespace pfrs = pfrd::sequence_tuple;
-
-#if __cpp_lib_is_aggregate >= 201703L
-        static_assert(std::is_aggregate_v<O>);
-#endif
-
-        using PfrTpl = decltype(pfrd::tie_as_tuple(pfrd::fake_object<O>()));
-        // object's member types as a tuple
-        using TS = pfrs::tuple<polyfill::remove_cvref_t<typename pfrs::tuple_element<I, PfrTpl>::type>...>;
-
-        using view_type = query_view<O,
-                                     Select,
-                                     decltype(internal::make_column<>(
-                                         std::string(pfr::get_name<I, O>()),
-                                         column_pointer<O, decltype(pfr::get_relative_address<O, I, TS>())>{
-                                             pfr::get_relative_address<O, I, TS>()}))...>;
-
-        return view_type{
-            std::move(name),
-            std::tuple{internal::make_column<>(std::string(pfr::get_name<I, O>()),
-                                               column_pointer<O, decltype(pfr::get_relative_address<O, I, TS>())>{
-                                                   pfr::get_relative_address<O, I, TS>()})...},
-            std::move(select)};
-    }
-}
-
-SQLITE_ORM_EXPORT namespace sqlite_orm {
     template<class O, class Select>
         requires (internal::is_select_expression_v<Select>)
     auto make_view(std::string name, Select select) {
@@ -220,13 +75,10 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
             select.highest_level = true;
         }
         return internal::make_view<O>(std::move(name),
-                                      std::make_index_sequence<boost::pfr::tuple_size_v<O>>{},
+                                      std::make_index_sequence<count_members<O>()>{},
                                       std::move(select));
     }
-}
-#endif
 
-SQLITE_ORM_EXPORT namespace sqlite_orm {
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
     /**
      *  Factory function for a view definition.
@@ -241,3 +93,4 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
 #endif
 }
 #endif
+#endif