odb/2.5.0-b.27

ODB is an object-relational mapping (ORM) system for C++. It provides
tools, APIs, and library support that allow you to persist C++ objects
to a relational database (RDBMS) without having to deal with tables,
columns, or SQL and without manually writing any of the mapping code.
For more information see:

http://www.codesynthesis.com/products/odb/

This package contains the ODB compiler and the ODB system documentation.

See the NEWS file for the user-visible changes from the previous release.

See... More

Version 2.5.0

 * Support for mapping C++ types as other C++ types. For example:

   #pragma db map type(bool) as(std::string) \
     to((?) ? "true" : "false") from((?) == "true")

   @@ Ref to the manual.

 * Support for custom table definition options in addition to column
   definition options. For details, refer to Section 14.1.16, "options" in
   the ODB manual.

 * Support for nested object ids. Now the 'id' pragma specifier can optionally
   include the data member path to the id inside a composite value. For
   example:

   #pragma db id(first)
   std::pair<int, int> p;

   Note that one somewhat counter-intuitive aspect of this new feature is
   that the whole member marked with id ('p' in the above example) and not
   just the actual id member ('p.first' in the above example) is treated as
   readonly.

   Such nested id also cannot be automatically assigned ('auto' specifier).

 * Support for defining views as instantiations of C++ class templates,
   similar to objects and composite value types.

 * Allow the use of object pointers as map keys. Also remove the restriction
   for map keys and set values to be NOT NULL.

 * New 'points_to' pragma allows the establishment of relationship without
   using object pointers.

 * The 'inverse' pragma now supports nested data members.

 * Helper header (<odb/nested-container.hxx>) for nested container emulation.
   It is still fairly experimental and only supports vector<vector<T>>. For
   example:

   #include <odb/nested-container.hxx>

   #pragma db object
   class package
   {
     using licenses_type = std::vector<std::string>
     using license_alternatives_type = std::vector<licenses_type>

     license_alternatives_type license_alternatives;

     // Database mapping.
     //
     using _license_key = odb::nested_key<licenses_type>;
     using _licenses_type = std::map<_license_key, std::string>;

     #pragma db value(_license_key)
     #pragma db member(_license_key::outer) column("alternative_index")
     #pragma db member(_license_key::inner) column("index")

     #pragma db member(license_alternatives) id_column("") value_column("")
     #pragma db member(licenses)                                       \
       virtual(_licenses_type)                                         \
       after(license_alternatives)                                     \
       get(odb::nested_get (this.license_alternatives))                \
       set(odb::nested_set (this.license_alternatives, std::move (?))) \
       id_column("") key_column("") value_column("license")
   };

 * Database classes are now move-constructible. This means they can be
   returned by value from a function in C++11.

 * Support for bulk operations in PostgreSQL 14 using the new pipeline mode.
   For details on bulk operations see Section 15.3, "Bulk Database Operations"
   in the ODB manual. Note that while this functionality requires libpq
   version 14 or later, it should be usable with PostgreSQL servers version
   7.4 or later. The development of this support was sponsored by Qube
   Research & Technologies Limited.

 * Support for SQLite ATTACH DATABASE. Attached databases are represented as
   special odb::sqlite::database instances. @@ TODO: doc ref.

 * Support for SQLite incremental BLOB/TEXT I/O (the sqlite3_blob_open()
   functionality). For details, refer to Section 18.1.3, "Incremental
   BLOB/TEXT I/O" in the ODB manual.

 * In PostgreSQL a SELECT statement in a view that is prefixed with the
   /*CALL*/ comment is recognized and handled as a stored procedure call.

 * Due to warnings issued by some compiler, std::auto_ptr is no longer mapped
   as an object pointer or wrapper in the C++11 mode. Use std::unique_ptr
   instead.

Version 2.4.0

 * Support for object loading views. Object loading views allow loading of
   one or more complete objects instead of, or in addition to, a subset of
   data members and with a single SELECT statement execution. For details,
   refer to Section 10.2, "Object Loading Views" in the ODB manual.

 * Support for bulk operations in Oracle and SQL Server. Bulk operations
   persist, update, or erase a range of objects using a single database
   statement execution which often translates to a significantly better
   performance. For details, refer to Section 15.3, "Bulk Database
   Operations" in the ODB manual.

 * New database class functions, query_one() and query_value(), provide
   convenient shortcuts for situations where the query is known to return
   at most one element (query_one) or exactly one element (query_value).
   Corresponding execute_one() and execute_value() functions for prepared
   queries are also provided. For details, refer to Sections 4.3, "Executing
   a Query" and 4.5, "Prepared Queries" in the ODB manual.

 * Support for defining persistent objects as instantiations of C++ class
   templates, similar to composite value types. For details, refer to
   Section 15.2, "Persistent Class Template Instantiations" in the... More