diff options
Diffstat (limited to 'libbrep/package-odb.cxx')
| -rw-r--r-- | libbrep/package-odb.cxx | 14202 |
1 files changed, 14202 insertions, 0 deletions
diff --git a/libbrep/package-odb.cxx b/libbrep/package-odb.cxx new file mode 100644 index 0000000..a75d5af --- /dev/null +++ b/libbrep/package-odb.cxx @@ -0,0 +1,14202 @@ +// -*- C++ -*- +// +// This file was generated by ODB, object-relational mapping (ORM) +// compiler for C++. +// + +#include <odb/pre.hxx> + +#include <libbrep/package-odb.hxx> + +#include <cassert> +#include <cstring> // std::memcpy + +#include <odb/schema-catalog-impl.hxx> + +#include <odb/pgsql/traits.hxx> +#include <odb/pgsql/database.hxx> +#include <odb/pgsql/transaction.hxx> +#include <odb/pgsql/connection.hxx> +#include <odb/pgsql/statement.hxx> +#include <odb/pgsql/statement-cache.hxx> +#include <odb/pgsql/simple-object-statements.hxx> +#include <odb/pgsql/view-statements.hxx> +#include <odb/pgsql/section-statements.hxx> +#include <odb/pgsql/container-statements.hxx> +#include <odb/pgsql/exceptions.hxx> +#include <odb/pgsql/prepared-query.hxx> +#include <odb/pgsql/simple-object-result.hxx> +#include <odb/pgsql/view-result.hxx> + +namespace odb +{ + // priority + // + + bool access::composite_value_traits< ::bpkg::priority, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // value + // + t[0UL] = 0; + + // comment + // + if (t[1UL]) + { + i.comment_value.capacity (i.comment_size); + grew = true; + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::priority, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // value + // + b[n].type = pgsql::bind::integer; + b[n].buffer = &i.value_value; + b[n].is_null = &i.value_null; + n++; + + // comment + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.comment_value.data (); + b[n].capacity = i.comment_value.capacity (); + b[n].size = &i.comment_size; + b[n].is_null = &i.comment_null; + n++; + } + + bool access::composite_value_traits< ::bpkg::priority, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // value + // + { + ::bpkg::priority::value_type const& v = + o.value; + + bool is_null (false); + pgsql::value_traits< + ::bpkg::priority::value_type, + pgsql::id_integer >::set_image ( + i.value_value, is_null, v); + i.value_null = is_null; + } + + // comment + // + { + ::std::string const& v = + o.comment; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.comment_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.comment_value, + size, + is_null, + v); + i.comment_null = is_null; + i.comment_size = size; + grew = grew || (cap != i.comment_value.capacity ()); + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::priority, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // value + // + { + ::bpkg::priority::value_type& v = + o.value; + + pgsql::value_traits< + ::bpkg::priority::value_type, + pgsql::id_integer >::set_value ( + v, + i.value_value, + i.value_null); + } + + // comment + // + { + ::std::string& v = + o.comment; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.comment_value, + i.comment_size, + i.comment_null); + } + } + + // licenses + // + + bool access::composite_value_traits< ::bpkg::licenses, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // comment + // + if (t[0UL]) + { + i.comment_value.capacity (i.comment_size); + grew = true; + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::licenses, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // comment + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.comment_value.data (); + b[n].capacity = i.comment_value.capacity (); + b[n].size = &i.comment_size; + b[n].is_null = &i.comment_null; + n++; + } + + bool access::composite_value_traits< ::bpkg::licenses, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // comment + // + { + ::std::string const& v = + o.comment; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.comment_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.comment_value, + size, + is_null, + v); + i.comment_null = is_null; + i.comment_size = size; + grew = grew || (cap != i.comment_value.capacity ()); + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::licenses, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // comment + // + { + ::std::string& v = + o.comment; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.comment_value, + i.comment_size, + i.comment_null); + } + } + + // manifest_url + // + + bool access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // value + // + if (t[0UL]) + { + i.value_value.capacity (i.value_size); + grew = true; + } + + // comment + // + if (t[1UL]) + { + i.comment_value.capacity (i.comment_size); + grew = true; + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // value + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.value_value.data (); + b[n].capacity = i.value_value.capacity (); + b[n].size = &i.value_size; + b[n].is_null = &i.value_null; + n++; + + // comment + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.comment_value.data (); + b[n].capacity = i.comment_value.capacity (); + b[n].size = &i.comment_size; + b[n].is_null = &i.comment_null; + n++; + } + + bool access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // value + // + { + // From package.hxx:68:5 + ::std::string const& v = + o.string (); + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.value_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.value_value, + size, + is_null, + v); + i.value_null = is_null; + i.value_size = size; + grew = grew || (cap != i.value_value.capacity ()); + } + + // comment + // + { + ::std::string const& v = + o.comment; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.comment_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.comment_value, + size, + is_null, + v); + i.comment_null = is_null; + i.comment_size = size; + grew = grew || (cap != i.comment_value.capacity ()); + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // value + // + { + // From package.hxx:69:5 + ::std::string v; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.value_value, + i.value_size, + i.value_null); + + // From package.hxx:69:5 + o = brep::manifest_url ((v), ""); + } + + // comment + // + { + ::std::string& v = + o.comment; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.comment_value, + i.comment_size, + i.comment_null); + } + } + + // email + // + + bool access::composite_value_traits< ::bpkg::email, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // value + // + if (t[0UL]) + { + i.value_value.capacity (i.value_size); + grew = true; + } + + // comment + // + if (t[1UL]) + { + i.comment_value.capacity (i.comment_size); + grew = true; + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::email, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // value + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.value_value.data (); + b[n].capacity = i.value_value.capacity (); + b[n].size = &i.value_size; + b[n].is_null = &i.value_null; + n++; + + // comment + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.comment_value.data (); + b[n].capacity = i.comment_value.capacity (); + b[n].size = &i.comment_size; + b[n].is_null = &i.comment_null; + n++; + } + + bool access::composite_value_traits< ::bpkg::email, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // value + // + { + // From package.hxx:77:58 + ::std::string const& v = + o; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.value_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.value_value, + size, + is_null, + v); + i.value_null = is_null; + i.value_size = size; + grew = grew || (cap != i.value_value.capacity ()); + } + + // comment + // + { + ::std::string const& v = + o.comment; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.comment_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.comment_value, + size, + is_null, + v); + i.comment_null = is_null; + i.comment_size = size; + grew = grew || (cap != i.comment_value.capacity ()); + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::email, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // value + // + { + // From package.hxx:77:58 + ::std::string& v = + o; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.value_value, + i.value_size, + i.value_null); + } + + // comment + // + { + ::std::string& v = + o.comment; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.comment_value, + i.comment_size, + i.comment_null); + } + } + + // version_constraint + // + + bool access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // min_version + // + if (composite_value_traits< ::brep::_version, id_pgsql >::grow ( + i.min_version_value, t + 0UL)) + grew = true; + + // max_version + // + if (composite_value_traits< ::brep::_version, id_pgsql >::grow ( + i.max_version_value, t + 6UL)) + grew = true; + + // min_open + // + t[12UL] = 0; + + // max_open + // + t[13UL] = 0; + + return grew; + } + + void access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // min_version + // + composite_value_traits< ::brep::_version, id_pgsql >::bind ( + b + n, i.min_version_value, sk); + n += 6UL; + + // max_version + // + composite_value_traits< ::brep::_version, id_pgsql >::bind ( + b + n, i.max_version_value, sk); + n += 6UL; + + // min_open + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.min_open_value; + b[n].is_null = &i.min_open_null; + n++; + + // max_open + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.max_open_value; + b[n].is_null = &i.max_open_null; + n++; + } + + bool access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // min_version + // + { + ::butl::optional< ::bpkg::version > const& v = + o.min_version; + + // From common.hxx:75:12 + ::brep::_optional_version const& vt = + (v) ? brep::_version + { + (v)->epoch, (v)->canonical_upstream, (v)->canonical_release, (v)->revision, (v)->upstream, (v)->release + } : brep::_optional_version (); + + if (wrapper_traits< ::brep::_optional_version >::get_null (vt)) + composite_value_traits< ::brep::_version, id_pgsql >::set_null ( + i.min_version_value, sk); + else + { + const::brep::_version& vw = + wrapper_traits< ::brep::_optional_version >::get_ref (vt); + + if (composite_value_traits< ::brep::_version, id_pgsql >::init ( + i.min_version_value, + vw, + sk)) + grew = true; + } + } + + // max_version + // + { + ::butl::optional< ::bpkg::version > const& v = + o.max_version; + + // From common.hxx:75:12 + ::brep::_optional_version const& vt = + (v) ? brep::_version + { + (v)->epoch, (v)->canonical_upstream, (v)->canonical_release, (v)->revision, (v)->upstream, (v)->release + } : brep::_optional_version (); + + if (wrapper_traits< ::brep::_optional_version >::get_null (vt)) + composite_value_traits< ::brep::_version, id_pgsql >::set_null ( + i.max_version_value, sk); + else + { + const::brep::_version& vw = + wrapper_traits< ::brep::_optional_version >::get_ref (vt); + + if (composite_value_traits< ::brep::_version, id_pgsql >::init ( + i.max_version_value, + vw, + sk)) + grew = true; + } + } + + // min_open + // + { + bool const& v = + o.min_open; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.min_open_value, is_null, v); + i.min_open_null = is_null; + } + + // max_open + // + { + bool const& v = + o.max_open; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.max_open_value, is_null, v); + i.max_open_null = is_null; + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // min_version + // + { + ::butl::optional< ::bpkg::version >& v = + o.min_version; + + ::brep::_optional_version vt; + + if (composite_value_traits< ::brep::_version, id_pgsql >::get_null ( + i.min_version_value)) + wrapper_traits< ::brep::_optional_version >::set_null (vt); + else + { + ::brep::_version& vw = + wrapper_traits< ::brep::_optional_version >::set_ref (vt); + + composite_value_traits< ::brep::_version, id_pgsql >::init ( + vw, + i.min_version_value, + db); + } + + // From common.hxx:75:12 + v = (vt) ? bpkg::version ((vt)->epoch, std::move ((vt)->upstream), std::move ((vt)->release), (vt)->revision, 0) : brep::optional_version (); + } + + // max_version + // + { + ::butl::optional< ::bpkg::version >& v = + o.max_version; + + ::brep::_optional_version vt; + + if (composite_value_traits< ::brep::_version, id_pgsql >::get_null ( + i.max_version_value)) + wrapper_traits< ::brep::_optional_version >::set_null (vt); + else + { + ::brep::_version& vw = + wrapper_traits< ::brep::_optional_version >::set_ref (vt); + + composite_value_traits< ::brep::_version, id_pgsql >::init ( + vw, + i.max_version_value, + db); + } + + // From common.hxx:75:12 + v = (vt) ? bpkg::version ((vt)->epoch, std::move ((vt)->upstream), std::move ((vt)->release), (vt)->revision, 0) : brep::optional_version (); + } + + // min_open + // + { + bool& v = + o.min_open; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.min_open_value, + i.min_open_null); + } + + // max_open + // + { + bool& v = + o.max_open; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.max_open_value, + i.max_open_null); + } + } + + // requirement_alternatives + // + + bool access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // conditional + // + t[0UL] = 0; + + // buildtime + // + t[1UL] = 0; + + // comment + // + if (t[2UL]) + { + i.comment_value.capacity (i.comment_size); + grew = true; + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // conditional + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.conditional_value; + b[n].is_null = &i.conditional_null; + n++; + + // buildtime + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.buildtime_value; + b[n].is_null = &i.buildtime_null; + n++; + + // comment + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.comment_value.data (); + b[n].capacity = i.comment_value.capacity (); + b[n].size = &i.comment_size; + b[n].is_null = &i.comment_null; + n++; + } + + bool access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // conditional + // + { + bool const& v = + o.conditional; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.conditional_value, is_null, v); + i.conditional_null = is_null; + } + + // buildtime + // + { + bool const& v = + o.buildtime; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.buildtime_value, is_null, v); + i.buildtime_null = is_null; + } + + // comment + // + { + ::std::string const& v = + o.comment; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.comment_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.comment_value, + size, + is_null, + v); + i.comment_null = is_null; + i.comment_size = size; + grew = grew || (cap != i.comment_value.capacity ()); + } + + return grew; + } + + void access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // conditional + // + { + bool& v = + o.conditional; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.conditional_value, + i.conditional_null); + } + + // buildtime + // + { + bool& v = + o.buildtime; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.buildtime_value, + i.buildtime_null); + } + + // comment + // + { + ::std::string& v = + o.comment; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.comment_value, + i.comment_size, + i.comment_null); + } + } + + // dependency + // + + bool access::composite_value_traits< ::brep::dependency, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // name + // + if (t[0UL]) + { + i.name_value.capacity (i.name_size); + grew = true; + } + + // constraint + // + if (composite_value_traits< ::bpkg::version_constraint, id_pgsql >::grow ( + i.constraint_value, t + 1UL)) + grew = true; + + // package + // + if (composite_value_traits< ::brep::package_id, id_pgsql >::grow ( + i.package_value, t + 15UL)) + grew = true; + + return grew; + } + + void access::composite_value_traits< ::brep::dependency, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // name + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.name_value.data (); + b[n].capacity = i.name_value.capacity (); + b[n].size = &i.name_size; + b[n].is_null = &i.name_null; + n++; + + // constraint + // + composite_value_traits< ::bpkg::version_constraint, id_pgsql >::bind ( + b + n, i.constraint_value, sk); + n += 14UL; + + // package + // + composite_value_traits< ::brep::package_id, id_pgsql >::bind ( + b + n, i.package_value, sk); + n += 6UL; + } + + bool access::composite_value_traits< ::brep::dependency, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // name + // + { + ::bpkg::package_name const& v = + o.name; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.name_value.capacity ()); + pgsql::value_traits< + ::bpkg::package_name, + pgsql::id_string >::set_image ( + i.name_value, + size, + is_null, + v); + i.name_null = is_null; + i.name_size = size; + grew = grew || (cap != i.name_value.capacity ()); + } + + // constraint + // + { + ::butl::optional< ::bpkg::version_constraint > const& v = + o.constraint; + + if (wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::get_null (v)) + composite_value_traits< ::bpkg::version_constraint, id_pgsql >::set_null ( + i.constraint_value, sk); + else + { + const::bpkg::version_constraint& vw = + wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::get_ref (v); + + if (composite_value_traits< ::bpkg::version_constraint, id_pgsql >::init ( + i.constraint_value, + vw, + sk)) + grew = true; + } + } + + // package + // + { + ::odb::lazy_shared_ptr< ::brep::package > const& v = + o.package; + + typedef object_traits< ::brep::package > obj_traits; + typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::package > > ptr_traits; + + bool is_null (ptr_traits::null_ptr (v)); + if (!is_null) + { + const obj_traits::id_type& ptr_id ( + ptr_traits::object_id< ptr_traits::element_type > (v)); + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + i.package_value, + ptr_id, + sk)) + grew = true; + } + else + composite_value_traits< obj_traits::id_type, id_pgsql >::set_null (i.package_value, sk); + } + + return grew; + } + + void access::composite_value_traits< ::brep::dependency, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // name + // + { + ::bpkg::package_name& v = + o.name; + + pgsql::value_traits< + ::bpkg::package_name, + pgsql::id_string >::set_value ( + v, + i.name_value, + i.name_size, + i.name_null); + } + + // constraint + // + { + ::butl::optional< ::bpkg::version_constraint >& v = + o.constraint; + + if (composite_value_traits< ::bpkg::version_constraint, id_pgsql >::get_null ( + i.constraint_value)) + wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_null (v); + else + { + ::bpkg::version_constraint& vw = + wrapper_traits< ::butl::optional< ::bpkg::version_constraint > >::set_ref (v); + + composite_value_traits< ::bpkg::version_constraint, id_pgsql >::init ( + vw, + i.constraint_value, + db); + } + } + + // package + // + { + ::odb::lazy_shared_ptr< ::brep::package >& v = + o.package; + + typedef object_traits< ::brep::package > obj_traits; + typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::package > > ptr_traits; + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null ( + i.package_value)) + v = ptr_traits::pointer_type (); + else + { + obj_traits::id_type ptr_id; + composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + ptr_id, + i.package_value, + db); + + v = ptr_traits::pointer_type ( + *static_cast<pgsql::database*> (db), ptr_id); + } + } + } + + // dependency_alternatives + // + + bool access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // conditional + // + t[0UL] = 0; + + // buildtime + // + t[1UL] = 0; + + // comment + // + if (t[2UL]) + { + i.comment_value.capacity (i.comment_size); + grew = true; + } + + return grew; + } + + void access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // conditional + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.conditional_value; + b[n].is_null = &i.conditional_null; + n++; + + // buildtime + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.buildtime_value; + b[n].is_null = &i.buildtime_null; + n++; + + // comment + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.comment_value.data (); + b[n].capacity = i.comment_value.capacity (); + b[n].size = &i.comment_size; + b[n].is_null = &i.comment_null; + n++; + } + + bool access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // conditional + // + { + bool const& v = + o.conditional; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.conditional_value, is_null, v); + i.conditional_null = is_null; + } + + // buildtime + // + { + bool const& v = + o.buildtime; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.buildtime_value, is_null, v); + i.buildtime_null = is_null; + } + + // comment + // + { + ::std::string const& v = + o.comment; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.comment_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.comment_value, + size, + is_null, + v); + i.comment_null = is_null; + i.comment_size = size; + grew = grew || (cap != i.comment_value.capacity ()); + } + + return grew; + } + + void access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // conditional + // + { + bool& v = + o.conditional; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.conditional_value, + i.conditional_null); + } + + // buildtime + // + { + bool& v = + o.buildtime; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.buildtime_value, + i.buildtime_null); + } + + // comment + // + { + ::std::string& v = + o.comment; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.comment_value, + i.comment_size, + i.comment_null); + } + } + + // test_dependency + // + + bool access::composite_value_traits< ::brep::test_dependency, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // dependency base + // + if (composite_value_traits< ::brep::dependency, id_pgsql >::grow ( + i, t + 0UL)) + grew = true; + + // type + // + if (t[21UL]) + { + i.type_value.capacity (i.type_size); + grew = true; + } + + return grew; + } + + void access::composite_value_traits< ::brep::test_dependency, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // dependency base + // + composite_value_traits< ::brep::dependency, id_pgsql >::bind (b + n, i, sk); + n += 21UL; + + // type + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.type_value.data (); + b[n].capacity = i.type_value.capacity (); + b[n].size = &i.type_size; + b[n].is_null = &i.type_null; + n++; + } + + bool access::composite_value_traits< ::brep::test_dependency, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // dependency base + // + if (composite_value_traits< ::brep::dependency, id_pgsql >::init (i, o, sk)) + grew = true; + + // type + // + { + ::bpkg::test_dependency_type const& v = + o.type; + + // From package.hxx:189:14 + ::std::string const& vt = + to_string (v); + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.type_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.type_value, + size, + is_null, + vt); + i.type_null = is_null; + i.type_size = size; + grew = grew || (cap != i.type_value.capacity ()); + } + + return grew; + } + + void access::composite_value_traits< ::brep::test_dependency, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // dependency base + // + composite_value_traits< ::brep::dependency, id_pgsql >::init (o, i, db); + + // type + // + { + ::bpkg::test_dependency_type& v = + o.type; + + ::std::string vt; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + vt, + i.type_value, + i.type_size, + i.type_null); + + // From package.hxx:189:14 + v = brep::to_test_dependency_type (vt); + } + } + + // certificate + // + + bool access::composite_value_traits< ::brep::certificate, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // fingerprint + // + if (t[0UL]) + { + i.fingerprint_value.capacity (i.fingerprint_size); + grew = true; + } + + // name + // + if (t[1UL]) + { + i.name_value.capacity (i.name_size); + grew = true; + } + + // organization + // + if (t[2UL]) + { + i.organization_value.capacity (i.organization_size); + grew = true; + } + + // email + // + if (t[3UL]) + { + i.email_value.capacity (i.email_size); + grew = true; + } + + // pem + // + if (t[4UL]) + { + i.pem_value.capacity (i.pem_size); + grew = true; + } + + return grew; + } + + void access::composite_value_traits< ::brep::certificate, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // fingerprint + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.fingerprint_value.data (); + b[n].capacity = i.fingerprint_value.capacity (); + b[n].size = &i.fingerprint_size; + b[n].is_null = &i.fingerprint_null; + n++; + + // name + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.name_value.data (); + b[n].capacity = i.name_value.capacity (); + b[n].size = &i.name_size; + b[n].is_null = &i.name_null; + n++; + + // organization + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.organization_value.data (); + b[n].capacity = i.organization_value.capacity (); + b[n].size = &i.organization_size; + b[n].is_null = &i.organization_null; + n++; + + // email + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.email_value.data (); + b[n].capacity = i.email_value.capacity (); + b[n].size = &i.email_size; + b[n].is_null = &i.email_null; + n++; + + // pem + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.pem_value.data (); + b[n].capacity = i.pem_value.capacity (); + b[n].size = &i.pem_size; + b[n].is_null = &i.pem_null; + n++; + } + + bool access::composite_value_traits< ::brep::certificate, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // fingerprint + // + { + ::std::string const& v = + o.fingerprint; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.fingerprint_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.fingerprint_value, + size, + is_null, + v); + i.fingerprint_null = is_null; + i.fingerprint_size = size; + grew = grew || (cap != i.fingerprint_value.capacity ()); + } + + // name + // + { + ::std::string const& v = + o.name; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.name_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.name_value, + size, + is_null, + v); + i.name_null = is_null; + i.name_size = size; + grew = grew || (cap != i.name_value.capacity ()); + } + + // organization + // + { + ::std::string const& v = + o.organization; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.organization_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.organization_value, + size, + is_null, + v); + i.organization_null = is_null; + i.organization_size = size; + grew = grew || (cap != i.organization_value.capacity ()); + } + + // email + // + { + ::std::string const& v = + o.email; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.email_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.email_value, + size, + is_null, + v); + i.email_null = is_null; + i.email_size = size; + grew = grew || (cap != i.email_value.capacity ()); + } + + // pem + // + { + ::std::string const& v = + o.pem; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.pem_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.pem_value, + size, + is_null, + v); + i.pem_null = is_null; + i.pem_size = size; + grew = grew || (cap != i.pem_value.capacity ()); + } + + return grew; + } + + void access::composite_value_traits< ::brep::certificate, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // fingerprint + // + { + ::std::string& v = + o.fingerprint; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.fingerprint_value, + i.fingerprint_size, + i.fingerprint_null); + } + + // name + // + { + ::std::string& v = + o.name; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.name_value, + i.name_size, + i.name_null); + } + + // organization + // + { + ::std::string& v = + o.organization; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.organization_value, + i.organization_size, + i.organization_null); + } + + // email + // + { + ::std::string& v = + o.email; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.email_value, + i.email_size, + i.email_null); + } + + // pem + // + { + ::std::string& v = + o.pem; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.pem_value, + i.pem_size, + i.pem_null); + } + } + + // tenant + // + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >:: + persist_statement_name[] = "persist_brep_tenant"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >:: + find_statement_name[] = "find_brep_tenant"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >:: + update_statement_name[] = "update_brep_tenant"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >:: + erase_statement_name[] = "erase_brep_tenant"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >:: + query_statement_name[] = "query_brep_tenant"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >:: + erase_query_statement_name[] = "erase_query_brep_tenant"; + + const unsigned int access::object_traits_impl< ::brep::tenant, id_pgsql >:: + persist_statement_types[] = + { + pgsql::text_oid, + pgsql::int8_oid, + pgsql::bool_oid + }; + + const unsigned int access::object_traits_impl< ::brep::tenant, id_pgsql >:: + find_statement_types[] = + { + pgsql::text_oid + }; + + const unsigned int access::object_traits_impl< ::brep::tenant, id_pgsql >:: + update_statement_types[] = + { + pgsql::int8_oid, + pgsql::bool_oid, + pgsql::text_oid + }; + + struct access::object_traits_impl< ::brep::tenant, id_pgsql >::extra_statement_cache_type + { + extra_statement_cache_type ( + pgsql::connection&, + image_type&, + id_image_type&, + pgsql::binding&, + pgsql::binding&, + pgsql::native_binding&, + const unsigned int*) + { + } + }; + + access::object_traits_impl< ::brep::tenant, id_pgsql >::id_type + access::object_traits_impl< ::brep::tenant, id_pgsql >:: + id (const image_type& i) + { + pgsql::database* db (0); + ODB_POTENTIALLY_UNUSED (db); + + id_type id; + { + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + id, + i.id_value, + i.id_size, + i.id_null); + } + + return id; + } + + bool access::object_traits_impl< ::brep::tenant, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // id + // + if (t[0UL]) + { + i.id_value.capacity (i.id_size); + grew = true; + } + + // creation_timestamp + // + t[1UL] = 0; + + // archived + // + t[2UL] = 0; + + return grew; + } + + void access::object_traits_impl< ::brep::tenant, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + + // id + // + if (sk != statement_update) + { + b[n].type = pgsql::bind::text; + b[n].buffer = i.id_value.data (); + b[n].capacity = i.id_value.capacity (); + b[n].size = &i.id_size; + b[n].is_null = &i.id_null; + n++; + } + + // creation_timestamp + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.creation_timestamp_value; + b[n].is_null = &i.creation_timestamp_null; + n++; + + // archived + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.archived_value; + b[n].is_null = &i.archived_null; + n++; + } + + void access::object_traits_impl< ::brep::tenant, id_pgsql >:: + bind (pgsql::bind* b, id_image_type& i) + { + std::size_t n (0); + b[n].type = pgsql::bind::text; + b[n].buffer = i.id_value.data (); + b[n].capacity = i.id_value.capacity (); + b[n].size = &i.id_size; + b[n].is_null = &i.id_null; + } + + bool access::object_traits_impl< ::brep::tenant, id_pgsql >:: + init (image_type& i, + const object_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // id + // + if (sk == statement_insert) + { + ::std::string const& v = + o.id; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.id_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.id_value, + size, + is_null, + v); + i.id_null = is_null; + i.id_size = size; + grew = grew || (cap != i.id_value.capacity ()); + } + + // creation_timestamp + // + { + ::butl::timestamp const& v = + o.creation_timestamp; + + // From common.hxx:119:14 + ::uint64_t const& vt = + std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count (); + + bool is_null (false); + pgsql::value_traits< + ::uint64_t, + pgsql::id_bigint >::set_image ( + i.creation_timestamp_value, is_null, vt); + i.creation_timestamp_null = is_null; + } + + // archived + // + { + bool const& v = + o.archived; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.archived_value, is_null, v); + i.archived_null = is_null; + } + + return grew; + } + + void access::object_traits_impl< ::brep::tenant, id_pgsql >:: + init (object_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // id + // + { + ::std::string& v = + o.id; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.id_value, + i.id_size, + i.id_null); + } + + // creation_timestamp + // + { + ::butl::timestamp& v = + o.creation_timestamp; + + ::uint64_t vt; + + pgsql::value_traits< + ::uint64_t, + pgsql::id_bigint >::set_value ( + vt, + i.creation_timestamp_value, + i.creation_timestamp_null); + + // From common.hxx:119:14 + v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt))); + } + + // archived + // + { + bool& v = + o.archived; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.archived_value, + i.archived_null); + } + } + + void access::object_traits_impl< ::brep::tenant, id_pgsql >:: + init (id_image_type& i, const id_type& id) + { + bool grew (false); + { + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.id_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.id_value, + size, + is_null, + id); + i.id_null = is_null; + i.id_size = size; + grew = grew || (cap != i.id_value.capacity ()); + } + + if (grew) + i.version++; + } + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >::persist_statement[] = + "INSERT INTO \"tenant\" " + "(\"id\", " + "\"creation_timestamp\", " + "\"archived\") " + "VALUES " + "($1, $2, $3)"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >::find_statement[] = + "SELECT " + "\"tenant\".\"id\", " + "\"tenant\".\"creation_timestamp\", " + "\"tenant\".\"archived\" " + "FROM \"tenant\" " + "WHERE \"tenant\".\"id\"=$1"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >::update_statement[] = + "UPDATE \"tenant\" " + "SET " + "\"creation_timestamp\"=$1, " + "\"archived\"=$2 " + "WHERE \"id\"=$3"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >::erase_statement[] = + "DELETE FROM \"tenant\" " + "WHERE \"id\"=$1"; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >::query_statement[] = + "SELECT " + "\"tenant\".\"id\", " + "\"tenant\".\"creation_timestamp\", " + "\"tenant\".\"archived\" " + "FROM \"tenant\""; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >::erase_query_statement[] = + "DELETE FROM \"tenant\""; + + const char access::object_traits_impl< ::brep::tenant, id_pgsql >::table_name[] = + "\"tenant\""; + + void access::object_traits_impl< ::brep::tenant, id_pgsql >:: + persist (database& db, const object_type& obj) + { + ODB_POTENTIALLY_UNUSED (db); + + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + callback (db, + obj, + callback_event::pre_persist); + + image_type& im (sts.image ()); + binding& imb (sts.insert_image_binding ()); + + if (init (im, obj, statement_insert)) + im.version++; + + if (im.version != sts.insert_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_insert); + sts.insert_image_version (im.version); + imb.version++; + } + + insert_statement& st (sts.persist_statement ()); + if (!st.execute ()) + throw object_already_persistent (); + + callback (db, + obj, + callback_event::post_persist); + } + + void access::object_traits_impl< ::brep::tenant, id_pgsql >:: + update (database& db, const object_type& obj) + { + ODB_POTENTIALLY_UNUSED (db); + + using namespace pgsql; + using pgsql::update_statement; + + callback (db, obj, callback_event::pre_update); + + pgsql::transaction& tr (pgsql::transaction::current ()); + pgsql::connection& conn (tr.connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + id_image_type& idi (sts.id_image ()); + init (idi, id (obj)); + + image_type& im (sts.image ()); + if (init (im, obj, statement_update)) + im.version++; + + bool u (false); + binding& imb (sts.update_image_binding ()); + if (im.version != sts.update_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_update); + sts.update_image_version (im.version); + imb.version++; + u = true; + } + + binding& idb (sts.id_image_binding ()); + if (idi.version != sts.update_id_image_version () || + idb.version == 0) + { + if (idi.version != sts.id_image_version () || + idb.version == 0) + { + bind (idb.bind, idi); + sts.id_image_version (idi.version); + idb.version++; + } + + sts.update_id_image_version (idi.version); + + if (!u) + imb.version++; + } + + update_statement& st (sts.update_statement ()); + if (st.execute () == 0) + throw object_not_persistent (); + + callback (db, obj, callback_event::post_update); + pointer_cache_traits::update (db, obj); + } + + void access::object_traits_impl< ::brep::tenant, id_pgsql >:: + erase (database& db, const id_type& id) + { + using namespace pgsql; + + ODB_POTENTIALLY_UNUSED (db); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + id_image_type& i (sts.id_image ()); + init (i, id); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + if (sts.erase_statement ().execute () != 1) + throw object_not_persistent (); + + pointer_cache_traits::erase (db, id); + } + + access::object_traits_impl< ::brep::tenant, id_pgsql >::pointer_type + access::object_traits_impl< ::brep::tenant, id_pgsql >:: + find (database& db, const id_type& id) + { + using namespace pgsql; + + { + pointer_type p (pointer_cache_traits::find (db, id)); + + if (!pointer_traits::null_ptr (p)) + return p; + } + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + + if (l.locked ()) + { + if (!find_ (sts, &id)) + return pointer_type (); + } + + pointer_type p ( + access::object_factory<object_type, pointer_type>::create ()); + pointer_traits::guard pg (p); + + pointer_cache_traits::insert_guard ig ( + pointer_cache_traits::insert (db, id, p)); + + object_type& obj (pointer_traits::get_ref (p)); + + if (l.locked ()) + { + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, false); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + pointer_cache_traits::load (ig.position ()); + } + else + sts.delay_load (id, obj, ig.position ()); + + ig.release (); + pg.release (); + return p; + } + + bool access::object_traits_impl< ::brep::tenant, id_pgsql >:: + find (database& db, const id_type& id, object_type& obj) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + assert (l.locked ()) /* Must be a top-level call. */; + + if (!find_ (sts, &id)) + return false; + + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + reference_cache_traits::position_type pos ( + reference_cache_traits::insert (db, id, obj)); + reference_cache_traits::insert_guard ig (pos); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, false); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + reference_cache_traits::load (pos); + ig.release (); + return true; + } + + bool access::object_traits_impl< ::brep::tenant, id_pgsql >:: + reload (database& db, object_type& obj) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + assert (l.locked ()) /* Must be a top-level call. */; + + const id_type& id (object_traits_impl::id (obj)); + if (!find_ (sts, &id)) + return false; + + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, true); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + return true; + } + + bool access::object_traits_impl< ::brep::tenant, id_pgsql >:: + find_ (statements_type& sts, + const id_type* id) + { + using namespace pgsql; + + id_image_type& i (sts.id_image ()); + init (i, *id); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + select_statement& st (sts.find_statement ()); + + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + if (grow (im, sts.select_image_truncated ())) + im.version++; + + if (im.version != sts.select_image_version ()) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + result< access::object_traits_impl< ::brep::tenant, id_pgsql >::object_type > + access::object_traits_impl< ::brep::tenant, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + std::string text (query_statement); + if (!q.empty ()) + { + text += " "; + text += q.clause (); + } + + q.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + text, + false, + true, + q.parameter_types (), + q.parameter_count (), + q.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::object_result_impl<object_type> > r ( + new (shared) pgsql::object_result_impl<object_type> ( + q, st, sts, 0)); + + return result<object_type> (r); + } + + unsigned long long access::object_traits_impl< ::brep::tenant, id_pgsql >:: + erase_query (database&, const query_base_type& q) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + std::string text (erase_query_statement); + if (!q.empty ()) + { + text += ' '; + text += q.clause (); + } + + q.init_parameters (); + delete_statement st ( + conn, + erase_query_statement_name, + text, + q.parameter_types (), + q.parameter_count (), + q.parameters_binding ()); + + return st.execute (); + } + + odb::details::shared_ptr<prepared_query_impl> + access::object_traits_impl< ::brep::tenant, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + std::string text (query_statement); + if (!q.empty ()) + { + text += " "; + text += q.clause (); + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = q; + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + text, + false, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::object_traits_impl< ::brep::tenant, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::object_result_impl<object_type> ( + pq.query, st, sts, 0)); + } + + // tenant_id + // + + const char access::view_traits_impl< ::brep::tenant_id, id_pgsql >:: + query_statement_name[] = "query_brep_tenant_id"; + + bool access::view_traits_impl< ::brep::tenant_id, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // value + // + if (t[0UL]) + { + i.value_value.capacity (i.value_size); + grew = true; + } + + return grew; + } + + void access::view_traits_impl< ::brep::tenant_id, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i) + { + using namespace pgsql; + + pgsql::statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + std::size_t n (0); + + // value + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.value_value.data (); + b[n].capacity = i.value_value.capacity (); + b[n].size = &i.value_size; + b[n].is_null = &i.value_null; + n++; + } + + void access::view_traits_impl< ::brep::tenant_id, id_pgsql >:: + init (view_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // value + // + { + ::std::string& v = + o.value; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.value_value, + i.value_size, + i.value_null); + } + } + + access::view_traits_impl< ::brep::tenant_id, id_pgsql >::query_base_type + access::view_traits_impl< ::brep::tenant_id, id_pgsql >:: + query_statement (const query_base_type& q) + { + query_base_type r ( + "SELECT " + "\"id\" "); + + r += "FROM \"tenant\""; + + if (!q.empty ()) + { + r += " "; + r += q.clause_prefix (); + r += q; + } + + return r; + } + + result< access::view_traits_impl< ::brep::tenant_id, id_pgsql >::view_type > + access::view_traits_impl< ::brep::tenant_id, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + const query_base_type& qs (query_statement (q)); + qs.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + qs.clause (), + false, + true, + qs.parameter_types (), + qs.parameter_count (), + qs.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::view_result_impl<view_type> > r ( + new (shared) pgsql::view_result_impl<view_type> ( + qs, st, sts, 0)); + + return result<view_type> (r); + } + + odb::details::shared_ptr<prepared_query_impl> + access::view_traits_impl< ::brep::tenant_id, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = query_statement (q); + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + r->query.clause (), + false, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::view_traits_impl< ::brep::tenant_id, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::view_result_impl<view_type> ( + pq.query, st, sts, 0)); + } + + // repository + // + + const char access::object_traits_impl< ::brep::repository, id_pgsql >:: + persist_statement_name[] = "persist_brep_repository"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >:: + find_statement_name[] = "find_brep_repository"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >:: + update_statement_name[] = "update_brep_repository"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >:: + erase_statement_name[] = "erase_brep_repository"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >:: + query_statement_name[] = "query_brep_repository"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >:: + erase_query_statement_name[] = "erase_query_brep_repository"; + + const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >:: + persist_statement_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int8_oid, + pgsql::int8_oid, + pgsql::bool_oid, + pgsql::bool_oid + }; + + const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >:: + find_statement_types[] = + { + pgsql::text_oid, + pgsql::text_oid + }; + + const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >:: + update_statement_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int8_oid, + pgsql::int8_oid, + pgsql::bool_oid, + pgsql::bool_oid, + pgsql::text_oid, + pgsql::text_oid + }; + + struct access::object_traits_impl< ::brep::repository, id_pgsql >::extra_statement_cache_type + { + pgsql::container_statements_impl< complements_traits > complements; + pgsql::container_statements_impl< prerequisites_traits > prerequisites; + + extra_statement_cache_type ( + pgsql::connection& c, + image_type&, + id_image_type&, + pgsql::binding& id, + pgsql::binding&, + pgsql::native_binding& idn, + const unsigned int* idt) + : complements (c, id, idn, idt), + prerequisites (c, id, idn, idt) + { + } + }; + + // complements + // + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + select_name[] = "select_brep_repository_complements"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + insert_name[] = "insert_brep_repository_complements"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + delete_name[] = "delete_brep_repository_complements"; + + const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int8_oid, + pgsql::text_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + select_statement[] = + "SELECT " + "\"repository_complements\".\"index\", " + "\"repository_complements\".\"complement_tenant\", " + "\"repository_complements\".\"complement_canonical_name\" " + "FROM \"repository_complements\" " + "WHERE \"repository_complements\".\"repository_tenant\"=$1 AND \"repository_complements\".\"repository_canonical_name\"=$2 ORDER BY \"repository_complements\".\"index\""; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + insert_statement[] = + "INSERT INTO \"repository_complements\" " + "(\"repository_tenant\", " + "\"repository_canonical_name\", " + "\"index\", " + "\"complement_tenant\", " + "\"complement_canonical_name\") " + "VALUES " + "($1, $2, $3, $4, $5)"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + delete_statement[] = + "DELETE FROM \"repository_complements\" " + "WHERE \"repository_tenant\"=$1 AND \"repository_canonical_name\"=$2"; + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< ::brep::repository_id, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + typedef object_traits< ::brep::repository > obj_traits; + typedef odb::pointer_traits< value_type > wptr_traits; + typedef odb::pointer_traits< wptr_traits::strong_pointer_type > ptr_traits; + + wptr_traits::strong_pointer_type sp (wptr_traits::lock (v)); + bool is_null (ptr_traits::null_ptr (sp)); + if (!is_null) + { + const obj_traits::id_type& ptr_id ( + ptr_traits::object_id< ptr_traits::element_type > (sp)); + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + i.value_value, + ptr_id, + sk)) + grew = true; + } + else + throw null_pointer (); + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + typedef object_traits< ::brep::repository > obj_traits; + typedef odb::pointer_traits< value_type > ptr_traits; + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null ( + i.value_value)) + v = ptr_traits::pointer_type (); + else + { + obj_traits::id_type ptr_id; + composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + ptr_id, + i.value_value, + db); + + v = ptr_traits::pointer_type ( + *static_cast<pgsql::database*> (db), ptr_id); + } + } + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::complements_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // prerequisites + // + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + select_name[] = "select_brep_repository_prerequisites"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + insert_name[] = "insert_brep_repository_prerequisites"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + delete_name[] = "delete_brep_repository_prerequisites"; + + const unsigned int access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int8_oid, + pgsql::text_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + select_statement[] = + "SELECT " + "\"repository_prerequisites\".\"index\", " + "\"repository_prerequisites\".\"prerequisite_tenant\", " + "\"repository_prerequisites\".\"prerequisite_canonical_name\" " + "FROM \"repository_prerequisites\" " + "WHERE \"repository_prerequisites\".\"repository_tenant\"=$1 AND \"repository_prerequisites\".\"repository_canonical_name\"=$2 ORDER BY \"repository_prerequisites\".\"index\""; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + insert_statement[] = + "INSERT INTO \"repository_prerequisites\" " + "(\"repository_tenant\", " + "\"repository_canonical_name\", " + "\"index\", " + "\"prerequisite_tenant\", " + "\"prerequisite_canonical_name\") " + "VALUES " + "($1, $2, $3, $4, $5)"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + delete_statement[] = + "DELETE FROM \"repository_prerequisites\" " + "WHERE \"repository_tenant\"=$1 AND \"repository_canonical_name\"=$2"; + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< ::brep::repository_id, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + typedef object_traits< ::brep::repository > obj_traits; + typedef odb::pointer_traits< value_type > wptr_traits; + typedef odb::pointer_traits< wptr_traits::strong_pointer_type > ptr_traits; + + wptr_traits::strong_pointer_type sp (wptr_traits::lock (v)); + bool is_null (ptr_traits::null_ptr (sp)); + if (!is_null) + { + const obj_traits::id_type& ptr_id ( + ptr_traits::object_id< ptr_traits::element_type > (sp)); + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + i.value_value, + ptr_id, + sk)) + grew = true; + } + else + throw null_pointer (); + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + typedef object_traits< ::brep::repository > obj_traits; + typedef odb::pointer_traits< value_type > ptr_traits; + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null ( + i.value_value)) + v = ptr_traits::pointer_type (); + else + { + obj_traits::id_type ptr_id; + composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + ptr_id, + i.value_value, + db); + + v = ptr_traits::pointer_type ( + *static_cast<pgsql::database*> (db), ptr_id); + } + } + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >::prerequisites_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + access::object_traits_impl< ::brep::repository, id_pgsql >::id_type + access::object_traits_impl< ::brep::repository, id_pgsql >:: + id (const image_type& i) + { + pgsql::database* db (0); + ODB_POTENTIALLY_UNUSED (db); + + id_type id; + { + composite_value_traits< ::brep::repository_id, id_pgsql >::init ( + id, + i.id_value, + db); + } + + return id; + } + + bool access::object_traits_impl< ::brep::repository, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // id + // + if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow ( + i.id_value, t + 0UL)) + grew = true; + + // location + // + if (composite_value_traits< ::brep::_repository_location, id_pgsql >::grow ( + i.location_value, t + 2UL)) + grew = true; + + // display_name + // + if (t[4UL]) + { + i.display_name_value.capacity (i.display_name_size); + grew = true; + } + + // priority + // + t[5UL] = 0; + + // interface_url + // + if (t[6UL]) + { + i.interface_url_value.capacity (i.interface_url_size); + grew = true; + } + + // email + // + if (composite_value_traits< ::bpkg::email, id_pgsql >::grow ( + i.email_value, t + 7UL)) + grew = true; + + // summary + // + if (t[9UL]) + { + i.summary_value.capacity (i.summary_size); + grew = true; + } + + // description + // + if (t[10UL]) + { + i.description_value.capacity (i.description_size); + grew = true; + } + + // cache_location + // + if (composite_value_traits< ::brep::_repository_location, id_pgsql >::grow ( + i.cache_location_value, t + 11UL)) + grew = true; + + // certificate + // + if (composite_value_traits< ::brep::certificate, id_pgsql >::grow ( + i.certificate_value, t + 13UL)) + grew = true; + + // packages_timestamp + // + t[18UL] = 0; + + // repositories_timestamp + // + t[19UL] = 0; + + // internal + // + t[20UL] = 0; + + // buildable + // + t[21UL] = 0; + + return grew; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + + // id + // + if (sk != statement_update) + { + composite_value_traits< ::brep::repository_id, id_pgsql >::bind ( + b + n, i.id_value, sk); + n += 2UL; + } + + // location + // + composite_value_traits< ::brep::_repository_location, id_pgsql >::bind ( + b + n, i.location_value, sk); + n += 2UL; + + // display_name + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.display_name_value.data (); + b[n].capacity = i.display_name_value.capacity (); + b[n].size = &i.display_name_size; + b[n].is_null = &i.display_name_null; + n++; + + // priority + // + b[n].type = pgsql::bind::integer; + b[n].buffer = &i.priority_value; + b[n].is_null = &i.priority_null; + n++; + + // interface_url + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.interface_url_value.data (); + b[n].capacity = i.interface_url_value.capacity (); + b[n].size = &i.interface_url_size; + b[n].is_null = &i.interface_url_null; + n++; + + // email + // + composite_value_traits< ::bpkg::email, id_pgsql >::bind ( + b + n, i.email_value, sk); + n += 2UL; + + // summary + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.summary_value.data (); + b[n].capacity = i.summary_value.capacity (); + b[n].size = &i.summary_size; + b[n].is_null = &i.summary_null; + n++; + + // description + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.description_value.data (); + b[n].capacity = i.description_value.capacity (); + b[n].size = &i.description_size; + b[n].is_null = &i.description_null; + n++; + + // cache_location + // + composite_value_traits< ::brep::_repository_location, id_pgsql >::bind ( + b + n, i.cache_location_value, sk); + n += 2UL; + + // certificate + // + composite_value_traits< ::brep::certificate, id_pgsql >::bind ( + b + n, i.certificate_value, sk); + n += 5UL; + + // packages_timestamp + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.packages_timestamp_value; + b[n].is_null = &i.packages_timestamp_null; + n++; + + // repositories_timestamp + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.repositories_timestamp_value; + b[n].is_null = &i.repositories_timestamp_null; + n++; + + // internal + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.internal_value; + b[n].is_null = &i.internal_null; + n++; + + // buildable + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.buildable_value; + b[n].is_null = &i.buildable_null; + n++; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >:: + bind (pgsql::bind* b, id_image_type& i) + { + std::size_t n (0); + pgsql::statement_kind sk (pgsql::statement_select); + composite_value_traits< ::brep::repository_id, id_pgsql >::bind ( + b + n, i.id_value, sk); + } + + bool access::object_traits_impl< ::brep::repository, id_pgsql >:: + init (image_type& i, + const object_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // id + // + if (sk == statement_insert) + { + ::brep::repository_id const& v = + o.id; + + if (composite_value_traits< ::brep::repository_id, id_pgsql >::init ( + i.id_value, + v, + sk)) + grew = true; + } + + // location + // + { + ::bpkg::repository_location const& v = + o.location; + + // From common.hxx:285:14 + ::brep::_repository_location const& vt = + brep::_repository_location + { + (v).url (), (v).empty () ? brep::repository_type::pkg : (v).type () + }; + + + if (composite_value_traits< ::brep::_repository_location, id_pgsql >::init ( + i.location_value, + vt, + sk)) + grew = true; + } + + // display_name + // + { + ::std::string const& v = + o.display_name; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.display_name_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.display_name_value, + size, + is_null, + v); + i.display_name_null = is_null; + i.display_name_size = size; + grew = grew || (cap != i.display_name_value.capacity ()); + } + + // priority + // + { + ::uint16_t const& v = + o.priority; + + bool is_null (false); + pgsql::value_traits< + ::uint16_t, + pgsql::id_integer >::set_image ( + i.priority_value, is_null, v); + i.priority_null = is_null; + } + + // interface_url + // + { + ::butl::optional< ::std::basic_string< char > > const& v = + o.interface_url; + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.interface_url_value.capacity ()); + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_image ( + i.interface_url_value, + size, + is_null, + v); + i.interface_url_null = is_null; + i.interface_url_size = size; + grew = grew || (cap != i.interface_url_value.capacity ()); + } + + // email + // + { + ::butl::optional< ::bpkg::email > const& v = + o.email; + + if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v)) + composite_value_traits< ::bpkg::email, id_pgsql >::set_null ( + i.email_value, sk); + else + { + const::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v); + + if (composite_value_traits< ::bpkg::email, id_pgsql >::init ( + i.email_value, + vw, + sk)) + grew = true; + } + } + + // summary + // + { + ::butl::optional< ::std::basic_string< char > > const& v = + o.summary; + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.summary_value.capacity ()); + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_image ( + i.summary_value, + size, + is_null, + v); + i.summary_null = is_null; + i.summary_size = size; + grew = grew || (cap != i.summary_value.capacity ()); + } + + // description + // + { + ::butl::optional< ::std::basic_string< char > > const& v = + o.description; + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.description_value.capacity ()); + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_image ( + i.description_value, + size, + is_null, + v); + i.description_null = is_null; + i.description_size = size; + grew = grew || (cap != i.description_value.capacity ()); + } + + // cache_location + // + { + ::bpkg::repository_location const& v = + o.cache_location; + + // From common.hxx:285:14 + ::brep::_repository_location const& vt = + brep::_repository_location + { + (v).url (), (v).empty () ? brep::repository_type::pkg : (v).type () + }; + + + if (composite_value_traits< ::brep::_repository_location, id_pgsql >::init ( + i.cache_location_value, + vt, + sk)) + grew = true; + } + + // certificate + // + { + ::butl::optional< ::brep::certificate > const& v = + o.certificate; + + if (wrapper_traits< ::butl::optional< ::brep::certificate > >::get_null (v)) + composite_value_traits< ::brep::certificate, id_pgsql >::set_null ( + i.certificate_value, sk); + else + { + const::brep::certificate& vw = + wrapper_traits< ::butl::optional< ::brep::certificate > >::get_ref (v); + + if (composite_value_traits< ::brep::certificate, id_pgsql >::init ( + i.certificate_value, + vw, + sk)) + grew = true; + } + } + + // packages_timestamp + // + { + ::butl::timestamp const& v = + o.packages_timestamp; + + // From common.hxx:119:14 + ::uint64_t const& vt = + std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count (); + + bool is_null (false); + pgsql::value_traits< + ::uint64_t, + pgsql::id_bigint >::set_image ( + i.packages_timestamp_value, is_null, vt); + i.packages_timestamp_null = is_null; + } + + // repositories_timestamp + // + { + ::butl::timestamp const& v = + o.repositories_timestamp; + + // From common.hxx:119:14 + ::uint64_t const& vt = + std::chrono::duration_cast < std::chrono::nanoseconds > ((v).time_since_epoch ()).count (); + + bool is_null (false); + pgsql::value_traits< + ::uint64_t, + pgsql::id_bigint >::set_image ( + i.repositories_timestamp_value, is_null, vt); + i.repositories_timestamp_null = is_null; + } + + // internal + // + { + bool const& v = + o.internal; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.internal_value, is_null, v); + i.internal_null = is_null; + } + + // buildable + // + { + bool const& v = + o.buildable; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.buildable_value, is_null, v); + i.buildable_null = is_null; + } + + return grew; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >:: + init (object_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // id + // + { + ::brep::repository_id& v = + o.id; + + composite_value_traits< ::brep::repository_id, id_pgsql >::init ( + v, + i.id_value, + db); + } + + // location + // + { + // From package.hxx:335:7 + ::bpkg::repository_location v; + + ::brep::_repository_location vt; + + composite_value_traits< ::brep::_repository_location, id_pgsql >::init ( + vt, + i.location_value, + db); + + // From common.hxx:285:14 + v = brep::repository_location (std::move ((vt).url), (vt).type); + // From package.hxx:335:7 + o.location = std::move (v); + assert (o.canonical_name == o.location.canonical_name ()); + } + + // display_name + // + { + ::std::string& v = + o.display_name; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.display_name_value, + i.display_name_size, + i.display_name_null); + } + + // priority + // + { + ::uint16_t& v = + o.priority; + + pgsql::value_traits< + ::uint16_t, + pgsql::id_integer >::set_value ( + v, + i.priority_value, + i.priority_null); + } + + // interface_url + // + { + ::butl::optional< ::std::basic_string< char > >& v = + o.interface_url; + + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_value ( + v, + i.interface_url_value, + i.interface_url_size, + i.interface_url_null); + } + + // email + // + { + ::butl::optional< ::bpkg::email >& v = + o.email; + + if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null ( + i.email_value)) + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v); + else + { + ::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v); + + composite_value_traits< ::bpkg::email, id_pgsql >::init ( + vw, + i.email_value, + db); + } + } + + // summary + // + { + ::butl::optional< ::std::basic_string< char > >& v = + o.summary; + + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_value ( + v, + i.summary_value, + i.summary_size, + i.summary_null); + } + + // description + // + { + ::butl::optional< ::std::basic_string< char > >& v = + o.description; + + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_value ( + v, + i.description_value, + i.description_size, + i.description_null); + } + + // cache_location + // + { + ::bpkg::repository_location& v = + o.cache_location; + + ::brep::_repository_location vt; + + composite_value_traits< ::brep::_repository_location, id_pgsql >::init ( + vt, + i.cache_location_value, + db); + + // From common.hxx:285:14 + v = brep::repository_location (std::move ((vt).url), (vt).type); + } + + // certificate + // + { + ::butl::optional< ::brep::certificate >& v = + o.certificate; + + if (composite_value_traits< ::brep::certificate, id_pgsql >::get_null ( + i.certificate_value)) + wrapper_traits< ::butl::optional< ::brep::certificate > >::set_null (v); + else + { + ::brep::certificate& vw = + wrapper_traits< ::butl::optional< ::brep::certificate > >::set_ref (v); + + composite_value_traits< ::brep::certificate, id_pgsql >::init ( + vw, + i.certificate_value, + db); + } + } + + // packages_timestamp + // + { + ::butl::timestamp& v = + o.packages_timestamp; + + ::uint64_t vt; + + pgsql::value_traits< + ::uint64_t, + pgsql::id_bigint >::set_value ( + vt, + i.packages_timestamp_value, + i.packages_timestamp_null); + + // From common.hxx:119:14 + v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt))); + } + + // repositories_timestamp + // + { + ::butl::timestamp& v = + o.repositories_timestamp; + + ::uint64_t vt; + + pgsql::value_traits< + ::uint64_t, + pgsql::id_bigint >::set_value ( + vt, + i.repositories_timestamp_value, + i.repositories_timestamp_null); + + // From common.hxx:119:14 + v = brep::timestamp (std::chrono::duration_cast < brep::timestamp::duration > (std::chrono::nanoseconds (vt))); + } + + // internal + // + { + bool& v = + o.internal; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.internal_value, + i.internal_null); + } + + // buildable + // + { + bool& v = + o.buildable; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.buildable_value, + i.buildable_null); + } + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >:: + init (id_image_type& i, const id_type& id) + { + bool grew (false); + pgsql::statement_kind sk (pgsql::statement_select); + { + if (composite_value_traits< ::brep::repository_id, id_pgsql >::init ( + i.id_value, + id, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::persist_statement[] = + "INSERT INTO \"repository\" " + "(\"tenant\", " + "\"canonical_name\", " + "\"location_url\", " + "\"location_type\", " + "\"display_name\", " + "\"priority\", " + "\"interface_url\", " + "\"email\", " + "\"email_comment\", " + "\"summary\", " + "\"description\", " + "\"cache_location_url\", " + "\"cache_location_type\", " + "\"certificate_fingerprint\", " + "\"certificate_name\", " + "\"certificate_organization\", " + "\"certificate_email\", " + "\"certificate_pem\", " + "\"packages_timestamp\", " + "\"repositories_timestamp\", " + "\"internal\", " + "\"buildable\") " + "VALUES " + "($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22)"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::find_statement[] = + "SELECT " + "\"repository\".\"tenant\", " + "\"repository\".\"canonical_name\", " + "\"repository\".\"location_url\", " + "\"repository\".\"location_type\", " + "\"repository\".\"display_name\", " + "\"repository\".\"priority\", " + "\"repository\".\"interface_url\", " + "\"repository\".\"email\", " + "\"repository\".\"email_comment\", " + "\"repository\".\"summary\", " + "\"repository\".\"description\", " + "\"repository\".\"cache_location_url\", " + "\"repository\".\"cache_location_type\", " + "\"repository\".\"certificate_fingerprint\", " + "\"repository\".\"certificate_name\", " + "\"repository\".\"certificate_organization\", " + "\"repository\".\"certificate_email\", " + "\"repository\".\"certificate_pem\", " + "\"repository\".\"packages_timestamp\", " + "\"repository\".\"repositories_timestamp\", " + "\"repository\".\"internal\", " + "\"repository\".\"buildable\" " + "FROM \"repository\" " + "WHERE \"repository\".\"tenant\"=$1 AND \"repository\".\"canonical_name\"=$2"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::update_statement[] = + "UPDATE \"repository\" " + "SET " + "\"location_url\"=$1, " + "\"location_type\"=$2, " + "\"display_name\"=$3, " + "\"priority\"=$4, " + "\"interface_url\"=$5, " + "\"email\"=$6, " + "\"email_comment\"=$7, " + "\"summary\"=$8, " + "\"description\"=$9, " + "\"cache_location_url\"=$10, " + "\"cache_location_type\"=$11, " + "\"certificate_fingerprint\"=$12, " + "\"certificate_name\"=$13, " + "\"certificate_organization\"=$14, " + "\"certificate_email\"=$15, " + "\"certificate_pem\"=$16, " + "\"packages_timestamp\"=$17, " + "\"repositories_timestamp\"=$18, " + "\"internal\"=$19, " + "\"buildable\"=$20 " + "WHERE \"tenant\"=$21 AND \"canonical_name\"=$22"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::erase_statement[] = + "DELETE FROM \"repository\" " + "WHERE \"tenant\"=$1 AND \"canonical_name\"=$2"; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::query_statement[] = + "SELECT " + "\"repository\".\"tenant\", " + "\"repository\".\"canonical_name\", " + "\"repository\".\"location_url\", " + "\"repository\".\"location_type\", " + "\"repository\".\"display_name\", " + "\"repository\".\"priority\", " + "\"repository\".\"interface_url\", " + "\"repository\".\"email\", " + "\"repository\".\"email_comment\", " + "\"repository\".\"summary\", " + "\"repository\".\"description\", " + "\"repository\".\"cache_location_url\", " + "\"repository\".\"cache_location_type\", " + "\"repository\".\"certificate_fingerprint\", " + "\"repository\".\"certificate_name\", " + "\"repository\".\"certificate_organization\", " + "\"repository\".\"certificate_email\", " + "\"repository\".\"certificate_pem\", " + "\"repository\".\"packages_timestamp\", " + "\"repository\".\"repositories_timestamp\", " + "\"repository\".\"internal\", " + "\"repository\".\"buildable\" " + "FROM \"repository\""; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::erase_query_statement[] = + "DELETE FROM \"repository\""; + + const char access::object_traits_impl< ::brep::repository, id_pgsql >::table_name[] = + "\"repository\""; + + void access::object_traits_impl< ::brep::repository, id_pgsql >:: + persist (database& db, const object_type& obj) + { + ODB_POTENTIALLY_UNUSED (db); + + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + callback (db, + obj, + callback_event::pre_persist); + + image_type& im (sts.image ()); + binding& imb (sts.insert_image_binding ()); + + if (init (im, obj, statement_insert)) + im.version++; + + if (im.version != sts.insert_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_insert); + sts.insert_image_version (im.version); + imb.version++; + } + + insert_statement& st (sts.persist_statement ()); + if (!st.execute ()) + throw object_already_persistent (); + + id_image_type& i (sts.id_image ()); + init (i, id (obj)); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + // complements + // + { + ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > const& v = + obj.complements; + + complements_traits::persist ( + v, + esc.complements); + } + + // prerequisites + // + { + ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > const& v = + obj.prerequisites; + + prerequisites_traits::persist ( + v, + esc.prerequisites); + } + + callback (db, + obj, + callback_event::post_persist); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >:: + update (database& db, const object_type& obj) + { + ODB_POTENTIALLY_UNUSED (db); + + using namespace pgsql; + using pgsql::update_statement; + + callback (db, obj, callback_event::pre_update); + + pgsql::transaction& tr (pgsql::transaction::current ()); + pgsql::connection& conn (tr.connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + id_image_type& idi (sts.id_image ()); + init (idi, id (obj)); + + image_type& im (sts.image ()); + if (init (im, obj, statement_update)) + im.version++; + + bool u (false); + binding& imb (sts.update_image_binding ()); + if (im.version != sts.update_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_update); + sts.update_image_version (im.version); + imb.version++; + u = true; + } + + binding& idb (sts.id_image_binding ()); + if (idi.version != sts.update_id_image_version () || + idb.version == 0) + { + if (idi.version != sts.id_image_version () || + idb.version == 0) + { + bind (idb.bind, idi); + sts.id_image_version (idi.version); + idb.version++; + } + + sts.update_id_image_version (idi.version); + + if (!u) + imb.version++; + } + + update_statement& st (sts.update_statement ()); + if (st.execute () == 0) + throw object_not_persistent (); + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + // complements + // + { + ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > const& v = + obj.complements; + + complements_traits::update ( + v, + esc.complements); + } + + // prerequisites + // + { + ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > const& v = + obj.prerequisites; + + prerequisites_traits::update ( + v, + esc.prerequisites); + } + + callback (db, obj, callback_event::post_update); + pointer_cache_traits::update (db, obj); + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >:: + erase (database& db, const id_type& id) + { + using namespace pgsql; + + ODB_POTENTIALLY_UNUSED (db); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + id_image_type& i (sts.id_image ()); + init (i, id); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + // complements + // + { + complements_traits::erase ( + esc.complements); + } + + // prerequisites + // + { + prerequisites_traits::erase ( + esc.prerequisites); + } + + if (sts.erase_statement ().execute () != 1) + throw object_not_persistent (); + + pointer_cache_traits::erase (db, id); + } + + access::object_traits_impl< ::brep::repository, id_pgsql >::pointer_type + access::object_traits_impl< ::brep::repository, id_pgsql >:: + find (database& db, const id_type& id) + { + using namespace pgsql; + + { + pointer_type p (pointer_cache_traits::find (db, id)); + + if (!pointer_traits::null_ptr (p)) + return p; + } + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + + if (l.locked ()) + { + if (!find_ (sts, &id)) + return pointer_type (); + } + + pointer_type p ( + access::object_factory<object_type, pointer_type>::create ()); + pointer_traits::guard pg (p); + + pointer_cache_traits::insert_guard ig ( + pointer_cache_traits::insert (db, id, p)); + + object_type& obj (pointer_traits::get_ref (p)); + + if (l.locked ()) + { + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, false); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + pointer_cache_traits::load (ig.position ()); + } + else + sts.delay_load (id, obj, ig.position ()); + + ig.release (); + pg.release (); + return p; + } + + bool access::object_traits_impl< ::brep::repository, id_pgsql >:: + find (database& db, const id_type& id, object_type& obj) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + assert (l.locked ()) /* Must be a top-level call. */; + + if (!find_ (sts, &id)) + return false; + + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + reference_cache_traits::position_type pos ( + reference_cache_traits::insert (db, id, obj)); + reference_cache_traits::insert_guard ig (pos); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, false); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + reference_cache_traits::load (pos); + ig.release (); + return true; + } + + bool access::object_traits_impl< ::brep::repository, id_pgsql >:: + reload (database& db, object_type& obj) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + assert (l.locked ()) /* Must be a top-level call. */; + + const id_type& id (object_traits_impl::id (obj)); + if (!find_ (sts, &id)) + return false; + + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, true); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + return true; + } + + bool access::object_traits_impl< ::brep::repository, id_pgsql >:: + find_ (statements_type& sts, + const id_type* id) + { + using namespace pgsql; + + id_image_type& i (sts.id_image ()); + init (i, *id); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + select_statement& st (sts.find_statement ()); + + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + if (grow (im, sts.select_image_truncated ())) + im.version++; + + if (im.version != sts.select_image_version ()) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::repository, id_pgsql >:: + load_ (statements_type& sts, + object_type& obj, + bool reload) + { + ODB_POTENTIALLY_UNUSED (reload); + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + // complements + // + { + ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > >& v = + obj.complements; + + complements_traits::load ( + v, + esc.complements); + } + + // prerequisites + // + { + ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > >& v = + obj.prerequisites; + + prerequisites_traits::load ( + v, + esc.prerequisites); + } + } + + result< access::object_traits_impl< ::brep::repository, id_pgsql >::object_type > + access::object_traits_impl< ::brep::repository, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + std::string text (query_statement); + if (!q.empty ()) + { + text += " "; + text += q.clause (); + } + + q.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + text, + false, + true, + q.parameter_types (), + q.parameter_count (), + q.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::object_result_impl<object_type> > r ( + new (shared) pgsql::object_result_impl<object_type> ( + q, st, sts, 0)); + + return result<object_type> (r); + } + + unsigned long long access::object_traits_impl< ::brep::repository, id_pgsql >:: + erase_query (database&, const query_base_type& q) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + std::string text (erase_query_statement); + if (!q.empty ()) + { + text += ' '; + text += q.clause (); + } + + q.init_parameters (); + delete_statement st ( + conn, + erase_query_statement_name, + text, + q.parameter_types (), + q.parameter_count (), + q.parameters_binding ()); + + return st.execute (); + } + + odb::details::shared_ptr<prepared_query_impl> + access::object_traits_impl< ::brep::repository, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + std::string text (query_statement); + if (!q.empty ()) + { + text += " "; + text += q.clause (); + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = q; + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + text, + false, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::object_traits_impl< ::brep::repository, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::object_result_impl<object_type> ( + pq.query, st, sts, 0)); + } + + // _license_key + // + + bool access::composite_value_traits< ::brep::package::_license_key, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // outer + // + t[0UL] = 0; + + // inner + // + t[1UL] = 0; + + return grew; + } + + void access::composite_value_traits< ::brep::package::_license_key, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // outer + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.outer_value; + b[n].is_null = &i.outer_null; + n++; + + // inner + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.inner_value; + b[n].is_null = &i.inner_null; + n++; + } + + bool access::composite_value_traits< ::brep::package::_license_key, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // outer + // + { + ::brep::package::_licenses_type::key_type::outer_type const& v = + o.outer; + + bool is_null (false); + pgsql::value_traits< + ::brep::package::_licenses_type::key_type::outer_type, + pgsql::id_bigint >::set_image ( + i.outer_value, is_null, v); + i.outer_null = is_null; + } + + // inner + // + { + ::brep::package::_licenses_type::key_type::inner_type const& v = + o.inner; + + bool is_null (false); + pgsql::value_traits< + ::brep::package::_licenses_type::key_type::inner_type, + pgsql::id_bigint >::set_image ( + i.inner_value, is_null, v); + i.inner_null = is_null; + } + + return grew; + } + + void access::composite_value_traits< ::brep::package::_license_key, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // outer + // + { + ::brep::package::_licenses_type::key_type::outer_type& v = + o.outer; + + pgsql::value_traits< + ::brep::package::_licenses_type::key_type::outer_type, + pgsql::id_bigint >::set_value ( + v, + i.outer_value, + i.outer_null); + } + + // inner + // + { + ::brep::package::_licenses_type::key_type::inner_type& v = + o.inner; + + pgsql::value_traits< + ::brep::package::_licenses_type::key_type::inner_type, + pgsql::id_bigint >::set_value ( + v, + i.inner_value, + i.inner_null); + } + } + + // _dependency_key + // + + bool access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // outer + // + t[0UL] = 0; + + // inner + // + t[1UL] = 0; + + return grew; + } + + void access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // outer + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.outer_value; + b[n].is_null = &i.outer_null; + n++; + + // inner + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.inner_value; + b[n].is_null = &i.inner_null; + n++; + } + + bool access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // outer + // + { + ::brep::package::_dependency_key::outer_type const& v = + o.outer; + + bool is_null (false); + pgsql::value_traits< + ::brep::package::_dependency_key::outer_type, + pgsql::id_bigint >::set_image ( + i.outer_value, is_null, v); + i.outer_null = is_null; + } + + // inner + // + { + ::brep::package::_dependency_key::inner_type const& v = + o.inner; + + bool is_null (false); + pgsql::value_traits< + ::brep::package::_dependency_key::inner_type, + pgsql::id_bigint >::set_image ( + i.inner_value, is_null, v); + i.inner_null = is_null; + } + + return grew; + } + + void access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // outer + // + { + ::brep::package::_dependency_key::outer_type& v = + o.outer; + + pgsql::value_traits< + ::brep::package::_dependency_key::outer_type, + pgsql::id_bigint >::set_value ( + v, + i.outer_value, + i.outer_null); + } + + // inner + // + { + ::brep::package::_dependency_key::inner_type& v = + o.inner; + + pgsql::value_traits< + ::brep::package::_dependency_key::inner_type, + pgsql::id_bigint >::set_value ( + v, + i.inner_value, + i.inner_null); + } + } + + // _requirement_key + // + + bool access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // outer + // + t[0UL] = 0; + + // inner + // + t[1UL] = 0; + + return grew; + } + + void access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (b); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + ODB_POTENTIALLY_UNUSED (n); + + // outer + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.outer_value; + b[n].is_null = &i.outer_null; + n++; + + // inner + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.inner_value; + b[n].is_null = &i.inner_null; + n++; + } + + bool access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >:: + init (image_type& i, + const value_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // outer + // + { + ::brep::package::_requirement_key::outer_type const& v = + o.outer; + + bool is_null (false); + pgsql::value_traits< + ::brep::package::_requirement_key::outer_type, + pgsql::id_bigint >::set_image ( + i.outer_value, is_null, v); + i.outer_null = is_null; + } + + // inner + // + { + ::brep::package::_requirement_key::inner_type const& v = + o.inner; + + bool is_null (false); + pgsql::value_traits< + ::brep::package::_requirement_key::inner_type, + pgsql::id_bigint >::set_image ( + i.inner_value, is_null, v); + i.inner_null = is_null; + } + + return grew; + } + + void access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >:: + init (value_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // outer + // + { + ::brep::package::_requirement_key::outer_type& v = + o.outer; + + pgsql::value_traits< + ::brep::package::_requirement_key::outer_type, + pgsql::id_bigint >::set_value ( + v, + i.outer_value, + i.outer_null); + } + + // inner + // + { + ::brep::package::_requirement_key::inner_type& v = + o.inner; + + pgsql::value_traits< + ::brep::package::_requirement_key::inner_type, + pgsql::id_bigint >::set_value ( + v, + i.inner_value, + i.inner_null); + } + } + + // package + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >:: + persist_statement_name[] = "persist_brep_package"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >:: + find_statement_name[] = "find_brep_package"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >:: + update_statement_name[] = "update_brep_package"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >:: + erase_statement_name[] = "erase_brep_package"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >:: + query_statement_name[] = "query_brep_package"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >:: + erase_query_statement_name[] = "erase_query_brep_package"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >:: + persist_statement_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::bool_oid, + pgsql::text_oid, + pgsql::text_oid + }; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >:: + find_statement_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid + }; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >:: + update_statement_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::bool_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid + }; + + const char alias_traits< ::brep::repository, + id_pgsql, + access::object_traits_impl< ::brep::package, id_pgsql >::internal_repository_tag>:: + table_name[] = "\"internal_repository\""; + + struct access::object_traits_impl< ::brep::package, id_pgsql >::extra_statement_cache_type + { + pgsql::container_statements_impl< license_alternatives_traits > license_alternatives; + pgsql::container_statements_impl< licenses_traits > licenses; + pgsql::container_statements_impl< topics_traits > topics; + pgsql::container_statements_impl< keywords_traits > keywords; + pgsql::container_statements_impl< dependencies_traits > dependencies; + pgsql::container_statements_impl< dependency_alternatives_traits > dependency_alternatives; + pgsql::container_statements_impl< requirements_traits > requirements; + pgsql::container_statements_impl< requirement_alternatives_traits > requirement_alternatives; + pgsql::container_statements_impl< tests_traits > tests; + pgsql::container_statements_impl< builds_traits > builds; + pgsql::container_statements_impl< build_constraints_traits > build_constraints; + pgsql::container_statements_impl< other_repositories_traits > other_repositories; + + pgsql::section_statements< ::brep::package, build_section_traits > build_section; + + extra_statement_cache_type ( + pgsql::connection& c, + image_type& im, + id_image_type& idim, + pgsql::binding& id, + pgsql::binding& idv, + pgsql::native_binding& idn, + const unsigned int* idt) + : license_alternatives (c, id, idn, idt), + licenses (c, id, idn, idt), + topics (c, id, idn, idt), + keywords (c, id, idn, idt), + dependencies (c, id, idn, idt), + dependency_alternatives (c, id, idn, idt), + requirements (c, id, idn, idt), + requirement_alternatives (c, id, idn, idt), + tests (c, id, idn, idt), + builds (c, id, idn, idt), + build_constraints (c, id, idn, idt), + other_repositories (c, id, idn, idt), + build_section (c, im, idim, id, idv, idn, idt) + { + } + }; + + // license_alternatives + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + select_name[] = "select_brep_package_license_alternatives"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + insert_name[] = "insert_brep_package_license_alternatives"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + delete_name[] = "delete_brep_package_license_alternatives"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + select_statement[] = + "SELECT " + "\"package_license_alternatives\".\"index\", " + "\"package_license_alternatives\".\"comment\" " + "FROM \"package_license_alternatives\" " + "WHERE \"package_license_alternatives\".\"tenant\"=$1 AND \"package_license_alternatives\".\"name\"=$2::CITEXT AND \"package_license_alternatives\".\"version_epoch\"=$3 AND \"package_license_alternatives\".\"version_canonical_upstream\"=$4 AND \"package_license_alternatives\".\"version_canonical_release\"=$5 AND \"package_license_alternatives\".\"version_revision\"=$6 ORDER BY \"package_license_alternatives\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + insert_statement[] = + "INSERT INTO \"package_license_alternatives\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"comment\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + delete_statement[] = + "DELETE FROM \"package_license_alternatives\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< value_type, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< value_type, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + if (composite_value_traits< value_type, id_pgsql >::init ( + i.value_value, + v, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + composite_value_traits< value_type, id_pgsql >::init ( + v, + i.value_value, + db); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::license_alternatives_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // licenses + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + select_name[] = "select_brep_package_licenses"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + insert_name[] = "insert_brep_package_licenses"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + delete_name[] = "delete_brep_package_licenses"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::int8_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + select_statement[] = + "SELECT " + "\"package_licenses\".\"alternative_index\", " + "\"package_licenses\".\"index\", " + "\"package_licenses\".\"license\" " + "FROM \"package_licenses\" " + "WHERE \"package_licenses\".\"tenant\"=$1 AND \"package_licenses\".\"name\"=$2::CITEXT AND \"package_licenses\".\"version_epoch\"=$3 AND \"package_licenses\".\"version_canonical_upstream\"=$4 AND \"package_licenses\".\"version_canonical_release\"=$5 AND \"package_licenses\".\"version_revision\"=$6"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + insert_statement[] = + "INSERT INTO \"package_licenses\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"alternative_index\", " + "\"index\", " + "\"license\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + delete_statement[] = + "DELETE FROM \"package_licenses\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // key + // + composite_value_traits< key_type, id_pgsql >::bind ( + b + n, d.key_value, sk); + n += 2UL; + + // value + // + b[n].type = pgsql::bind::text; + b[n].buffer = d.value_value.data (); + b[n].capacity = d.value_value.capacity (); + b[n].size = &d.value_size; + b[n].is_null = &d.value_null; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // key + // + if (composite_value_traits< key_type, id_pgsql >::grow ( + i.key_value, t + 0UL)) + grew = true; + + // value + // + if (t[2UL]) + { + i.value_value.capacity (i.value_size); + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + init (data_image_type& i, + const key_type* k, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // key + // + if (k != 0) + { + composite_value_traits< key_type, id_pgsql >::init ( + i.key_value, + *k, + sk); + } + + // value + // + { + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.value_value.capacity ()); + pgsql::value_traits< + value_type, + pgsql::id_string >::set_image ( + i.value_value, + size, + is_null, + v); + i.value_null = is_null; + i.value_size = size; + grew = grew || (cap != i.value_value.capacity ()); + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + init (key_type& k, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // key + // + { + composite_value_traits< key_type, id_pgsql >::init ( + k, + i.key_value, + db); + } + + // value + // + { + pgsql::value_traits< + value_type, + pgsql::id_string >::set_value ( + v, + i.value_value, + i.value_size, + i.value_null); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + insert (const key_type& k, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &k, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + select (key_type& k, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (k, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::licenses_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::erase (fs); + } + + // topics + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + select_name[] = "select_brep_package_topics"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + insert_name[] = "insert_brep_package_topics"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + delete_name[] = "delete_brep_package_topics"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + select_statement[] = + "SELECT " + "\"package_topics\".\"index\", " + "\"package_topics\".\"topic\" " + "FROM \"package_topics\" " + "WHERE \"package_topics\".\"tenant\"=$1 AND \"package_topics\".\"name\"=$2::CITEXT AND \"package_topics\".\"version_epoch\"=$3 AND \"package_topics\".\"version_canonical_upstream\"=$4 AND \"package_topics\".\"version_canonical_release\"=$5 AND \"package_topics\".\"version_revision\"=$6 ORDER BY \"package_topics\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + insert_statement[] = + "INSERT INTO \"package_topics\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"topic\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + delete_statement[] = + "DELETE FROM \"package_topics\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + b[n].type = pgsql::bind::text; + b[n].buffer = d.value_value.data (); + b[n].capacity = d.value_value.capacity (); + b[n].size = &d.value_size; + b[n].is_null = &d.value_null; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (t[1UL]) + { + i.value_value.capacity (i.value_size); + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.value_value.capacity ()); + pgsql::value_traits< + value_type, + pgsql::id_string >::set_image ( + i.value_value, + size, + is_null, + v); + i.value_null = is_null; + i.value_size = size; + grew = grew || (cap != i.value_value.capacity ()); + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + pgsql::value_traits< + value_type, + pgsql::id_string >::set_value ( + v, + i.value_value, + i.value_size, + i.value_null); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::topics_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // keywords + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + select_name[] = "select_brep_package_keywords"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + insert_name[] = "insert_brep_package_keywords"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + delete_name[] = "delete_brep_package_keywords"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + select_statement[] = + "SELECT " + "\"package_keywords\".\"index\", " + "\"package_keywords\".\"keyword\" " + "FROM \"package_keywords\" " + "WHERE \"package_keywords\".\"tenant\"=$1 AND \"package_keywords\".\"name\"=$2::CITEXT AND \"package_keywords\".\"version_epoch\"=$3 AND \"package_keywords\".\"version_canonical_upstream\"=$4 AND \"package_keywords\".\"version_canonical_release\"=$5 AND \"package_keywords\".\"version_revision\"=$6 ORDER BY \"package_keywords\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + insert_statement[] = + "INSERT INTO \"package_keywords\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"keyword\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + delete_statement[] = + "DELETE FROM \"package_keywords\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + b[n].type = pgsql::bind::text; + b[n].buffer = d.value_value.data (); + b[n].capacity = d.value_value.capacity (); + b[n].size = &d.value_size; + b[n].is_null = &d.value_null; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (t[1UL]) + { + i.value_value.capacity (i.value_size); + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.value_value.capacity ()); + pgsql::value_traits< + value_type, + pgsql::id_string >::set_image ( + i.value_value, + size, + is_null, + v); + i.value_null = is_null; + i.value_size = size; + grew = grew || (cap != i.value_value.capacity ()); + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + pgsql::value_traits< + value_type, + pgsql::id_string >::set_value ( + v, + i.value_value, + i.value_size, + i.value_null); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::keywords_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // dependencies + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + select_name[] = "select_brep_package_dependencies"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + insert_name[] = "insert_brep_package_dependencies"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + delete_name[] = "delete_brep_package_dependencies"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::bool_oid, + pgsql::bool_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + select_statement[] = + "SELECT " + "\"package_dependencies\".\"index\", " + "\"package_dependencies\".\"conditional\", " + "\"package_dependencies\".\"buildtime\", " + "\"package_dependencies\".\"comment\" " + "FROM \"package_dependencies\" " + "WHERE \"package_dependencies\".\"tenant\"=$1 AND \"package_dependencies\".\"name\"=$2::CITEXT AND \"package_dependencies\".\"version_epoch\"=$3 AND \"package_dependencies\".\"version_canonical_upstream\"=$4 AND \"package_dependencies\".\"version_canonical_release\"=$5 AND \"package_dependencies\".\"version_revision\"=$6 ORDER BY \"package_dependencies\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + insert_statement[] = + "INSERT INTO \"package_dependencies\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"conditional\", " + "\"buildtime\", " + "\"comment\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + delete_statement[] = + "DELETE FROM \"package_dependencies\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< value_type, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< value_type, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + if (composite_value_traits< value_type, id_pgsql >::init ( + i.value_value, + v, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + composite_value_traits< value_type, id_pgsql >::init ( + v, + i.value_value, + db); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependencies_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // dependency_alternatives + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + select_name[] = "select_brep_package_dependency_alternatives"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + insert_name[] = "insert_brep_package_dependency_alternatives"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + delete_name[] = "delete_brep_package_dependency_alternatives"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::int8_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::bool_oid, + pgsql::bool_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + select_statement[] = + "SELECT " + "\"package_dependency_alternatives\".\"dependency_index\", " + "\"package_dependency_alternatives\".\"index\", " + "\"package_dependency_alternatives\".\"dep_name\"::TEXT, " + "\"package_dependency_alternatives\".\"dep_min_version_epoch\", " + "\"package_dependency_alternatives\".\"dep_min_version_canonical_upstream\", " + "\"package_dependency_alternatives\".\"dep_min_version_canonical_release\", " + "\"package_dependency_alternatives\".\"dep_min_version_revision\", " + "\"package_dependency_alternatives\".\"dep_min_version_upstream\", " + "\"package_dependency_alternatives\".\"dep_min_version_release\", " + "\"package_dependency_alternatives\".\"dep_max_version_epoch\", " + "\"package_dependency_alternatives\".\"dep_max_version_canonical_upstream\", " + "\"package_dependency_alternatives\".\"dep_max_version_canonical_release\", " + "\"package_dependency_alternatives\".\"dep_max_version_revision\", " + "\"package_dependency_alternatives\".\"dep_max_version_upstream\", " + "\"package_dependency_alternatives\".\"dep_max_version_release\", " + "\"package_dependency_alternatives\".\"dep_min_open\", " + "\"package_dependency_alternatives\".\"dep_max_open\", " + "\"package_dependency_alternatives\".\"dep_package_tenant\", " + "\"package_dependency_alternatives\".\"dep_package_name\"::TEXT, " + "\"package_dependency_alternatives\".\"dep_package_version_epoch\", " + "\"package_dependency_alternatives\".\"dep_package_version_canonical_upstream\", " + "\"package_dependency_alternatives\".\"dep_package_version_canonical_release\", " + "\"package_dependency_alternatives\".\"dep_package_version_revision\" " + "FROM \"package_dependency_alternatives\" " + "WHERE \"package_dependency_alternatives\".\"tenant\"=$1 AND \"package_dependency_alternatives\".\"name\"=$2::CITEXT AND \"package_dependency_alternatives\".\"version_epoch\"=$3 AND \"package_dependency_alternatives\".\"version_canonical_upstream\"=$4 AND \"package_dependency_alternatives\".\"version_canonical_release\"=$5 AND \"package_dependency_alternatives\".\"version_revision\"=$6"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + insert_statement[] = + "INSERT INTO \"package_dependency_alternatives\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"dependency_index\", " + "\"index\", " + "\"dep_name\", " + "\"dep_min_version_epoch\", " + "\"dep_min_version_canonical_upstream\", " + "\"dep_min_version_canonical_release\", " + "\"dep_min_version_revision\", " + "\"dep_min_version_upstream\", " + "\"dep_min_version_release\", " + "\"dep_max_version_epoch\", " + "\"dep_max_version_canonical_upstream\", " + "\"dep_max_version_canonical_release\", " + "\"dep_max_version_revision\", " + "\"dep_max_version_upstream\", " + "\"dep_max_version_release\", " + "\"dep_min_open\", " + "\"dep_max_open\", " + "\"dep_package_tenant\", " + "\"dep_package_name\", " + "\"dep_package_version_epoch\", " + "\"dep_package_version_canonical_upstream\", " + "\"dep_package_version_canonical_release\", " + "\"dep_package_version_revision\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9::CITEXT, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25::CITEXT, $26, $27, $28, $29)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + delete_statement[] = + "DELETE FROM \"package_dependency_alternatives\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // key + // + composite_value_traits< key_type, id_pgsql >::bind ( + b + n, d.key_value, sk); + n += 2UL; + + // value + // + composite_value_traits< value_type, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // key + // + if (composite_value_traits< key_type, id_pgsql >::grow ( + i.key_value, t + 0UL)) + grew = true; + + // value + // + if (composite_value_traits< value_type, id_pgsql >::grow ( + i.value_value, t + 2UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + init (data_image_type& i, + const key_type* k, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // key + // + if (k != 0) + { + composite_value_traits< key_type, id_pgsql >::init ( + i.key_value, + *k, + sk); + } + + // value + // + { + if (composite_value_traits< value_type, id_pgsql >::init ( + i.value_value, + v, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + init (key_type& k, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // key + // + { + composite_value_traits< key_type, id_pgsql >::init ( + k, + i.key_value, + db); + } + + // value + // + { + composite_value_traits< value_type, id_pgsql >::init ( + v, + i.value_value, + db); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + insert (const key_type& k, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &k, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + select (key_type& k, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (k, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::dependency_alternatives_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::erase (fs); + } + + // requirements + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + select_name[] = "select_brep_package_requirements"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + insert_name[] = "insert_brep_package_requirements"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + delete_name[] = "delete_brep_package_requirements"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::bool_oid, + pgsql::bool_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + select_statement[] = + "SELECT " + "\"package_requirements\".\"index\", " + "\"package_requirements\".\"conditional\", " + "\"package_requirements\".\"buildtime\", " + "\"package_requirements\".\"comment\" " + "FROM \"package_requirements\" " + "WHERE \"package_requirements\".\"tenant\"=$1 AND \"package_requirements\".\"name\"=$2::CITEXT AND \"package_requirements\".\"version_epoch\"=$3 AND \"package_requirements\".\"version_canonical_upstream\"=$4 AND \"package_requirements\".\"version_canonical_release\"=$5 AND \"package_requirements\".\"version_revision\"=$6 ORDER BY \"package_requirements\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + insert_statement[] = + "INSERT INTO \"package_requirements\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"conditional\", " + "\"buildtime\", " + "\"comment\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + delete_statement[] = + "DELETE FROM \"package_requirements\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< value_type, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< value_type, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + if (composite_value_traits< value_type, id_pgsql >::init ( + i.value_value, + v, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + composite_value_traits< value_type, id_pgsql >::init ( + v, + i.value_value, + db); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirements_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // requirement_alternatives + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + select_name[] = "select_brep_package_requirement_alternatives"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + insert_name[] = "insert_brep_package_requirement_alternatives"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + delete_name[] = "delete_brep_package_requirement_alternatives"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::int8_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + select_statement[] = + "SELECT " + "\"package_requirement_alternatives\".\"requirement_index\", " + "\"package_requirement_alternatives\".\"index\", " + "\"package_requirement_alternatives\".\"id\" " + "FROM \"package_requirement_alternatives\" " + "WHERE \"package_requirement_alternatives\".\"tenant\"=$1 AND \"package_requirement_alternatives\".\"name\"=$2::CITEXT AND \"package_requirement_alternatives\".\"version_epoch\"=$3 AND \"package_requirement_alternatives\".\"version_canonical_upstream\"=$4 AND \"package_requirement_alternatives\".\"version_canonical_release\"=$5 AND \"package_requirement_alternatives\".\"version_revision\"=$6"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + insert_statement[] = + "INSERT INTO \"package_requirement_alternatives\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"requirement_index\", " + "\"index\", " + "\"id\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + delete_statement[] = + "DELETE FROM \"package_requirement_alternatives\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // key + // + composite_value_traits< key_type, id_pgsql >::bind ( + b + n, d.key_value, sk); + n += 2UL; + + // value + // + b[n].type = pgsql::bind::text; + b[n].buffer = d.value_value.data (); + b[n].capacity = d.value_value.capacity (); + b[n].size = &d.value_size; + b[n].is_null = &d.value_null; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // key + // + if (composite_value_traits< key_type, id_pgsql >::grow ( + i.key_value, t + 0UL)) + grew = true; + + // value + // + if (t[2UL]) + { + i.value_value.capacity (i.value_size); + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + init (data_image_type& i, + const key_type* k, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // key + // + if (k != 0) + { + composite_value_traits< key_type, id_pgsql >::init ( + i.key_value, + *k, + sk); + } + + // value + // + { + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.value_value.capacity ()); + pgsql::value_traits< + value_type, + pgsql::id_string >::set_image ( + i.value_value, + size, + is_null, + v); + i.value_null = is_null; + i.value_size = size; + grew = grew || (cap != i.value_value.capacity ()); + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + init (key_type& k, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // key + // + { + composite_value_traits< key_type, id_pgsql >::init ( + k, + i.key_value, + db); + } + + // value + // + { + pgsql::value_traits< + value_type, + pgsql::id_string >::set_value ( + v, + i.value_value, + i.value_size, + i.value_null); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + insert (const key_type& k, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &k, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + select (key_type& k, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (k, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::requirement_alternatives_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + container_traits_type::erase (fs); + } + + // tests + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + select_name[] = "select_brep_package_tests"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + insert_name[] = "insert_brep_package_tests"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + delete_name[] = "delete_brep_package_tests"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::bool_oid, + pgsql::bool_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + select_statement[] = + "SELECT " + "\"package_tests\".\"index\", " + "\"package_tests\".\"test_name\"::TEXT, " + "\"package_tests\".\"test_min_version_epoch\", " + "\"package_tests\".\"test_min_version_canonical_upstream\", " + "\"package_tests\".\"test_min_version_canonical_release\", " + "\"package_tests\".\"test_min_version_revision\", " + "\"package_tests\".\"test_min_version_upstream\", " + "\"package_tests\".\"test_min_version_release\", " + "\"package_tests\".\"test_max_version_epoch\", " + "\"package_tests\".\"test_max_version_canonical_upstream\", " + "\"package_tests\".\"test_max_version_canonical_release\", " + "\"package_tests\".\"test_max_version_revision\", " + "\"package_tests\".\"test_max_version_upstream\", " + "\"package_tests\".\"test_max_version_release\", " + "\"package_tests\".\"test_min_open\", " + "\"package_tests\".\"test_max_open\", " + "\"package_tests\".\"test_package_tenant\", " + "\"package_tests\".\"test_package_name\"::TEXT, " + "\"package_tests\".\"test_package_version_epoch\", " + "\"package_tests\".\"test_package_version_canonical_upstream\", " + "\"package_tests\".\"test_package_version_canonical_release\", " + "\"package_tests\".\"test_package_version_revision\", " + "\"package_tests\".\"test_type\" " + "FROM \"package_tests\" " + "WHERE \"package_tests\".\"tenant\"=$1 AND \"package_tests\".\"name\"=$2::CITEXT AND \"package_tests\".\"version_epoch\"=$3 AND \"package_tests\".\"version_canonical_upstream\"=$4 AND \"package_tests\".\"version_canonical_release\"=$5 AND \"package_tests\".\"version_revision\"=$6 ORDER BY \"package_tests\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + insert_statement[] = + "INSERT INTO \"package_tests\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"test_name\", " + "\"test_min_version_epoch\", " + "\"test_min_version_canonical_upstream\", " + "\"test_min_version_canonical_release\", " + "\"test_min_version_revision\", " + "\"test_min_version_upstream\", " + "\"test_min_version_release\", " + "\"test_max_version_epoch\", " + "\"test_max_version_canonical_upstream\", " + "\"test_max_version_canonical_release\", " + "\"test_max_version_revision\", " + "\"test_max_version_upstream\", " + "\"test_max_version_release\", " + "\"test_min_open\", " + "\"test_max_open\", " + "\"test_package_tenant\", " + "\"test_package_name\", " + "\"test_package_version_epoch\", " + "\"test_package_version_canonical_upstream\", " + "\"test_package_version_canonical_release\", " + "\"test_package_version_revision\", " + "\"test_type\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8::CITEXT, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24::CITEXT, $25, $26, $27, $28, $29)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + delete_statement[] = + "DELETE FROM \"package_tests\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< value_type, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< value_type, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + if (composite_value_traits< value_type, id_pgsql >::init ( + i.value_value, + v, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + composite_value_traits< value_type, id_pgsql >::init ( + v, + i.value_value, + db); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::tests_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // builds + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + select_name[] = "select_brep_package_builds"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + insert_name[] = "insert_brep_package_builds"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + delete_name[] = "delete_brep_package_builds"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::text_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + select_statement[] = + "SELECT " + "\"package_builds\".\"index\", " + "\"package_builds\".\"expression\", " + "\"package_builds\".\"comment\" " + "FROM \"package_builds\" " + "WHERE \"package_builds\".\"tenant\"=$1 AND \"package_builds\".\"name\"=$2::CITEXT AND \"package_builds\".\"version_epoch\"=$3 AND \"package_builds\".\"version_canonical_upstream\"=$4 AND \"package_builds\".\"version_canonical_release\"=$5 AND \"package_builds\".\"version_revision\"=$6 ORDER BY \"package_builds\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + insert_statement[] = + "INSERT INTO \"package_builds\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"expression\", " + "\"comment\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + delete_statement[] = + "DELETE FROM \"package_builds\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< value_type, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< value_type, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + if (composite_value_traits< value_type, id_pgsql >::init ( + i.value_value, + v, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + composite_value_traits< value_type, id_pgsql >::init ( + v, + i.value_value, + db); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::builds_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // build_constraints + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + select_name[] = "select_brep_package_build_constraints"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + insert_name[] = "insert_brep_package_build_constraints"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + delete_name[] = "delete_brep_package_build_constraints"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::bool_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + select_statement[] = + "SELECT " + "\"package_build_constraints\".\"index\", " + "\"package_build_constraints\".\"exclusion\", " + "\"package_build_constraints\".\"config\", " + "\"package_build_constraints\".\"target\", " + "\"package_build_constraints\".\"comment\" " + "FROM \"package_build_constraints\" " + "WHERE \"package_build_constraints\".\"tenant\"=$1 AND \"package_build_constraints\".\"name\"=$2::CITEXT AND \"package_build_constraints\".\"version_epoch\"=$3 AND \"package_build_constraints\".\"version_canonical_upstream\"=$4 AND \"package_build_constraints\".\"version_canonical_release\"=$5 AND \"package_build_constraints\".\"version_revision\"=$6 ORDER BY \"package_build_constraints\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + insert_statement[] = + "INSERT INTO \"package_build_constraints\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"exclusion\", " + "\"config\", " + "\"target\", " + "\"comment\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + delete_statement[] = + "DELETE FROM \"package_build_constraints\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< value_type, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< value_type, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + if (composite_value_traits< value_type, id_pgsql >::init ( + i.value_value, + v, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + composite_value_traits< value_type, id_pgsql >::init ( + v, + i.value_value, + db); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_constraints_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // other_repositories + // + + const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + select_name[] = "select_brep_package_other_repositories"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + insert_name[] = "insert_brep_package_other_repositories"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + delete_name[] = "delete_brep_package_other_repositories"; + + const unsigned int access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + insert_types[] = + { + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::text_oid, + pgsql::text_oid, + pgsql::int4_oid, + pgsql::int8_oid, + pgsql::text_oid, + pgsql::text_oid + }; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + select_statement[] = + "SELECT " + "\"package_other_repositories\".\"index\", " + "\"package_other_repositories\".\"repository_tenant\", " + "\"package_other_repositories\".\"repository_canonical_name\" " + "FROM \"package_other_repositories\" " + "WHERE \"package_other_repositories\".\"tenant\"=$1 AND \"package_other_repositories\".\"name\"=$2::CITEXT AND \"package_other_repositories\".\"version_epoch\"=$3 AND \"package_other_repositories\".\"version_canonical_upstream\"=$4 AND \"package_other_repositories\".\"version_canonical_release\"=$5 AND \"package_other_repositories\".\"version_revision\"=$6 ORDER BY \"package_other_repositories\".\"index\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + insert_statement[] = + "INSERT INTO \"package_other_repositories\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"index\", " + "\"repository_tenant\", " + "\"repository_canonical_name\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + delete_statement[] = + "DELETE FROM \"package_other_repositories\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + bind (pgsql::bind* b, + const pgsql::bind* id, + std::size_t id_size, + data_image_type& d) + { + using namespace pgsql; + + statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + size_t n (0); + + // object_id + // + if (id != 0) + std::memcpy (&b[n], id, id_size * sizeof (id[0])); + n += id_size; + + // index + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &d.index_value; + b[n].is_null = &d.index_null; + n++; + + // value + // + composite_value_traits< ::brep::repository_id, id_pgsql >::bind ( + b + n, d.value_value, sk); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + grow (data_image_type& i, + bool* t) + { + bool grew (false); + + // index + // + t[0UL] = 0; + + // value + // + if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow ( + i.value_value, t + 1UL)) + grew = true; + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + init (data_image_type& i, + index_type* j, + const value_type& v) + { + using namespace pgsql; + + statement_kind sk (statement_insert); + ODB_POTENTIALLY_UNUSED (sk); + + bool grew (false); + + // index + // + if (j != 0) + { + bool is_null (false); + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_image ( + i.index_value, is_null, *j); + i.index_null = is_null; + } + + // value + // + { + typedef object_traits< ::brep::repository > obj_traits; + typedef odb::pointer_traits< value_type > ptr_traits; + + bool is_null (ptr_traits::null_ptr (v)); + if (!is_null) + { + const obj_traits::id_type& ptr_id ( + ptr_traits::object_id< ptr_traits::element_type > (v)); + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + i.value_value, + ptr_id, + sk)) + grew = true; + } + else + throw null_pointer (); + } + + if (grew) + i.version++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + init (index_type& j, + value_type& v, + const data_image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (db); + + // index + // + { + pgsql::value_traits< + index_type, + pgsql::id_bigint >::set_value ( + j, + i.index_value, + i.index_null); + } + + // value + // + { + typedef object_traits< ::brep::repository > obj_traits; + typedef odb::pointer_traits< value_type > ptr_traits; + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null ( + i.value_value)) + v = ptr_traits::pointer_type (); + else + { + obj_traits::id_type ptr_id; + composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + ptr_id, + i.value_value, + db); + + v = ptr_traits::pointer_type ( + *static_cast<pgsql::database*> (db), ptr_id); + } + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + insert (index_type i, const value_type& v, void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (di, &i, v); + + if (sts.data_binding_test_version ()) + { + const binding& id (sts.id_binding ()); + bind (sts.data_bind (), id.bind, id.count, di); + sts.data_binding_update_version (); + } + + if (!sts.insert_statement ().execute ()) + throw object_already_persistent (); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + select (index_type& i, value_type& v, void* d) + { + using namespace pgsql; + using pgsql::select_statement; + + statements_type& sts (*static_cast< statements_type* > (d)); + data_image_type& di (sts.data_image ()); + + init (i, v, di, &sts.connection ().database ()); + + select_statement& st (sts.select_statement ()); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, sts.id_binding ().count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + delete_ (void* d) + { + using namespace pgsql; + + statements_type& sts (*static_cast< statements_type* > (d)); + sts.delete_statement ().execute (); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + persist (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::persist (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + load (container_type& c, + statements_type& sts) + { + using namespace pgsql; + using pgsql::select_statement; + + const binding& id (sts.id_binding ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), id.bind, id.count, sts.data_image ()); + sts.data_binding_update_version (); + } + + select_statement& st (sts.select_statement ()); + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + data_image_type& di (sts.data_image ()); + grow (di, sts.select_image_truncated ()); + + if (sts.data_binding_test_version ()) + { + bind (sts.data_bind (), 0, id.count, di); + sts.data_binding_update_version (); + st.refetch (); + } + } + + bool more (r != select_statement::no_data); + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::load (c, more, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + update (const container_type& c, + statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::update (c, fs); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::other_repositories_traits:: + erase (statements_type& sts) + { + using namespace pgsql; + + functions_type& fs (sts.functions ()); + fs.ordered_ = true; + container_traits_type::erase (fs); + } + + // build_section + // + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_section_traits:: + load (extra_statement_cache_type& esc, object_type& obj) + { + // builds + // + { + ::brep::build_class_exprs& v = + obj.builds; + + builds_traits::load ( + v, + esc.builds); + } + + // build_constraints + // + { + ::brep::package::build_constraints_type& v = + obj.build_constraints; + + build_constraints_traits::load ( + v, + esc.build_constraints); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >::build_section_traits:: + update (extra_statement_cache_type& esc, const object_type& obj) + { + // builds + // + { + ::brep::build_class_exprs const& v = + obj.builds; + + builds_traits::update ( + v, + esc.builds); + } + + // build_constraints + // + { + ::brep::package::build_constraints_type const& v = + obj.build_constraints; + + build_constraints_traits::update ( + v, + esc.build_constraints); + } + } + + access::object_traits_impl< ::brep::package, id_pgsql >::id_type + access::object_traits_impl< ::brep::package, id_pgsql >:: + id (const image_type& i) + { + pgsql::database* db (0); + ODB_POTENTIALLY_UNUSED (db); + + id_type id; + { + composite_value_traits< ::brep::package_id, id_pgsql >::init ( + id, + i.id_value, + db); + } + + return id; + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // id + // + if (composite_value_traits< ::brep::package_id, id_pgsql >::grow ( + i.id_value, t + 0UL)) + grew = true; + + // version + // + if (composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::grow ( + i.version_value, t + 6UL)) + grew = true; + + // upstream_version + // + if (t[8UL]) + { + i.upstream_version_value.capacity (i.upstream_version_size); + grew = true; + } + + // project + // + if (t[9UL]) + { + i.project_value.capacity (i.project_size); + grew = true; + } + + // priority + // + if (composite_value_traits< ::brep::package::priority_type, id_pgsql >::grow ( + i.priority_value, t + 10UL)) + grew = true; + + // summary + // + if (t[12UL]) + { + i.summary_value.capacity (i.summary_size); + grew = true; + } + + // description + // + if (t[13UL]) + { + i.description_value.capacity (i.description_size); + grew = true; + } + + // description_type + // + if (t[14UL]) + { + i.description_type_value.capacity (i.description_type_size); + grew = true; + } + + // changes + // + if (t[15UL]) + { + i.changes_value.capacity (i.changes_size); + grew = true; + } + + // url + // + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::grow ( + i.url_value, t + 16UL)) + grew = true; + + // doc_url + // + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::grow ( + i.doc_url_value, t + 18UL)) + grew = true; + + // src_url + // + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::grow ( + i.src_url_value, t + 20UL)) + grew = true; + + // package_url + // + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::grow ( + i.package_url_value, t + 22UL)) + grew = true; + + // email + // + if (composite_value_traits< ::bpkg::email, id_pgsql >::grow ( + i.email_value, t + 24UL)) + grew = true; + + // package_email + // + if (composite_value_traits< ::bpkg::email, id_pgsql >::grow ( + i.package_email_value, t + 26UL)) + grew = true; + + // build_email + // + if (composite_value_traits< ::bpkg::email, id_pgsql >::grow ( + i.build_email_value, t + 28UL)) + grew = true; + + // build_warning_email + // + if (composite_value_traits< ::bpkg::email, id_pgsql >::grow ( + i.build_warning_email_value, t + 30UL)) + grew = true; + + // build_error_email + // + if (composite_value_traits< ::bpkg::email, id_pgsql >::grow ( + i.build_error_email_value, t + 32UL)) + grew = true; + + // internal_repository + // + if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow ( + i.internal_repository_value, t + 34UL)) + grew = true; + + // location + // + if (t[36UL]) + { + i.location_value.capacity (i.location_size); + grew = true; + } + + // fragment + // + if (t[37UL]) + { + i.fragment_value.capacity (i.fragment_size); + grew = true; + } + + // sha256sum + // + if (t[38UL]) + { + i.sha256sum_value.capacity (i.sha256sum_size); + grew = true; + } + + // buildable + // + t[39UL] = 0; + + // unbuildable_reason + // + if (t[40UL]) + { + i.unbuildable_reason_value.capacity (i.unbuildable_reason_size); + grew = true; + } + + // search_index + // + if (t[41UL]) + { + i.search_index_value.capacity (i.search_index_size); + grew = true; + } + + return grew; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + std::size_t n (0); + + // id + // + if (sk != statement_update) + { + composite_value_traits< ::brep::package_id, id_pgsql >::bind ( + b + n, i.id_value, sk); + n += 6UL; + } + + // version + // + composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::bind ( + b + n, i.version_value, sk); + n += 2UL; + + // upstream_version + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.upstream_version_value.data (); + b[n].capacity = i.upstream_version_value.capacity (); + b[n].size = &i.upstream_version_size; + b[n].is_null = &i.upstream_version_null; + n++; + + // project + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.project_value.data (); + b[n].capacity = i.project_value.capacity (); + b[n].size = &i.project_size; + b[n].is_null = &i.project_null; + n++; + + // priority + // + composite_value_traits< ::brep::package::priority_type, id_pgsql >::bind ( + b + n, i.priority_value, sk); + n += 2UL; + + // summary + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.summary_value.data (); + b[n].capacity = i.summary_value.capacity (); + b[n].size = &i.summary_size; + b[n].is_null = &i.summary_null; + n++; + + // description + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.description_value.data (); + b[n].capacity = i.description_value.capacity (); + b[n].size = &i.description_size; + b[n].is_null = &i.description_null; + n++; + + // description_type + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.description_type_value.data (); + b[n].capacity = i.description_type_value.capacity (); + b[n].size = &i.description_type_size; + b[n].is_null = &i.description_type_null; + n++; + + // changes + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.changes_value.data (); + b[n].capacity = i.changes_value.capacity (); + b[n].size = &i.changes_size; + b[n].is_null = &i.changes_null; + n++; + + // url + // + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::bind ( + b + n, i.url_value, sk); + n += 2UL; + + // doc_url + // + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::bind ( + b + n, i.doc_url_value, sk); + n += 2UL; + + // src_url + // + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::bind ( + b + n, i.src_url_value, sk); + n += 2UL; + + // package_url + // + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::bind ( + b + n, i.package_url_value, sk); + n += 2UL; + + // email + // + composite_value_traits< ::bpkg::email, id_pgsql >::bind ( + b + n, i.email_value, sk); + n += 2UL; + + // package_email + // + composite_value_traits< ::bpkg::email, id_pgsql >::bind ( + b + n, i.package_email_value, sk); + n += 2UL; + + // build_email + // + composite_value_traits< ::bpkg::email, id_pgsql >::bind ( + b + n, i.build_email_value, sk); + n += 2UL; + + // build_warning_email + // + composite_value_traits< ::bpkg::email, id_pgsql >::bind ( + b + n, i.build_warning_email_value, sk); + n += 2UL; + + // build_error_email + // + composite_value_traits< ::bpkg::email, id_pgsql >::bind ( + b + n, i.build_error_email_value, sk); + n += 2UL; + + // internal_repository + // + composite_value_traits< ::brep::repository_id, id_pgsql >::bind ( + b + n, i.internal_repository_value, sk); + n += 2UL; + + // location + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.location_value.data (); + b[n].capacity = i.location_value.capacity (); + b[n].size = &i.location_size; + b[n].is_null = &i.location_null; + n++; + + // fragment + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.fragment_value.data (); + b[n].capacity = i.fragment_value.capacity (); + b[n].size = &i.fragment_size; + b[n].is_null = &i.fragment_null; + n++; + + // sha256sum + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.sha256sum_value.data (); + b[n].capacity = i.sha256sum_value.capacity (); + b[n].size = &i.sha256sum_size; + b[n].is_null = &i.sha256sum_null; + n++; + + // buildable + // + b[n].type = pgsql::bind::boolean_; + b[n].buffer = &i.buildable_value; + b[n].is_null = &i.buildable_null; + n++; + + // unbuildable_reason + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.unbuildable_reason_value.data (); + b[n].capacity = i.unbuildable_reason_value.capacity (); + b[n].size = &i.unbuildable_reason_size; + b[n].is_null = &i.unbuildable_reason_null; + n++; + + // search_index + // + b[n].type = pgsql::bind::text; + b[n].buffer = i.search_index_value.data (); + b[n].capacity = i.search_index_value.capacity (); + b[n].size = &i.search_index_size; + b[n].is_null = &i.search_index_null; + n++; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >:: + bind (pgsql::bind* b, id_image_type& i) + { + std::size_t n (0); + pgsql::statement_kind sk (pgsql::statement_select); + composite_value_traits< ::brep::package_id, id_pgsql >::bind ( + b + n, i.id_value, sk); + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >:: + init (image_type& i, + const object_type& o, + pgsql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace pgsql; + + bool grew (false); + + // id + // + if (sk == statement_insert) + { + ::brep::package_id const& v = + o.id; + + if (composite_value_traits< ::brep::package_id, id_pgsql >::init ( + i.id_value, + v, + sk)) + grew = true; + } + + // version + // + { + ::brep::package::upstream_version_type const& v = + o.version; + + if (composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::init ( + i.version_value, + v, + sk)) + grew = true; + } + + // upstream_version + // + { + ::butl::optional< ::std::basic_string< char > > const& v = + o.upstream_version; + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.upstream_version_value.capacity ()); + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_image ( + i.upstream_version_value, + size, + is_null, + v); + i.upstream_version_null = is_null; + i.upstream_version_size = size; + grew = grew || (cap != i.upstream_version_value.capacity ()); + } + + // project + // + { + ::bpkg::package_name const& v = + o.project; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.project_value.capacity ()); + pgsql::value_traits< + ::bpkg::package_name, + pgsql::id_string >::set_image ( + i.project_value, + size, + is_null, + v); + i.project_null = is_null; + i.project_size = size; + grew = grew || (cap != i.project_value.capacity ()); + } + + // priority + // + { + ::brep::package::priority_type const& v = + o.priority; + + if (composite_value_traits< ::brep::package::priority_type, id_pgsql >::init ( + i.priority_value, + v, + sk)) + grew = true; + } + + // summary + // + { + ::std::string const& v = + o.summary; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.summary_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.summary_value, + size, + is_null, + v); + i.summary_null = is_null; + i.summary_size = size; + grew = grew || (cap != i.summary_value.capacity ()); + } + + // description + // + { + ::butl::optional< ::std::basic_string< char > > const& v = + o.description; + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.description_value.capacity ()); + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_image ( + i.description_value, + size, + is_null, + v); + i.description_null = is_null; + i.description_size = size; + grew = grew || (cap != i.description_value.capacity ()); + } + + // description_type + // + { + ::butl::optional< ::bpkg::text_type > const& v = + o.description_type; + + // From package.hxx:58:14 + ::brep::optional_string const& vt = + (v) ? to_string ( * (v)) : brep::optional_string (); + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.description_type_value.capacity ()); + pgsql::value_traits< + ::brep::optional_string, + pgsql::id_string >::set_image ( + i.description_type_value, + size, + is_null, + vt); + i.description_type_null = is_null; + i.description_type_size = size; + grew = grew || (cap != i.description_type_value.capacity ()); + } + + // changes + // + { + ::std::string const& v = + o.changes; + + bool is_null (false); + std::size_t size (0); + std::size_t cap (i.changes_value.capacity ()); + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_image ( + i.changes_value, + size, + is_null, + v); + i.changes_null = is_null; + i.changes_size = size; + grew = grew || (cap != i.changes_value.capacity ()); + } + + // url + // + { + ::butl::optional< ::bpkg::manifest_url > const& v = + o.url; + + if (wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_null (v)) + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::set_null ( + i.url_value, sk); + else + { + const::bpkg::manifest_url& vw = + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_ref (v); + + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init ( + i.url_value, + vw, + sk)) + grew = true; + } + } + + // doc_url + // + { + ::butl::optional< ::bpkg::manifest_url > const& v = + o.doc_url; + + if (wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_null (v)) + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::set_null ( + i.doc_url_value, sk); + else + { + const::bpkg::manifest_url& vw = + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_ref (v); + + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init ( + i.doc_url_value, + vw, + sk)) + grew = true; + } + } + + // src_url + // + { + ::butl::optional< ::bpkg::manifest_url > const& v = + o.src_url; + + if (wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_null (v)) + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::set_null ( + i.src_url_value, sk); + else + { + const::bpkg::manifest_url& vw = + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_ref (v); + + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init ( + i.src_url_value, + vw, + sk)) + grew = true; + } + } + + // package_url + // + { + ::butl::optional< ::bpkg::manifest_url > const& v = + o.package_url; + + if (wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_null (v)) + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::set_null ( + i.package_url_value, sk); + else + { + const::bpkg::manifest_url& vw = + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::get_ref (v); + + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init ( + i.package_url_value, + vw, + sk)) + grew = true; + } + } + + // email + // + { + ::butl::optional< ::bpkg::email > const& v = + o.email; + + if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v)) + composite_value_traits< ::bpkg::email, id_pgsql >::set_null ( + i.email_value, sk); + else + { + const::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v); + + if (composite_value_traits< ::bpkg::email, id_pgsql >::init ( + i.email_value, + vw, + sk)) + grew = true; + } + } + + // package_email + // + { + ::butl::optional< ::bpkg::email > const& v = + o.package_email; + + if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v)) + composite_value_traits< ::bpkg::email, id_pgsql >::set_null ( + i.package_email_value, sk); + else + { + const::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v); + + if (composite_value_traits< ::bpkg::email, id_pgsql >::init ( + i.package_email_value, + vw, + sk)) + grew = true; + } + } + + // build_email + // + { + ::butl::optional< ::bpkg::email > const& v = + o.build_email; + + if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v)) + composite_value_traits< ::bpkg::email, id_pgsql >::set_null ( + i.build_email_value, sk); + else + { + const::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v); + + if (composite_value_traits< ::bpkg::email, id_pgsql >::init ( + i.build_email_value, + vw, + sk)) + grew = true; + } + } + + // build_warning_email + // + { + ::butl::optional< ::bpkg::email > const& v = + o.build_warning_email; + + if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v)) + composite_value_traits< ::bpkg::email, id_pgsql >::set_null ( + i.build_warning_email_value, sk); + else + { + const::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v); + + if (composite_value_traits< ::bpkg::email, id_pgsql >::init ( + i.build_warning_email_value, + vw, + sk)) + grew = true; + } + } + + // build_error_email + // + { + ::butl::optional< ::bpkg::email > const& v = + o.build_error_email; + + if (wrapper_traits< ::butl::optional< ::bpkg::email > >::get_null (v)) + composite_value_traits< ::bpkg::email, id_pgsql >::set_null ( + i.build_error_email_value, sk); + else + { + const::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::get_ref (v); + + if (composite_value_traits< ::bpkg::email, id_pgsql >::init ( + i.build_error_email_value, + vw, + sk)) + grew = true; + } + } + + // internal_repository + // + { + ::odb::lazy_shared_ptr< ::brep::repository > const& v = + o.internal_repository; + + typedef object_traits< ::brep::repository > obj_traits; + typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::repository > > ptr_traits; + + bool is_null (ptr_traits::null_ptr (v)); + if (!is_null) + { + const obj_traits::id_type& ptr_id ( + ptr_traits::object_id< ptr_traits::element_type > (v)); + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + i.internal_repository_value, + ptr_id, + sk)) + grew = true; + } + else + composite_value_traits< obj_traits::id_type, id_pgsql >::set_null (i.internal_repository_value, sk); + } + + // location + // + { + ::butl::optional< ::butl::basic_path< char, ::butl::any_path_kind< char > > > const& v = + o.location; + + // From common.hxx:101:14 + ::brep::optional_string const& vt = + (v) ? (v)->string () : brep::optional_string (); + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.location_value.capacity ()); + pgsql::value_traits< + ::brep::optional_string, + pgsql::id_string >::set_image ( + i.location_value, + size, + is_null, + vt); + i.location_null = is_null; + i.location_size = size; + grew = grew || (cap != i.location_value.capacity ()); + } + + // fragment + // + { + ::butl::optional< ::std::basic_string< char > > const& v = + o.fragment; + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.fragment_value.capacity ()); + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_image ( + i.fragment_value, + size, + is_null, + v); + i.fragment_null = is_null; + i.fragment_size = size; + grew = grew || (cap != i.fragment_value.capacity ()); + } + + // sha256sum + // + { + ::butl::optional< ::std::basic_string< char > > const& v = + o.sha256sum; + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.sha256sum_value.capacity ()); + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_image ( + i.sha256sum_value, + size, + is_null, + v); + i.sha256sum_null = is_null; + i.sha256sum_size = size; + grew = grew || (cap != i.sha256sum_value.capacity ()); + } + + // buildable + // + { + bool const& v = + o.buildable; + + bool is_null (false); + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_image ( + i.buildable_value, is_null, v); + i.buildable_null = is_null; + } + + // unbuildable_reason + // + { + ::butl::optional< ::brep::unbuildable_reason > const& v = + o.unbuildable_reason; + + // From common.hxx:352:14 + ::brep::optional_string const& vt = + (v) ? to_string ( * (v)) : brep::optional_string (); + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.unbuildable_reason_value.capacity ()); + pgsql::value_traits< + ::brep::optional_string, + pgsql::id_string >::set_image ( + i.unbuildable_reason_value, + size, + is_null, + vt); + i.unbuildable_reason_null = is_null; + i.unbuildable_reason_size = size; + grew = grew || (cap != i.unbuildable_reason_value.capacity ()); + } + + // search_index + // + { + // From package.hxx:610:7 + ::brep::weighted_text const& v = + o.search_text (); + + bool is_null (true); + std::size_t size (0); + std::size_t cap (i.search_index_value.capacity ()); + pgsql::value_traits< + ::brep::weighted_text, + pgsql::id_string >::set_image ( + i.search_index_value, + size, + is_null, + v); + i.search_index_null = is_null; + i.search_index_size = size; + grew = grew || (cap != i.search_index_value.capacity ()); + } + + return grew; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >:: + init (object_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // id + // + { + ::brep::package_id& v = + o.id; + + composite_value_traits< ::brep::package_id, id_pgsql >::init ( + v, + i.id_value, + db); + } + + // version + // + { + // From package.hxx:523:32 + ::brep::package::upstream_version_type v; + + composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::init ( + v, + i.version_value, + db); + + // From package.hxx:523:32 + o.version.init (o.id.version, (v)); + } + + // upstream_version + // + { + ::butl::optional< ::std::basic_string< char > >& v = + o.upstream_version; + + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_value ( + v, + i.upstream_version_value, + i.upstream_version_size, + i.upstream_version_null); + } + + // project + // + { + ::bpkg::package_name& v = + o.project; + + pgsql::value_traits< + ::bpkg::package_name, + pgsql::id_string >::set_value ( + v, + i.project_value, + i.project_size, + i.project_null); + } + + // priority + // + { + ::brep::package::priority_type& v = + o.priority; + + composite_value_traits< ::brep::package::priority_type, id_pgsql >::init ( + v, + i.priority_value, + db); + } + + // summary + // + { + ::std::string& v = + o.summary; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.summary_value, + i.summary_size, + i.summary_null); + } + + // description + // + { + ::butl::optional< ::std::basic_string< char > >& v = + o.description; + + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_value ( + v, + i.description_value, + i.description_size, + i.description_null); + } + + // description_type + // + { + ::butl::optional< ::bpkg::text_type >& v = + o.description_type; + + ::brep::optional_string vt; + + pgsql::value_traits< + ::brep::optional_string, + pgsql::id_string >::set_value ( + vt, + i.description_type_value, + i.description_type_size, + i.description_type_null); + + // From package.hxx:58:14 + v = (vt) ? brep::to_text_type ( * (vt)) : brep::optional_text_type (); + } + + // changes + // + { + ::std::string& v = + o.changes; + + pgsql::value_traits< + ::std::string, + pgsql::id_string >::set_value ( + v, + i.changes_value, + i.changes_size, + i.changes_null); + } + + // url + // + { + ::butl::optional< ::bpkg::manifest_url >& v = + o.url; + + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::get_null ( + i.url_value)) + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_null (v); + else + { + ::bpkg::manifest_url& vw = + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_ref (v); + + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init ( + vw, + i.url_value, + db); + } + } + + // doc_url + // + { + ::butl::optional< ::bpkg::manifest_url >& v = + o.doc_url; + + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::get_null ( + i.doc_url_value)) + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_null (v); + else + { + ::bpkg::manifest_url& vw = + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_ref (v); + + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init ( + vw, + i.doc_url_value, + db); + } + } + + // src_url + // + { + ::butl::optional< ::bpkg::manifest_url >& v = + o.src_url; + + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::get_null ( + i.src_url_value)) + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_null (v); + else + { + ::bpkg::manifest_url& vw = + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_ref (v); + + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init ( + vw, + i.src_url_value, + db); + } + } + + // package_url + // + { + ::butl::optional< ::bpkg::manifest_url >& v = + o.package_url; + + if (composite_value_traits< ::bpkg::manifest_url, id_pgsql >::get_null ( + i.package_url_value)) + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_null (v); + else + { + ::bpkg::manifest_url& vw = + wrapper_traits< ::butl::optional< ::bpkg::manifest_url > >::set_ref (v); + + composite_value_traits< ::bpkg::manifest_url, id_pgsql >::init ( + vw, + i.package_url_value, + db); + } + } + + // email + // + { + ::butl::optional< ::bpkg::email >& v = + o.email; + + if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null ( + i.email_value)) + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v); + else + { + ::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v); + + composite_value_traits< ::bpkg::email, id_pgsql >::init ( + vw, + i.email_value, + db); + } + } + + // package_email + // + { + ::butl::optional< ::bpkg::email >& v = + o.package_email; + + if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null ( + i.package_email_value)) + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v); + else + { + ::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v); + + composite_value_traits< ::bpkg::email, id_pgsql >::init ( + vw, + i.package_email_value, + db); + } + } + + // build_email + // + { + ::butl::optional< ::bpkg::email >& v = + o.build_email; + + if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null ( + i.build_email_value)) + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v); + else + { + ::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v); + + composite_value_traits< ::bpkg::email, id_pgsql >::init ( + vw, + i.build_email_value, + db); + } + } + + // build_warning_email + // + { + ::butl::optional< ::bpkg::email >& v = + o.build_warning_email; + + if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null ( + i.build_warning_email_value)) + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v); + else + { + ::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v); + + composite_value_traits< ::bpkg::email, id_pgsql >::init ( + vw, + i.build_warning_email_value, + db); + } + } + + // build_error_email + // + { + ::butl::optional< ::bpkg::email >& v = + o.build_error_email; + + if (composite_value_traits< ::bpkg::email, id_pgsql >::get_null ( + i.build_error_email_value)) + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_null (v); + else + { + ::bpkg::email& vw = + wrapper_traits< ::butl::optional< ::bpkg::email > >::set_ref (v); + + composite_value_traits< ::bpkg::email, id_pgsql >::init ( + vw, + i.build_error_email_value, + db); + } + } + + // internal_repository + // + { + ::odb::lazy_shared_ptr< ::brep::repository >& v = + o.internal_repository; + + typedef object_traits< ::brep::repository > obj_traits; + typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::repository > > ptr_traits; + + if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null ( + i.internal_repository_value)) + v = ptr_traits::pointer_type (); + else + { + obj_traits::id_type ptr_id; + composite_value_traits< obj_traits::id_type, id_pgsql >::init ( + ptr_id, + i.internal_repository_value, + db); + + v = ptr_traits::pointer_type ( + *static_cast<pgsql::database*> (db), ptr_id); + } + } + + // location + // + { + ::butl::optional< ::butl::basic_path< char, ::butl::any_path_kind< char > > >& v = + o.location; + + ::brep::optional_string vt; + + pgsql::value_traits< + ::brep::optional_string, + pgsql::id_string >::set_value ( + vt, + i.location_value, + i.location_size, + i.location_null); + + // From common.hxx:101:14 + v = (vt) ? brep::path ( * (vt)) : brep::optional_path (); + } + + // fragment + // + { + ::butl::optional< ::std::basic_string< char > >& v = + o.fragment; + + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_value ( + v, + i.fragment_value, + i.fragment_size, + i.fragment_null); + } + + // sha256sum + // + { + ::butl::optional< ::std::basic_string< char > >& v = + o.sha256sum; + + pgsql::value_traits< + ::butl::optional< ::std::basic_string< char > >, + pgsql::id_string >::set_value ( + v, + i.sha256sum_value, + i.sha256sum_size, + i.sha256sum_null); + } + + // buildable + // + { + bool& v = + o.buildable; + + pgsql::value_traits< + bool, + pgsql::id_boolean >::set_value ( + v, + i.buildable_value, + i.buildable_null); + } + + // unbuildable_reason + // + { + ::butl::optional< ::brep::unbuildable_reason >& v = + o.unbuildable_reason; + + ::brep::optional_string vt; + + pgsql::value_traits< + ::brep::optional_string, + pgsql::id_string >::set_value ( + vt, + i.unbuildable_reason_value, + i.unbuildable_reason_size, + i.unbuildable_reason_null); + + // From common.hxx:352:14 + v = (vt) ? brep::to_unbuildable_reason ( * (vt)) : brep::optional_unbuildable_reason (); + } + + // search_index + // + { + // From package.hxx:610:7 + ::brep::weighted_text v; + + pgsql::value_traits< + ::brep::weighted_text, + pgsql::id_string >::set_value ( + v, + i.search_index_value, + i.search_index_size, + i.search_index_null); + + // From package.hxx:610:7 + o.search_text (v); + } + } + + void access::object_traits_impl< ::brep::package, id_pgsql >:: + init (id_image_type& i, const id_type& id) + { + bool grew (false); + pgsql::statement_kind sk (pgsql::statement_select); + { + if (composite_value_traits< ::brep::package_id, id_pgsql >::init ( + i.id_value, + id, + sk)) + grew = true; + } + + if (grew) + i.version++; + } + + const char access::object_traits_impl< ::brep::package, id_pgsql >::persist_statement[] = + "INSERT INTO \"package\" " + "(\"tenant\", " + "\"name\", " + "\"version_epoch\", " + "\"version_canonical_upstream\", " + "\"version_canonical_release\", " + "\"version_revision\", " + "\"version_upstream\", " + "\"version_release\", " + "\"upstream_version\", " + "\"project\", " + "\"priority\", " + "\"priority_comment\", " + "\"summary\", " + "\"description\", " + "\"description_type\", " + "\"changes\", " + "\"url\", " + "\"url_comment\", " + "\"doc_url\", " + "\"doc_url_comment\", " + "\"src_url\", " + "\"src_url_comment\", " + "\"package_url\", " + "\"package_url_comment\", " + "\"email\", " + "\"email_comment\", " + "\"package_email\", " + "\"package_email_comment\", " + "\"build_email\", " + "\"build_email_comment\", " + "\"build_warning_email\", " + "\"build_warning_email_comment\", " + "\"build_error_email\", " + "\"build_error_email_comment\", " + "\"internal_repository_tenant\", " + "\"internal_repository_canonical_name\", " + "\"location\", " + "\"fragment\", " + "\"sha256sum\", " + "\"buildable\", " + "\"unbuildable_reason\", " + "\"search_index\") " + "VALUES " + "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10::CITEXT, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28, $29, $30, $31, $32, $33, $34, $35, $36, $37, $38, $39, $40, $41, to_tsvector($42::weighted_text))"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::find_statement[] = + "SELECT " + "\"package\".\"tenant\", " + "\"package\".\"name\"::TEXT, " + "\"package\".\"version_epoch\", " + "\"package\".\"version_canonical_upstream\", " + "\"package\".\"version_canonical_release\", " + "\"package\".\"version_revision\", " + "\"package\".\"version_upstream\", " + "\"package\".\"version_release\", " + "\"package\".\"upstream_version\", " + "\"package\".\"project\"::TEXT, " + "\"package\".\"priority\", " + "\"package\".\"priority_comment\", " + "\"package\".\"summary\", " + "\"package\".\"description\", " + "\"package\".\"description_type\", " + "\"package\".\"changes\", " + "\"package\".\"url\", " + "\"package\".\"url_comment\", " + "\"package\".\"doc_url\", " + "\"package\".\"doc_url_comment\", " + "\"package\".\"src_url\", " + "\"package\".\"src_url_comment\", " + "\"package\".\"package_url\", " + "\"package\".\"package_url_comment\", " + "\"package\".\"email\", " + "\"package\".\"email_comment\", " + "\"package\".\"package_email\", " + "\"package\".\"package_email_comment\", " + "\"package\".\"build_email\", " + "\"package\".\"build_email_comment\", " + "\"package\".\"build_warning_email\", " + "\"package\".\"build_warning_email_comment\", " + "\"package\".\"build_error_email\", " + "\"package\".\"build_error_email_comment\", " + "\"package\".\"internal_repository_tenant\", " + "\"package\".\"internal_repository_canonical_name\", " + "\"package\".\"location\", " + "\"package\".\"fragment\", " + "\"package\".\"sha256sum\", " + "\"package\".\"buildable\", " + "\"package\".\"unbuildable_reason\", " + "COALESCE('',\"package\".\"search_index\") " + "FROM \"package\" " + "WHERE \"package\".\"tenant\"=$1 AND \"package\".\"name\"=$2::CITEXT AND \"package\".\"version_epoch\"=$3 AND \"package\".\"version_canonical_upstream\"=$4 AND \"package\".\"version_canonical_release\"=$5 AND \"package\".\"version_revision\"=$6"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::update_statement[] = + "UPDATE \"package\" " + "SET " + "\"version_upstream\"=$1, " + "\"version_release\"=$2, " + "\"upstream_version\"=$3, " + "\"project\"=$4::CITEXT, " + "\"priority\"=$5, " + "\"priority_comment\"=$6, " + "\"summary\"=$7, " + "\"description\"=$8, " + "\"description_type\"=$9, " + "\"changes\"=$10, " + "\"url\"=$11, " + "\"url_comment\"=$12, " + "\"doc_url\"=$13, " + "\"doc_url_comment\"=$14, " + "\"src_url\"=$15, " + "\"src_url_comment\"=$16, " + "\"package_url\"=$17, " + "\"package_url_comment\"=$18, " + "\"email\"=$19, " + "\"email_comment\"=$20, " + "\"package_email\"=$21, " + "\"package_email_comment\"=$22, " + "\"build_email\"=$23, " + "\"build_email_comment\"=$24, " + "\"build_warning_email\"=$25, " + "\"build_warning_email_comment\"=$26, " + "\"build_error_email\"=$27, " + "\"build_error_email_comment\"=$28, " + "\"internal_repository_tenant\"=$29, " + "\"internal_repository_canonical_name\"=$30, " + "\"location\"=$31, " + "\"fragment\"=$32, " + "\"sha256sum\"=$33, " + "\"buildable\"=$34, " + "\"unbuildable_reason\"=$35, " + "\"search_index\"=to_tsvector($36::weighted_text) " + "WHERE \"tenant\"=$37 AND \"name\"=$38::CITEXT AND \"version_epoch\"=$39 AND \"version_canonical_upstream\"=$40 AND \"version_canonical_release\"=$41 AND \"version_revision\"=$42"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::erase_statement[] = + "DELETE FROM \"package\" " + "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6"; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::query_statement[] = + "SELECT\n" + "\"package\".\"tenant\",\n" + "\"package\".\"name\"::TEXT,\n" + "\"package\".\"version_epoch\",\n" + "\"package\".\"version_canonical_upstream\",\n" + "\"package\".\"version_canonical_release\",\n" + "\"package\".\"version_revision\",\n" + "\"package\".\"version_upstream\",\n" + "\"package\".\"version_release\",\n" + "\"package\".\"upstream_version\",\n" + "\"package\".\"project\"::TEXT,\n" + "\"package\".\"priority\",\n" + "\"package\".\"priority_comment\",\n" + "\"package\".\"summary\",\n" + "\"package\".\"description\",\n" + "\"package\".\"description_type\",\n" + "\"package\".\"changes\",\n" + "\"package\".\"url\",\n" + "\"package\".\"url_comment\",\n" + "\"package\".\"doc_url\",\n" + "\"package\".\"doc_url_comment\",\n" + "\"package\".\"src_url\",\n" + "\"package\".\"src_url_comment\",\n" + "\"package\".\"package_url\",\n" + "\"package\".\"package_url_comment\",\n" + "\"package\".\"email\",\n" + "\"package\".\"email_comment\",\n" + "\"package\".\"package_email\",\n" + "\"package\".\"package_email_comment\",\n" + "\"package\".\"build_email\",\n" + "\"package\".\"build_email_comment\",\n" + "\"package\".\"build_warning_email\",\n" + "\"package\".\"build_warning_email_comment\",\n" + "\"package\".\"build_error_email\",\n" + "\"package\".\"build_error_email_comment\",\n" + "\"package\".\"internal_repository_tenant\",\n" + "\"package\".\"internal_repository_canonical_name\",\n" + "\"package\".\"location\",\n" + "\"package\".\"fragment\",\n" + "\"package\".\"sha256sum\",\n" + "\"package\".\"buildable\",\n" + "\"package\".\"unbuildable_reason\",\n" + "COALESCE('',\"package\".\"search_index\")\n" + "FROM \"package\"\n" + "LEFT JOIN \"repository\" AS \"internal_repository\" ON \"internal_repository\".\"tenant\"=\"package\".\"internal_repository_tenant\" AND \"internal_repository\".\"canonical_name\"=\"package\".\"internal_repository_canonical_name\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::erase_query_statement[] = + "DELETE FROM \"package\""; + + const char access::object_traits_impl< ::brep::package, id_pgsql >::table_name[] = + "\"package\""; + + void access::object_traits_impl< ::brep::package, id_pgsql >:: + persist (database& db, const object_type& obj) + { + ODB_POTENTIALLY_UNUSED (db); + + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + callback (db, + obj, + callback_event::pre_persist); + + image_type& im (sts.image ()); + binding& imb (sts.insert_image_binding ()); + + if (init (im, obj, statement_insert)) + im.version++; + + if (im.version != sts.insert_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_insert); + sts.insert_image_version (im.version); + imb.version++; + } + + insert_statement& st (sts.persist_statement ()); + if (!st.execute ()) + throw object_already_persistent (); + + id_image_type& i (sts.id_image ()); + init (i, id (obj)); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + // license_alternatives + // + { + ::brep::package::license_alternatives_type const& v = + obj.license_alternatives; + + license_alternatives_traits::persist ( + v, + esc.license_alternatives); + } + + // licenses + // + { + // From package.hxx:538:7 + ::std::map< ::odb::nested_key< ::bpkg::licenses >, ::std::basic_string< char > > const& v = + odb::nested_get (obj.license_alternatives); + + licenses_traits::persist ( + v, + esc.licenses); + } + + // topics + // + { + ::butl::small_vector< ::std::basic_string< char >, 5 > const& v = + obj.topics; + + topics_traits::persist ( + v, + esc.topics); + } + + // keywords + // + { + ::butl::small_vector< ::std::basic_string< char >, 5 > const& v = + obj.keywords; + + keywords_traits::persist ( + v, + esc.keywords); + } + + // dependencies + // + { + ::brep::package::dependencies_type const& v = + obj.dependencies; + + dependencies_traits::persist ( + v, + esc.dependencies); + } + + // dependency_alternatives + // + { + // From package.hxx:564:7 + ::std::map< ::odb::nested_key< ::brep::dependency_alternatives >, ::brep::dependency > const& v = + odb::nested_get (obj.dependencies); + + dependency_alternatives_traits::persist ( + v, + esc.dependency_alternatives); + } + + // requirements + // + { + ::brep::package::requirements_type const& v = + obj.requirements; + + requirements_traits::persist ( + v, + esc.requirements); + } + + // requirement_alternatives + // + { + // From package.hxx:582:7 + ::std::map< ::odb::nested_key< ::bpkg::requirement_alternatives >, ::std::basic_string< char > > const& v = + odb::nested_get (obj.requirements); + + requirement_alternatives_traits::persist ( + v, + esc.requirement_alternatives); + } + + // tests + // + { + ::butl::small_vector< ::brep::test_dependency, 1 > const& v = + obj.tests; + + tests_traits::persist ( + v, + esc.tests); + } + + // builds + // + { + ::brep::build_class_exprs const& v = + obj.builds; + + builds_traits::persist ( + v, + esc.builds); + } + + // build_constraints + // + { + ::brep::package::build_constraints_type const& v = + obj.build_constraints; + + build_constraints_traits::persist ( + v, + esc.build_constraints); + } + + // other_repositories + // + { + ::std::vector< ::odb::lazy_shared_ptr< ::brep::repository > > const& v = + obj.other_repositories; + + other_repositories_traits::persist ( + v, + esc.other_repositories); + } + + obj.build_section.reset (true, false); + + callback (db, + obj, + callback_event::post_persist); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >:: + update (database& db, const object_type& obj) + { + ODB_POTENTIALLY_UNUSED (db); + + using namespace pgsql; + using pgsql::update_statement; + + callback (db, obj, callback_event::pre_update); + + pgsql::transaction& tr (pgsql::transaction::current ()); + pgsql::connection& conn (tr.connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + id_image_type& idi (sts.id_image ()); + init (idi, id (obj)); + + image_type& im (sts.image ()); + if (init (im, obj, statement_update)) + im.version++; + + bool u (false); + binding& imb (sts.update_image_binding ()); + if (im.version != sts.update_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_update); + sts.update_image_version (im.version); + imb.version++; + u = true; + } + + binding& idb (sts.id_image_binding ()); + if (idi.version != sts.update_id_image_version () || + idb.version == 0) + { + if (idi.version != sts.id_image_version () || + idb.version == 0) + { + bind (idb.bind, idi); + sts.id_image_version (idi.version); + idb.version++; + } + + sts.update_id_image_version (idi.version); + + if (!u) + imb.version++; + } + + update_statement& st (sts.update_statement ()); + if (st.execute () == 0) + throw object_not_persistent (); + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + // license_alternatives + // + { + ::brep::package::license_alternatives_type const& v = + obj.license_alternatives; + + license_alternatives_traits::update ( + v, + esc.license_alternatives); + } + + // licenses + // + { + // From package.hxx:538:7 + ::std::map< ::odb::nested_key< ::bpkg::licenses >, ::std::basic_string< char > > const& v = + odb::nested_get (obj.license_alternatives); + + licenses_traits::update ( + v, + esc.licenses); + } + + // topics + // + { + ::butl::small_vector< ::std::basic_string< char >, 5 > const& v = + obj.topics; + + topics_traits::update ( + v, + esc.topics); + } + + // keywords + // + { + ::butl::small_vector< ::std::basic_string< char >, 5 > const& v = + obj.keywords; + + keywords_traits::update ( + v, + esc.keywords); + } + + // dependencies + // + { + ::brep::package::dependencies_type const& v = + obj.dependencies; + + dependencies_traits::update ( + v, + esc.dependencies); + } + + // dependency_alternatives + // + { + // From package.hxx:564:7 + ::std::map< ::odb::nested_key< ::brep::dependency_alternatives >, ::brep::dependency > const& v = + odb::nested_get (obj.dependencies); + + dependency_alternatives_traits::update ( + v, + esc.dependency_alternatives); + } + + // requirements + // + { + ::brep::package::requirements_type const& v = + obj.requirements; + + requirements_traits::update ( + v, + esc.requirements); + } + + // requirement_alternatives + // + { + // From package.hxx:582:7 + ::std::map< ::odb::nested_key< ::bpkg::requirement_alternatives >, ::std::basic_string< char > > const& v = + odb::nested_get (obj.requirements); + + requirement_alternatives_traits::update ( + v, + esc.requirement_alternatives); + } + + // tests + // + { + ::butl::small_vector< ::brep::test_dependency, 1 > const& v = + obj.tests; + + tests_traits::update ( + v, + esc.tests); + } + + // other_repositories + // + { + ::std::vector< ::odb::lazy_shared_ptr< ::brep::repository > > const& v = + obj.other_repositories; + + other_repositories_traits::update ( + v, + esc.other_repositories); + } + + if (obj.build_section.loaded ()) + { + build_section_traits::update (esc, obj); + } + + callback (db, obj, callback_event::post_update); + pointer_cache_traits::update (db, obj); + } + + void access::object_traits_impl< ::brep::package, id_pgsql >:: + erase (database& db, const id_type& id) + { + using namespace pgsql; + + ODB_POTENTIALLY_UNUSED (db); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + id_image_type& i (sts.id_image ()); + init (i, id); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + // license_alternatives + // + { + license_alternatives_traits::erase ( + esc.license_alternatives); + } + + // licenses + // + { + licenses_traits::erase ( + esc.licenses); + } + + // topics + // + { + topics_traits::erase ( + esc.topics); + } + + // keywords + // + { + keywords_traits::erase ( + esc.keywords); + } + + // dependencies + // + { + dependencies_traits::erase ( + esc.dependencies); + } + + // dependency_alternatives + // + { + dependency_alternatives_traits::erase ( + esc.dependency_alternatives); + } + + // requirements + // + { + requirements_traits::erase ( + esc.requirements); + } + + // requirement_alternatives + // + { + requirement_alternatives_traits::erase ( + esc.requirement_alternatives); + } + + // tests + // + { + tests_traits::erase ( + esc.tests); + } + + // builds + // + { + builds_traits::erase ( + esc.builds); + } + + // build_constraints + // + { + build_constraints_traits::erase ( + esc.build_constraints); + } + + // other_repositories + // + { + other_repositories_traits::erase ( + esc.other_repositories); + } + + if (sts.erase_statement ().execute () != 1) + throw object_not_persistent (); + + pointer_cache_traits::erase (db, id); + } + + access::object_traits_impl< ::brep::package, id_pgsql >::pointer_type + access::object_traits_impl< ::brep::package, id_pgsql >:: + find (database& db, const id_type& id) + { + using namespace pgsql; + + { + pointer_type p (pointer_cache_traits::find (db, id)); + + if (!pointer_traits::null_ptr (p)) + return p; + } + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + + if (l.locked ()) + { + if (!find_ (sts, &id)) + return pointer_type (); + } + + pointer_type p ( + access::object_factory<object_type, pointer_type>::create ()); + pointer_traits::guard pg (p); + + pointer_cache_traits::insert_guard ig ( + pointer_cache_traits::insert (db, id, p)); + + object_type& obj (pointer_traits::get_ref (p)); + + if (l.locked ()) + { + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, false); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + pointer_cache_traits::load (ig.position ()); + } + else + sts.delay_load (id, obj, ig.position ()); + + ig.release (); + pg.release (); + return p; + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >:: + find (database& db, const id_type& id, object_type& obj) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + assert (l.locked ()) /* Must be a top-level call. */; + + if (!find_ (sts, &id)) + return false; + + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + reference_cache_traits::position_type pos ( + reference_cache_traits::insert (db, id, obj)); + reference_cache_traits::insert_guard ig (pos); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, false); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + reference_cache_traits::load (pos); + ig.release (); + return true; + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >:: + reload (database& db, object_type& obj) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + assert (l.locked ()) /* Must be a top-level call. */; + + const id_type& id (object_traits_impl::id (obj)); + if (!find_ (sts, &id)) + return false; + + select_statement& st (sts.find_statement ()); + ODB_POTENTIALLY_UNUSED (st); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + load_ (sts, obj, true); + sts.load_delayed (0); + l.unlock (); + callback (db, obj, callback_event::post_load); + return true; + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >:: + load (connection& conn, object_type& obj, section& s) + { + using namespace pgsql; + + pgsql::connection& c (static_cast<pgsql::connection&> (conn)); + statements_type& sts (c.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + assert (l.locked ()) /* Must be a top-level call. */; + + bool r (false); + + id_image_type& i (sts.id_image ()); + init (i, id (obj)); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + if (!r && &s == &obj.build_section) + { + build_section_traits::load (esc, obj); + r = true; + } + + sts.load_delayed (0); + l.unlock (); + return r; + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >:: + update (connection& conn, const object_type& obj, const section& s) + { + using namespace pgsql; + + pgsql::connection& c (static_cast<pgsql::connection&> (conn)); + statements_type& sts (c.statement_cache ().find_object<object_type> ()); + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + id_image_type& i (sts.id_image ()); + init (i, id (obj)); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + if (&s == &obj.build_section)build_section_traits::update (esc, obj); + else + return false; + + return true; + } + + bool access::object_traits_impl< ::brep::package, id_pgsql >:: + find_ (statements_type& sts, + const id_type* id) + { + using namespace pgsql; + + id_image_type& i (sts.id_image ()); + init (i, *id); + + binding& idb (sts.id_image_binding ()); + if (i.version != sts.id_image_version () || idb.version == 0) + { + bind (idb.bind, i); + sts.id_image_version (i.version); + idb.version++; + } + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + select_statement& st (sts.find_statement ()); + + st.execute (); + auto_result ar (st); + select_statement::result r (st.fetch ()); + + if (r == select_statement::truncated) + { + if (grow (im, sts.select_image_truncated ())) + im.version++; + + if (im.version != sts.select_image_version ()) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + st.refetch (); + } + } + + return r != select_statement::no_data; + } + + void access::object_traits_impl< ::brep::package, id_pgsql >:: + load_ (statements_type& sts, + object_type& obj, + bool reload) + { + ODB_POTENTIALLY_UNUSED (reload); + + extra_statement_cache_type& esc (sts.extra_statement_cache ()); + + // license_alternatives + // + { + ::brep::package::license_alternatives_type& v = + obj.license_alternatives; + + license_alternatives_traits::load ( + v, + esc.license_alternatives); + } + + // licenses + // + { + ::std::map< ::odb::nested_key< ::bpkg::licenses >, ::std::basic_string< char > > v; + + licenses_traits::load ( + v, + esc.licenses); + + // From package.hxx:539:7 + odb::nested_set (obj.license_alternatives, std::move (v)); + } + + // topics + // + { + ::butl::small_vector< ::std::basic_string< char >, 5 >& v = + obj.topics; + + topics_traits::load ( + v, + esc.topics); + } + + // keywords + // + { + ::butl::small_vector< ::std::basic_string< char >, 5 >& v = + obj.keywords; + + keywords_traits::load ( + v, + esc.keywords); + } + + // dependencies + // + { + ::brep::package::dependencies_type& v = + obj.dependencies; + + dependencies_traits::load ( + v, + esc.dependencies); + } + + // dependency_alternatives + // + { + ::std::map< ::odb::nested_key< ::brep::dependency_alternatives >, ::brep::dependency > v; + + dependency_alternatives_traits::load ( + v, + esc.dependency_alternatives); + + // From package.hxx:565:7 + odb::nested_set (obj.dependencies, std::move (v)); + } + + // requirements + // + { + ::brep::package::requirements_type& v = + obj.requirements; + + requirements_traits::load ( + v, + esc.requirements); + } + + // requirement_alternatives + // + { + ::std::map< ::odb::nested_key< ::bpkg::requirement_alternatives >, ::std::basic_string< char > > v; + + requirement_alternatives_traits::load ( + v, + esc.requirement_alternatives); + + // From package.hxx:583:7 + odb::nested_set (obj.requirements, std::move (v)); + } + + // tests + // + { + ::butl::small_vector< ::brep::test_dependency, 1 >& v = + obj.tests; + + tests_traits::load ( + v, + esc.tests); + } + + // other_repositories + // + { + ::std::vector< ::odb::lazy_shared_ptr< ::brep::repository > >& v = + obj.other_repositories; + + other_repositories_traits::load ( + v, + esc.other_repositories); + } + + if (reload) + { + if (obj.build_section.loaded ()) + { + build_section_traits::load (esc, obj); + obj.build_section.reset (true, false); + } + } + else + obj.build_section.reset (); + } + + result< access::object_traits_impl< ::brep::package, id_pgsql >::object_type > + access::object_traits_impl< ::brep::package, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + std::string text (query_statement); + if (!q.empty ()) + { + text += "\n"; + text += q.clause (); + } + + q.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + text, + true, + true, + q.parameter_types (), + q.parameter_count (), + q.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::object_result_impl<object_type> > r ( + new (shared) pgsql::object_result_impl<object_type> ( + q, st, sts, 0)); + + return result<object_type> (r); + } + + unsigned long long access::object_traits_impl< ::brep::package, id_pgsql >:: + erase_query (database&, const query_base_type& q) + { + using namespace pgsql; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + std::string text (erase_query_statement); + if (!q.empty ()) + { + text += ' '; + text += q.clause (); + } + + q.init_parameters (); + delete_statement st ( + conn, + erase_query_statement_name, + text, + q.parameter_types (), + q.parameter_count (), + q.parameters_binding ()); + + return st.execute (); + } + + odb::details::shared_ptr<prepared_query_impl> + access::object_traits_impl< ::brep::package, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + std::string text (query_statement); + if (!q.empty ()) + { + text += "\n"; + text += q.clause (); + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = q; + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + text, + true, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::object_traits_impl< ::brep::package, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.select_image_binding ()); + + if (im.version != sts.select_image_version () || + imb.version == 0) + { + bind (imb.bind, im, statement_select); + sts.select_image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::object_result_impl<object_type> ( + pq.query, st, sts, 0)); + } + + // latest_package_search_rank + // + + const char access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:: + query_statement_name[] = "query_brep_latest_package_search_rank"; + + bool access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // id + // + if (composite_value_traits< ::brep::package_id, id_pgsql >::grow ( + i.id_value, t + 0UL)) + grew = true; + + // rank + // + t[6UL] = 0; + + return grew; + } + + void access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i) + { + using namespace pgsql; + + pgsql::statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + std::size_t n (0); + + // id + // + composite_value_traits< ::brep::package_id, id_pgsql >::bind ( + b + n, i.id_value, sk); + n += 6UL; + + // rank + // + b[n].type = pgsql::bind::double_; + b[n].buffer = &i.rank_value; + b[n].is_null = &i.rank_null; + n++; + } + + void access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:: + init (view_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // id + // + { + ::brep::package_id& v = + o.id; + + composite_value_traits< ::brep::package_id, id_pgsql >::init ( + v, + i.id_value, + db); + } + + // rank + // + { + double& v = + o.rank; + + pgsql::value_traits< + double, + pgsql::id_double >::set_value ( + v, + i.rank_value, + i.rank_null); + } + } + + access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::query_base_type + access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:: + query_statement (const query_base_type& q) + { + query_base_type r ( + "SELECT * FROM search_latest_packages" + q); + return r; + } + + result< access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >::view_type > + access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + const query_base_type& qs (query_statement (q)); + qs.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + qs.clause (), + false, + true, + qs.parameter_types (), + qs.parameter_count (), + qs.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::view_result_impl<view_type> > r ( + new (shared) pgsql::view_result_impl<view_type> ( + qs, st, sts, 0)); + + return result<view_type> (r); + } + + odb::details::shared_ptr<prepared_query_impl> + access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = query_statement (q); + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + r->query.clause (), + false, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::view_result_impl<view_type> ( + pq.query, st, sts, 0)); + } + + // latest_package_count + // + + const char access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:: + query_statement_name[] = "query_brep_latest_package_count"; + + bool access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // result + // + t[0UL] = 0; + + return grew; + } + + void access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i) + { + using namespace pgsql; + + pgsql::statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + std::size_t n (0); + + // result + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.result_value; + b[n].is_null = &i.result_null; + n++; + } + + void access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:: + init (view_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // result + // + { + ::std::size_t& v = + o.result; + + pgsql::value_traits< + ::std::size_t, + pgsql::id_bigint >::set_value ( + v, + i.result_value, + i.result_null); + } + } + + access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::query_base_type + access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:: + query_statement (const query_base_type& q) + { + query_base_type r ( + "SELECT count(*) FROM search_latest_packages" + q); + return r; + } + + result< access::view_traits_impl< ::brep::latest_package_count, id_pgsql >::view_type > + access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + const query_base_type& qs (query_statement (q)); + qs.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + qs.clause (), + false, + true, + qs.parameter_types (), + qs.parameter_count (), + qs.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::view_result_impl<view_type> > r ( + new (shared) pgsql::view_result_impl<view_type> ( + qs, st, sts, 0)); + + return result<view_type> (r); + } + + odb::details::shared_ptr<prepared_query_impl> + access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = query_statement (q); + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + r->query.clause (), + false, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::view_result_impl<view_type> ( + pq.query, st, sts, 0)); + } + + // package_search_rank + // + + const char access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:: + query_statement_name[] = "query_brep_package_search_rank"; + + bool access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // id + // + if (composite_value_traits< ::brep::package_id, id_pgsql >::grow ( + i.id_value, t + 0UL)) + grew = true; + + // rank + // + t[6UL] = 0; + + return grew; + } + + void access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i) + { + using namespace pgsql; + + pgsql::statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + std::size_t n (0); + + // id + // + composite_value_traits< ::brep::package_id, id_pgsql >::bind ( + b + n, i.id_value, sk); + n += 6UL; + + // rank + // + b[n].type = pgsql::bind::double_; + b[n].buffer = &i.rank_value; + b[n].is_null = &i.rank_null; + n++; + } + + void access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:: + init (view_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // id + // + { + ::brep::package_id& v = + o.id; + + composite_value_traits< ::brep::package_id, id_pgsql >::init ( + v, + i.id_value, + db); + } + + // rank + // + { + double& v = + o.rank; + + pgsql::value_traits< + double, + pgsql::id_double >::set_value ( + v, + i.rank_value, + i.rank_null); + } + } + + access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::query_base_type + access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:: + query_statement (const query_base_type& q) + { + query_base_type r ( + "SELECT * FROM search_packages" + q); + return r; + } + + result< access::view_traits_impl< ::brep::package_search_rank, id_pgsql >::view_type > + access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + const query_base_type& qs (query_statement (q)); + qs.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + qs.clause (), + false, + true, + qs.parameter_types (), + qs.parameter_count (), + qs.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::view_result_impl<view_type> > r ( + new (shared) pgsql::view_result_impl<view_type> ( + qs, st, sts, 0)); + + return result<view_type> (r); + } + + odb::details::shared_ptr<prepared_query_impl> + access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = query_statement (q); + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + r->query.clause (), + false, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::view_result_impl<view_type> ( + pq.query, st, sts, 0)); + } + + // package_count + // + + const char access::view_traits_impl< ::brep::package_count, id_pgsql >:: + query_statement_name[] = "query_brep_package_count"; + + bool access::view_traits_impl< ::brep::package_count, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // result + // + t[0UL] = 0; + + return grew; + } + + void access::view_traits_impl< ::brep::package_count, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i) + { + using namespace pgsql; + + pgsql::statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + std::size_t n (0); + + // result + // + b[n].type = pgsql::bind::bigint; + b[n].buffer = &i.result_value; + b[n].is_null = &i.result_null; + n++; + } + + void access::view_traits_impl< ::brep::package_count, id_pgsql >:: + init (view_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // result + // + { + ::std::size_t& v = + o.result; + + pgsql::value_traits< + ::std::size_t, + pgsql::id_bigint >::set_value ( + v, + i.result_value, + i.result_null); + } + } + + access::view_traits_impl< ::brep::package_count, id_pgsql >::query_base_type + access::view_traits_impl< ::brep::package_count, id_pgsql >:: + query_statement (const query_base_type& q) + { + query_base_type r ( + "SELECT count(*) FROM search_packages" + q); + return r; + } + + result< access::view_traits_impl< ::brep::package_count, id_pgsql >::view_type > + access::view_traits_impl< ::brep::package_count, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + const query_base_type& qs (query_statement (q)); + qs.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + qs.clause (), + false, + true, + qs.parameter_types (), + qs.parameter_count (), + qs.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::view_result_impl<view_type> > r ( + new (shared) pgsql::view_result_impl<view_type> ( + qs, st, sts, 0)); + + return result<view_type> (r); + } + + odb::details::shared_ptr<prepared_query_impl> + access::view_traits_impl< ::brep::package_count, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = query_statement (q); + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + r->query.clause (), + false, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::view_traits_impl< ::brep::package_count, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::view_result_impl<view_type> ( + pq.query, st, sts, 0)); + } + + // latest_package + // + + const char access::view_traits_impl< ::brep::latest_package, id_pgsql >:: + query_statement_name[] = "query_brep_latest_package"; + + bool access::view_traits_impl< ::brep::latest_package, id_pgsql >:: + grow (image_type& i, + bool* t) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (t); + + bool grew (false); + + // id + // + if (composite_value_traits< ::brep::package_id, id_pgsql >::grow ( + i.id_value, t + 0UL)) + grew = true; + + return grew; + } + + void access::view_traits_impl< ::brep::latest_package, id_pgsql >:: + bind (pgsql::bind* b, + image_type& i) + { + using namespace pgsql; + + pgsql::statement_kind sk (statement_select); + ODB_POTENTIALLY_UNUSED (sk); + + std::size_t n (0); + + // id + // + composite_value_traits< ::brep::package_id, id_pgsql >::bind ( + b + n, i.id_value, sk); + n += 6UL; + } + + void access::view_traits_impl< ::brep::latest_package, id_pgsql >:: + init (view_type& o, + const image_type& i, + database* db) + { + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (db); + + // id + // + { + ::brep::package_id& v = + o.id; + + composite_value_traits< ::brep::package_id, id_pgsql >::init ( + v, + i.id_value, + db); + } + } + + access::view_traits_impl< ::brep::latest_package, id_pgsql >::query_base_type + access::view_traits_impl< ::brep::latest_package, id_pgsql >:: + query_statement (const query_base_type& q) + { + query_base_type r ( + "SELECT * FROM latest_package" + q); + return r; + } + + result< access::view_traits_impl< ::brep::latest_package, id_pgsql >::view_type > + access::view_traits_impl< ::brep::latest_package, id_pgsql >:: + query (database&, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + const query_base_type& qs (query_statement (q)); + qs.init_parameters (); + shared_ptr<select_statement> st ( + new (shared) select_statement ( + sts.connection (), + query_statement_name, + qs.clause (), + false, + true, + qs.parameter_types (), + qs.parameter_count (), + qs.parameters_binding (), + imb)); + + st->execute (); + st->deallocate (); + + shared_ptr< odb::view_result_impl<view_type> > r ( + new (shared) pgsql::view_result_impl<view_type> ( + qs, st, sts, 0)); + + return result<view_type> (r); + } + + odb::details::shared_ptr<prepared_query_impl> + access::view_traits_impl< ::brep::latest_package, id_pgsql >:: + prepare_query (connection& c, const char* n, const query_base_type& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::connection& conn ( + static_cast<pgsql::connection&> (c)); + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + shared_ptr<pgsql::prepared_query_impl> r ( + new (shared) pgsql::prepared_query_impl (conn)); + r->name = n; + r->execute = &execute_query; + r->query = query_statement (q); + r->stmt.reset ( + new (shared) select_statement ( + sts.connection (), + n, + r->query.clause (), + false, + true, + r->query.parameter_types (), + r->query.parameter_count (), + r->query.parameters_binding (), + imb)); + + return r; + } + + odb::details::shared_ptr<result_impl> + access::view_traits_impl< ::brep::latest_package, id_pgsql >:: + execute_query (prepared_query_impl& q) + { + using namespace pgsql; + using odb::details::shared; + using odb::details::shared_ptr; + + pgsql::prepared_query_impl& pq ( + static_cast<pgsql::prepared_query_impl&> (q)); + shared_ptr<select_statement> st ( + odb::details::inc_ref ( + static_cast<select_statement*> (pq.stmt.get ()))); + + pgsql::connection& conn ( + pgsql::transaction::current ().connection ()); + + // The connection used by the current transaction and the + // one used to prepare this statement must be the same. + // + assert (&conn == &st->connection ()); + + statements_type& sts ( + conn.statement_cache ().find_view<view_type> ()); + + image_type& im (sts.image ()); + binding& imb (sts.image_binding ()); + + if (im.version != sts.image_version () || imb.version == 0) + { + bind (imb.bind, im); + sts.image_version (im.version); + imb.version++; + } + + pq.query.init_parameters (); + st->execute (); + + return shared_ptr<result_impl> ( + new (shared) pgsql::view_result_impl<view_type> ( + pq.query, st, sts, 0)); + } +} + +namespace odb +{ + static bool + create_schema (database& db, unsigned short pass, bool drop) + { + ODB_POTENTIALLY_UNUSED (db); + ODB_POTENTIALLY_UNUSED (pass); + ODB_POTENTIALLY_UNUSED (drop); + + if (drop) + { + switch (pass) + { + case 1: + { + return true; + } + case 2: + { + db.execute ("DROP TABLE IF EXISTS \"package_other_repositories\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_build_constraints\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_builds\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_tests\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_requirement_alternatives\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_requirements\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_dependency_alternatives\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_dependencies\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_keywords\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_topics\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_licenses\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package_license_alternatives\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"package\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"repository_prerequisites\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"repository_complements\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"repository\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"tenant\" CASCADE"); + db.execute ("DROP TABLE IF EXISTS \"schema_version\""); + return false; + } + } + } + else + { + switch (pass) + { + case 1: + { + db.execute ("CREATE TABLE \"tenant\" (\n" + " \"id\" TEXT NOT NULL PRIMARY KEY,\n" + " \"creation_timestamp\" BIGINT NOT NULL,\n" + " \"archived\" BOOLEAN NOT NULL)"); + db.execute ("CREATE TABLE \"repository\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"canonical_name\" TEXT NOT NULL,\n" + " \"location_url\" TEXT NOT NULL,\n" + " \"location_type\" TEXT NOT NULL,\n" + " \"display_name\" TEXT NOT NULL,\n" + " \"priority\" INTEGER NOT NULL,\n" + " \"interface_url\" TEXT NULL,\n" + " \"email\" TEXT NULL,\n" + " \"email_comment\" TEXT NULL,\n" + " \"summary\" TEXT NULL,\n" + " \"description\" TEXT NULL,\n" + " \"cache_location_url\" TEXT NOT NULL,\n" + " \"cache_location_type\" TEXT NOT NULL,\n" + " \"certificate_fingerprint\" TEXT NULL,\n" + " \"certificate_name\" TEXT NULL,\n" + " \"certificate_organization\" TEXT NULL,\n" + " \"certificate_email\" TEXT NULL,\n" + " \"certificate_pem\" TEXT NULL,\n" + " \"packages_timestamp\" BIGINT NOT NULL,\n" + " \"repositories_timestamp\" BIGINT NOT NULL,\n" + " \"internal\" BOOLEAN NOT NULL,\n" + " \"buildable\" BOOLEAN NOT NULL,\n" + " PRIMARY KEY (\"tenant\",\n" + " \"canonical_name\"),\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED)"); + db.execute ("CREATE TABLE \"repository_complements\" (\n" + " \"repository_tenant\" TEXT NOT NULL,\n" + " \"repository_canonical_name\" TEXT NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"complement_tenant\" TEXT NOT NULL,\n" + " \"complement_canonical_name\" TEXT NOT NULL,\n" + " CONSTRAINT \"repository_tenant_fk\"\n" + " FOREIGN KEY (\"repository_tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"repository_fk\"\n" + " FOREIGN KEY (\"repository_tenant\",\n" + " \"repository_canonical_name\")\n" + " REFERENCES \"repository\" (\"tenant\",\n" + " \"canonical_name\")\n" + " ON DELETE CASCADE,\n" + " CONSTRAINT \"complement_tenant_fk\"\n" + " FOREIGN KEY (\"complement_tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"complement_fk\"\n" + " FOREIGN KEY (\"complement_tenant\",\n" + " \"complement_canonical_name\")\n" + " REFERENCES \"repository\" (\"tenant\",\n" + " \"canonical_name\")\n" + " INITIALLY DEFERRED)"); + db.execute ("CREATE INDEX \"repository_complements_repository_i\"\n" + " ON \"repository_complements\" (\n" + " \"repository_tenant\",\n" + " \"repository_canonical_name\")"); + db.execute ("CREATE INDEX \"repository_complements_index_i\"\n" + " ON \"repository_complements\" (\"index\")"); + db.execute ("CREATE TABLE \"repository_prerequisites\" (\n" + " \"repository_tenant\" TEXT NOT NULL,\n" + " \"repository_canonical_name\" TEXT NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"prerequisite_tenant\" TEXT NOT NULL,\n" + " \"prerequisite_canonical_name\" TEXT NOT NULL,\n" + " CONSTRAINT \"repository_tenant_fk\"\n" + " FOREIGN KEY (\"repository_tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"repository_fk\"\n" + " FOREIGN KEY (\"repository_tenant\",\n" + " \"repository_canonical_name\")\n" + " REFERENCES \"repository\" (\"tenant\",\n" + " \"canonical_name\")\n" + " ON DELETE CASCADE,\n" + " CONSTRAINT \"prerequisite_tenant_fk\"\n" + " FOREIGN KEY (\"prerequisite_tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"prerequisite_fk\"\n" + " FOREIGN KEY (\"prerequisite_tenant\",\n" + " \"prerequisite_canonical_name\")\n" + " REFERENCES \"repository\" (\"tenant\",\n" + " \"canonical_name\")\n" + " INITIALLY DEFERRED)"); + db.execute ("CREATE INDEX \"repository_prerequisites_repository_i\"\n" + " ON \"repository_prerequisites\" (\n" + " \"repository_tenant\",\n" + " \"repository_canonical_name\")"); + db.execute ("CREATE INDEX \"repository_prerequisites_index_i\"\n" + " ON \"repository_prerequisites\" (\"index\")"); + db.execute ("CREATE TABLE \"package\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"version_upstream\" TEXT NOT NULL,\n" + " \"version_release\" TEXT NULL,\n" + " \"upstream_version\" TEXT NULL,\n" + " \"project\" CITEXT NOT NULL,\n" + " \"priority\" INTEGER NOT NULL,\n" + " \"priority_comment\" TEXT NOT NULL,\n" + " \"summary\" TEXT NOT NULL,\n" + " \"description\" TEXT NULL,\n" + " \"description_type\" TEXT NULL,\n" + " \"changes\" TEXT NOT NULL,\n" + " \"url\" TEXT NULL,\n" + " \"url_comment\" TEXT NULL,\n" + " \"doc_url\" TEXT NULL,\n" + " \"doc_url_comment\" TEXT NULL,\n" + " \"src_url\" TEXT NULL,\n" + " \"src_url_comment\" TEXT NULL,\n" + " \"package_url\" TEXT NULL,\n" + " \"package_url_comment\" TEXT NULL,\n" + " \"email\" TEXT NULL,\n" + " \"email_comment\" TEXT NULL,\n" + " \"package_email\" TEXT NULL,\n" + " \"package_email_comment\" TEXT NULL,\n" + " \"build_email\" TEXT NULL,\n" + " \"build_email_comment\" TEXT NULL,\n" + " \"build_warning_email\" TEXT NULL,\n" + " \"build_warning_email_comment\" TEXT NULL,\n" + " \"build_error_email\" TEXT NULL,\n" + " \"build_error_email_comment\" TEXT NULL,\n" + " \"internal_repository_tenant\" TEXT NULL,\n" + " \"internal_repository_canonical_name\" TEXT NULL,\n" + " \"location\" TEXT NULL,\n" + " \"fragment\" TEXT NULL,\n" + " \"sha256sum\" TEXT NULL,\n" + " \"buildable\" BOOLEAN NOT NULL,\n" + " \"unbuildable_reason\" TEXT NULL,\n" + " \"search_index\" tsvector NULL,\n" + " PRIMARY KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\"),\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"internal_repository_tenant_fk\"\n" + " FOREIGN KEY (\"internal_repository_tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"internal_repository_fk\"\n" + " FOREIGN KEY (\"internal_repository_tenant\",\n" + " \"internal_repository_canonical_name\")\n" + " REFERENCES \"repository\" (\"tenant\",\n" + " \"canonical_name\")\n" + " INITIALLY DEFERRED)"); + db.execute ("CREATE INDEX \"package_search_index_i\"\n" + " ON \"package\" USING GIN (\"search_index\")"); + db.execute ("CREATE TABLE \"package_license_alternatives\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"comment\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_license_alternatives_object_id_i\"\n" + " ON \"package_license_alternatives\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_license_alternatives_index_i\"\n" + " ON \"package_license_alternatives\" (\"index\")"); + db.execute ("CREATE TABLE \"package_licenses\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"alternative_index\" BIGINT NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"license\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_licenses_object_id_i\"\n" + " ON \"package_licenses\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE TABLE \"package_topics\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"topic\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_topics_object_id_i\"\n" + " ON \"package_topics\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_topics_index_i\"\n" + " ON \"package_topics\" (\"index\")"); + db.execute ("CREATE TABLE \"package_keywords\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"keyword\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_keywords_object_id_i\"\n" + " ON \"package_keywords\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_keywords_index_i\"\n" + " ON \"package_keywords\" (\"index\")"); + db.execute ("CREATE TABLE \"package_dependencies\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"conditional\" BOOLEAN NOT NULL,\n" + " \"buildtime\" BOOLEAN NOT NULL,\n" + " \"comment\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_dependencies_object_id_i\"\n" + " ON \"package_dependencies\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_dependencies_index_i\"\n" + " ON \"package_dependencies\" (\"index\")"); + db.execute ("CREATE TABLE \"package_dependency_alternatives\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"dependency_index\" BIGINT NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"dep_name\" CITEXT NOT NULL,\n" + " \"dep_min_version_epoch\" INTEGER NULL,\n" + " \"dep_min_version_canonical_upstream\" TEXT NULL,\n" + " \"dep_min_version_canonical_release\" TEXT NULL,\n" + " \"dep_min_version_revision\" INTEGER NULL,\n" + " \"dep_min_version_upstream\" TEXT NULL,\n" + " \"dep_min_version_release\" TEXT NULL,\n" + " \"dep_max_version_epoch\" INTEGER NULL,\n" + " \"dep_max_version_canonical_upstream\" TEXT NULL,\n" + " \"dep_max_version_canonical_release\" TEXT NULL,\n" + " \"dep_max_version_revision\" INTEGER NULL,\n" + " \"dep_max_version_upstream\" TEXT NULL,\n" + " \"dep_max_version_release\" TEXT NULL,\n" + " \"dep_min_open\" BOOLEAN NULL,\n" + " \"dep_max_open\" BOOLEAN NULL,\n" + " \"dep_package_tenant\" TEXT NULL,\n" + " \"dep_package_name\" CITEXT NULL,\n" + " \"dep_package_version_epoch\" INTEGER NULL,\n" + " \"dep_package_version_canonical_upstream\" TEXT NULL,\n" + " \"dep_package_version_canonical_release\" TEXT NULL COLLATE \"C\",\n" + " \"dep_package_version_revision\" INTEGER NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE,\n" + " CONSTRAINT \"dep_package_tenant_fk\"\n" + " FOREIGN KEY (\"dep_package_tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"dep_package_fk\"\n" + " FOREIGN KEY (\"dep_package_tenant\",\n" + " \"dep_package_name\",\n" + " \"dep_package_version_epoch\",\n" + " \"dep_package_version_canonical_upstream\",\n" + " \"dep_package_version_canonical_release\",\n" + " \"dep_package_version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " INITIALLY DEFERRED)"); + db.execute ("CREATE INDEX \"package_dependency_alternatives_object_id_i\"\n" + " ON \"package_dependency_alternatives\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE TABLE \"package_requirements\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"conditional\" BOOLEAN NOT NULL,\n" + " \"buildtime\" BOOLEAN NOT NULL,\n" + " \"comment\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_requirements_object_id_i\"\n" + " ON \"package_requirements\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_requirements_index_i\"\n" + " ON \"package_requirements\" (\"index\")"); + db.execute ("CREATE TABLE \"package_requirement_alternatives\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"requirement_index\" BIGINT NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"id\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_requirement_alternatives_object_id_i\"\n" + " ON \"package_requirement_alternatives\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE TABLE \"package_tests\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"test_name\" CITEXT NOT NULL,\n" + " \"test_min_version_epoch\" INTEGER NULL,\n" + " \"test_min_version_canonical_upstream\" TEXT NULL,\n" + " \"test_min_version_canonical_release\" TEXT NULL,\n" + " \"test_min_version_revision\" INTEGER NULL,\n" + " \"test_min_version_upstream\" TEXT NULL,\n" + " \"test_min_version_release\" TEXT NULL,\n" + " \"test_max_version_epoch\" INTEGER NULL,\n" + " \"test_max_version_canonical_upstream\" TEXT NULL,\n" + " \"test_max_version_canonical_release\" TEXT NULL,\n" + " \"test_max_version_revision\" INTEGER NULL,\n" + " \"test_max_version_upstream\" TEXT NULL,\n" + " \"test_max_version_release\" TEXT NULL,\n" + " \"test_min_open\" BOOLEAN NULL,\n" + " \"test_max_open\" BOOLEAN NULL,\n" + " \"test_package_tenant\" TEXT NULL,\n" + " \"test_package_name\" CITEXT NULL,\n" + " \"test_package_version_epoch\" INTEGER NULL,\n" + " \"test_package_version_canonical_upstream\" TEXT NULL,\n" + " \"test_package_version_canonical_release\" TEXT NULL COLLATE \"C\",\n" + " \"test_package_version_revision\" INTEGER NULL,\n" + " \"test_type\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE,\n" + " CONSTRAINT \"test_package_tenant_fk\"\n" + " FOREIGN KEY (\"test_package_tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"test_package_fk\"\n" + " FOREIGN KEY (\"test_package_tenant\",\n" + " \"test_package_name\",\n" + " \"test_package_version_epoch\",\n" + " \"test_package_version_canonical_upstream\",\n" + " \"test_package_version_canonical_release\",\n" + " \"test_package_version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " INITIALLY DEFERRED)"); + db.execute ("CREATE INDEX \"package_tests_object_id_i\"\n" + " ON \"package_tests\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_tests_index_i\"\n" + " ON \"package_tests\" (\"index\")"); + db.execute ("CREATE TABLE \"package_builds\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"expression\" TEXT NOT NULL,\n" + " \"comment\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_builds_object_id_i\"\n" + " ON \"package_builds\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_builds_index_i\"\n" + " ON \"package_builds\" (\"index\")"); + db.execute ("CREATE TABLE \"package_build_constraints\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"exclusion\" BOOLEAN NOT NULL,\n" + " \"config\" TEXT NOT NULL,\n" + " \"target\" TEXT NULL,\n" + " \"comment\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE)"); + db.execute ("CREATE INDEX \"package_build_constraints_object_id_i\"\n" + " ON \"package_build_constraints\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_build_constraints_index_i\"\n" + " ON \"package_build_constraints\" (\"index\")"); + db.execute ("CREATE TABLE \"package_other_repositories\" (\n" + " \"tenant\" TEXT NOT NULL,\n" + " \"name\" CITEXT NOT NULL,\n" + " \"version_epoch\" INTEGER NOT NULL,\n" + " \"version_canonical_upstream\" TEXT NOT NULL,\n" + " \"version_canonical_release\" TEXT NOT NULL COLLATE \"C\",\n" + " \"version_revision\" INTEGER NOT NULL,\n" + " \"index\" BIGINT NOT NULL,\n" + " \"repository_tenant\" TEXT NOT NULL,\n" + " \"repository_canonical_name\" TEXT NOT NULL,\n" + " CONSTRAINT \"tenant_fk\"\n" + " FOREIGN KEY (\"tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"object_id_fk\"\n" + " FOREIGN KEY (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " REFERENCES \"package\" (\"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")\n" + " ON DELETE CASCADE,\n" + " CONSTRAINT \"repository_tenant_fk\"\n" + " FOREIGN KEY (\"repository_tenant\")\n" + " REFERENCES \"tenant\" (\"id\")\n" + " INITIALLY DEFERRED,\n" + " CONSTRAINT \"repository_fk\"\n" + " FOREIGN KEY (\"repository_tenant\",\n" + " \"repository_canonical_name\")\n" + " REFERENCES \"repository\" (\"tenant\",\n" + " \"canonical_name\")\n" + " INITIALLY DEFERRED)"); + db.execute ("CREATE INDEX \"package_other_repositories_object_id_i\"\n" + " ON \"package_other_repositories\" (\n" + " \"tenant\",\n" + " \"name\",\n" + " \"version_epoch\",\n" + " \"version_canonical_upstream\",\n" + " \"version_canonical_release\",\n" + " \"version_revision\")"); + db.execute ("CREATE INDEX \"package_other_repositories_index_i\"\n" + " ON \"package_other_repositories\" (\"index\")"); + return true; + } + case 2: + { + db.execute ("CREATE TABLE \"schema_version\" (\n" + " \"name\" TEXT NOT NULL PRIMARY KEY,\n" + " \"version\" BIGINT NOT NULL,\n" + " \"migration\" BOOLEAN NOT NULL)"); + db.execute ("INSERT INTO \"schema_version\" (\n" + " \"name\", \"version\", \"migration\")\n" + " VALUES ('package', 19, FALSE)"); + return false; + } + } + } + + return false; + } + + static const schema_catalog_create_entry + create_schema_entry_ ( + id_pgsql, + "package", + &create_schema); + + static const schema_catalog_migrate_entry + migrate_schema_entry_19_ ( + id_pgsql, + "package", + 19ULL, + 0); +} + +#include <odb/post.hxx> |