Potential Bug in Bulk Persist template (libodb/odb/database.ixx)

[N40]

When attempting to use the new bulk persist mechanism, I stumpled upon a potential bug or at least something I do not understand

In ibodb/odb/database.ixx:741

the
persist_ <typename I, database_id DB>
method calls the
persist_<I, typename opt::object_type, id_common>
method.

Inside of the latter one (within database.txx) is
object_traits_impl<object_type, DB>::batch
referenced.
This one NEVER exists for DB = id_common. Only for id_pgsql etc.
So AFAIK the code in database.ixx is broken and line 741 should be
persist_<I, typename opt::object_type, DB >

Or did I misunderstand something?

[boris-kolpackov]

Does this bug lead to any compilation errors for you? If so, could you describe your setup, specifically, how you invoke the ODB compiler?

[N40]

Setup

-- compiler  AppleClang 17.0.0
-- cmake     3.30.5
-- odb       2.5.0

General compile command is

odb
    --multi-database dynamic -d sqlite -d pgsq -d common
    --generate-query --generate-session --generate-schema
    --std c++17
    <REGEX_FLAGS>
    <FILE_SUFFIX_FLAGS>
    <INCLUDES>
HEADER.h

Compile error

In file included from /usr/local/include/odb/database.hxx:653:
/usr/local/include/odb/database.txx:182:68: error: no member named 'batch' in 'odb::object_traits_impl<CLASS, odb::id_common>'
  182 |         typename persist_type<object_type>::type* a[object_traits::batch];
      |                                                     ~~~~~~~~~~~~~~~^
/usr/local/include/odb/database.ixx:741:5: note: in instantiation of function template specialization 'odb::database::persist_<std::__wrap_iter<const std::shared_ptr<const CLASS> *>, const CLASS, odb::id_common>' requested here
  741 |     persist_<I, typename opt::object_type, id_common> (

Edit:

compiling the headers with odb works fine.
I get the error above when trying to compile my project including the odb-created output

[boris-kolpackov]

Hm, my understanding is that this code is only instantiated if you call the persist(I begin, I end) version of persist(), which, per the documentation, is only available if bulk operations are enabled for the object. Can you confirm whether your code calls this version of persist()? In fact, the complete diagnostics that you get with all the "instantiated from..." lines would be helpful.

[N40]

/usr/local/include/odb/database.txx:182:68: error: no member named 'batch' in 'odb::object_traits_impl<MyClass, odb::id_common>'
  182 |         typename persist_type<object_type>::type* a[object_traits::batch];
      |                                                     ~~~~~~~~~~~~~~~^
/usr/local/include/odb/database.ixx:741:5: note: in instantiation of function template specialization 'odb::database::persist_<std::__wrap_iter<std::shared_ptr<const MyClass> *>, const MyClass, odb::id_common>' requested here
  741 |     persist_<I, typename opt::object_type, id_common> (
      |     ^
/usr/local/include/odb/pgsql/database.ixx:126:7: note: in instantiation of function template specialization 'odb::database::persist_<std::__wrap_iter<std::shared_ptr<const MyClass> *>, odb::id_pgsql>' requested here
  126 |       persist_<I, id_pgsql> (b, e, cont);
      |       ^
MySource.cpp: note: in instantiation of function template specialization 'odb::pgsql::database::persist<std::__wrap_iter<std::shared_ptr<const MyClass> *>>' requested here
   52 |         db->persist(v.begin(), v.end());

My remark is a theoretical one:

• database::persist_ (I b, I e, bool cont, details::meta::no /*ptr*/) (database.txx:78) is protected, so it must be called from somewhere
• The latter one is for all DBs
• It is the only bulk persist implementation template
• !!! The only place calling this template is hard coding id_common
• within the odb binary code I only find generator code for batch for oracle, pgsql and mysql.
  -> So I come to the deduced conclusion that the persist_(b, e) template can NEVER work.

[boris-kolpackov]

When the ODB compiler is invoked in the single-database mode (i.e., the --multi-database option is not specified), template specialization with id_common are made to derive from those for concrete databases (e.g., PostgreSQL) rather than being a dispatcher layer as in the dynamic multi-database support. This is why the persits_() implementation that you are seeing works.

Per the documentation (second paragraph):

There is also currently no emulation of the bulk API for other databases nor dynamic multi-database support.

The reason the seemingly invalid (in this mode) persist_() doesn't cause issues with dynamic multi-database support is that it is not instantiated unless you call one of the bulk-only API functions (like persist(I begin, I end)). Which you should not do, naturally.

[N40]

Thank you for your explanations!

Nevertheless I wonder why it would be against the design goal or not work to change database.ixx:741' to persist_<I, typename opt::object_type, DB>`.

[boris-kolpackov]

Nevertheless I wonder why it would be against the design goal or not work to change database.ixx:741 to persist_<I, typename opt::object_type, DB>.

Hard to say, I don't remember exactly why I hardcoded id_common there, but it could be to prevent things from compiling in the dynamic multi-database mode since it instead could end up failing at runtime or some such.

I guess the question is what are you trying to achieve here? Do you want to make dynamic multi-database work with bulk operations? If so, then the approach should be to understand how things would work end-to-end and all the part that will need changing.