// -*- C++ -*-
//
// This file was generated by ODB, object-relational mapping (ORM)
// compiler for C++.
//

#ifndef LIBBREP_PACKAGE_ODB_HXX
#define LIBBREP_PACKAGE_ODB_HXX

// Begin prologue.
//
#include <libbrep/package-traits.hxx>
//
// End prologue.

#include <odb/version.hxx>

#if (ODB_VERSION != 20470UL)
#error ODB runtime version mismatch
#endif

#include <odb/pre.hxx>

#include <libbrep/package.hxx>

#include <libbrep/common-odb.hxx>

#include <memory>
#include <cstddef>
#include <utility>

#include <odb/core.hxx>
#include <odb/traits.hxx>
#include <odb/callback.hxx>
#include <odb/wrapper-traits.hxx>
#include <odb/pointer-traits.hxx>
#include <odb/container-traits.hxx>
#include <odb/session.hxx>
#include <odb/cache-traits.hxx>
#include <odb/prepared-query.hxx>
#include <odb/result.hxx>
#include <odb/simple-object-result.hxx>
#include <odb/view-image.hxx>
#include <odb/view-result.hxx>

#include <odb/details/unused.hxx>
#include <odb/details/shared-ptr.hxx>

namespace odb
{
  // tenant
  //
  template <>
  struct class_traits< ::brep::tenant >
  {
    static const class_kind kind = class_object;
  };

  template <>
  class access::object_traits< ::brep::tenant >
  {
    public:
    typedef ::brep::tenant object_type;
    typedef ::std::shared_ptr< ::brep::tenant > pointer_type;
    typedef odb::pointer_traits<pointer_type> pointer_traits;

    static const bool polymorphic = false;

    typedef ::std::string id_type;

    static const bool auto_id = false;

    static const bool abstract = false;

    static id_type
    id (const object_type&);

    typedef
    odb::pointer_cache_traits<
      pointer_type,
      odb::session >
    pointer_cache_traits;

    typedef
    odb::reference_cache_traits<
      object_type,
      odb::session >
    reference_cache_traits;

    static void
    callback (database&, object_type&, callback_event);

    static void
    callback (database&, const object_type&, callback_event);
  };

  // tenant_id
  //
  template <>
  struct class_traits< ::brep::tenant_id >
  {
    static const class_kind kind = class_view;
  };

  template <>
  class access::view_traits< ::brep::tenant_id >
  {
    public:
    typedef ::brep::tenant_id view_type;
    typedef ::brep::tenant_id* pointer_type;

    static void
    callback (database&, view_type&, callback_event);
  };

  // repository
  //
  template <>
  struct class_traits< ::brep::repository >
  {
    static const class_kind kind = class_object;
  };

  template <>
  class access::object_traits< ::brep::repository >
  {
    public:
    typedef ::brep::repository object_type;
    typedef ::std::shared_ptr< ::brep::repository > pointer_type;
    typedef odb::pointer_traits<pointer_type> pointer_traits;

    static const bool polymorphic = false;

    typedef ::brep::repository_id id_type;

    static const bool auto_id = false;

    static const bool abstract = false;

    static id_type
    id (const object_type&);

    typedef
    odb::pointer_cache_traits<
      pointer_type,
      odb::session >
    pointer_cache_traits;

    typedef
    odb::reference_cache_traits<
      object_type,
      odb::session >
    reference_cache_traits;

    static void
    callback (database&, object_type&, callback_event);

    static void
    callback (database&, const object_type&, callback_event);
  };

  // package
  //
  template <>
  struct class_traits< ::brep::package >
  {
    static const class_kind kind = class_object;
  };

  template <>
  class access::object_traits< ::brep::package >
  {
    public:
    typedef ::brep::package object_type;
    typedef ::std::shared_ptr< ::brep::package > pointer_type;
    typedef odb::pointer_traits<pointer_type> pointer_traits;

    static const bool polymorphic = false;

    typedef ::brep::package_id id_type;

    static const bool auto_id = false;

    static const bool abstract = false;

    static id_type
    id (const object_type&);

    typedef
    odb::pointer_cache_traits<
      pointer_type,
      odb::session >
    pointer_cache_traits;

    typedef
    odb::reference_cache_traits<
      object_type,
      odb::session >
    reference_cache_traits;

    static void
    callback (database&, object_type&, callback_event);

    static void
    callback (database&, const object_type&, callback_event);
  };

  // latest_package_search_rank
  //
  template <>
  struct class_traits< ::brep::latest_package_search_rank >
  {
    static const class_kind kind = class_view;
  };

  template <>
  class access::view_traits< ::brep::latest_package_search_rank >
  {
    public:
    typedef ::brep::latest_package_search_rank view_type;
    typedef ::brep::latest_package_search_rank* pointer_type;

    static void
    callback (database&, view_type&, callback_event);
  };

  // latest_package_count
  //
  template <>
  struct class_traits< ::brep::latest_package_count >
  {
    static const class_kind kind = class_view;
  };

  template <>
  class access::view_traits< ::brep::latest_package_count >
  {
    public:
    typedef ::brep::latest_package_count view_type;
    typedef ::brep::latest_package_count* pointer_type;

    static void
    callback (database&, view_type&, callback_event);
  };

  // package_search_rank
  //
  template <>
  struct class_traits< ::brep::package_search_rank >
  {
    static const class_kind kind = class_view;
  };

  template <>
  class access::view_traits< ::brep::package_search_rank >
  {
    public:
    typedef ::brep::package_search_rank view_type;
    typedef ::brep::package_search_rank* pointer_type;

    static void
    callback (database&, view_type&, callback_event);
  };

  // package_count
  //
  template <>
  struct class_traits< ::brep::package_count >
  {
    static const class_kind kind = class_view;
  };

  template <>
  class access::view_traits< ::brep::package_count >
  {
    public:
    typedef ::brep::package_count view_type;
    typedef ::brep::package_count* pointer_type;

    static void
    callback (database&, view_type&, callback_event);
  };

  // latest_package
  //
  template <>
  struct class_traits< ::brep::latest_package >
  {
    static const class_kind kind = class_view;
  };

  template <>
  class access::view_traits< ::brep::latest_package >
  {
    public:
    typedef ::brep::latest_package view_type;
    typedef ::brep::latest_package* pointer_type;

    static void
    callback (database&, view_type&, callback_event);
  };
}

#include <odb/details/buffer.hxx>

#include <odb/pgsql/version.hxx>
#include <odb/pgsql/forward.hxx>
#include <odb/pgsql/binding.hxx>
#include <odb/pgsql/pgsql-types.hxx>
#include <odb/pgsql/query.hxx>

namespace odb
{
  // priority
  //
  template <>
  class access::composite_value_traits< ::bpkg::priority, id_pgsql >
  {
    public:
    typedef ::bpkg::priority value_type;

    struct image_type
    {
      // value
      //
      int value_value;
      bool value_null;

      // comment
      //
      details::buffer comment_value;
      std::size_t comment_size;
      bool comment_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 2UL;
  };

  // licenses
  //
  template <>
  class access::composite_value_traits< ::bpkg::licenses, id_pgsql >
  {
    public:
    typedef ::bpkg::licenses value_type;

    struct image_type
    {
      // comment
      //
      details::buffer comment_value;
      std::size_t comment_size;
      bool comment_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 1UL;
  };

  // manifest_url
  //
  template <>
  class access::composite_value_traits< ::bpkg::manifest_url, id_pgsql >
  {
    public:
    typedef ::bpkg::manifest_url value_type;

    struct image_type
    {
      // value
      //
      details::buffer value_value;
      std::size_t value_size;
      bool value_null;

      // comment
      //
      details::buffer comment_value;
      std::size_t comment_size;
      bool comment_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 2UL;
  };

  // email
  //
  template <>
  class access::composite_value_traits< ::bpkg::email, id_pgsql >
  {
    public:
    typedef ::bpkg::email value_type;

    struct image_type
    {
      // value
      //
      details::buffer value_value;
      std::size_t value_size;
      bool value_null;

      // comment
      //
      details::buffer comment_value;
      std::size_t comment_size;
      bool comment_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 2UL;
  };

  // version_constraint
  //
  template <>
  class access::composite_value_traits< ::bpkg::version_constraint, id_pgsql >
  {
    public:
    typedef ::bpkg::version_constraint value_type;

    struct image_type
    {
      // min_version
      //
      composite_value_traits< ::brep::_version, id_pgsql >::image_type min_version_value;

      // max_version
      //
      composite_value_traits< ::brep::_version, id_pgsql >::image_type max_version_value;

      // min_open
      //
      bool min_open_value;
      bool min_open_null;

      // max_open
      //
      bool max_open_value;
      bool max_open_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 14UL;
  };

  // requirement_alternatives
  //
  template <>
  class access::composite_value_traits< ::bpkg::requirement_alternatives, id_pgsql >
  {
    public:
    typedef ::bpkg::requirement_alternatives value_type;

    struct image_type
    {
      // conditional
      //
      bool conditional_value;
      bool conditional_null;

      // buildtime
      //
      bool buildtime_value;
      bool buildtime_null;

      // comment
      //
      details::buffer comment_value;
      std::size_t comment_size;
      bool comment_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 3UL;
  };

  // dependency
  //
  template <>
  class access::composite_value_traits< ::brep::dependency, id_pgsql >
  {
    public:
    typedef ::brep::dependency value_type;

    struct image_type
    {
      // name
      //
      details::buffer name_value;
      std::size_t name_size;
      bool name_null;

      // constraint
      //
      composite_value_traits< ::bpkg::version_constraint, id_pgsql >::image_type constraint_value;

      // package
      //
      composite_value_traits< ::brep::package_id, id_pgsql >::image_type package_value;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 21UL;
  };

  // dependency_alternatives
  //
  template <>
  class access::composite_value_traits< ::brep::dependency_alternatives, id_pgsql >
  {
    public:
    typedef ::brep::dependency_alternatives value_type;

    struct image_type
    {
      // conditional
      //
      bool conditional_value;
      bool conditional_null;

      // buildtime
      //
      bool buildtime_value;
      bool buildtime_null;

      // comment
      //
      details::buffer comment_value;
      std::size_t comment_size;
      bool comment_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 3UL;
  };

  // test_dependency
  //
  template <>
  class access::composite_value_traits< ::brep::test_dependency, id_pgsql >
  {
    public:
    typedef ::brep::test_dependency value_type;

    struct image_type: composite_value_traits< ::brep::dependency, id_pgsql >::image_type
    {
      // type
      //
      details::buffer type_value;
      std::size_t type_size;
      bool type_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 22UL;
  };

  // certificate
  //
  template <>
  class access::composite_value_traits< ::brep::certificate, id_pgsql >
  {
    public:
    typedef ::brep::certificate value_type;

    struct image_type
    {
      // fingerprint
      //
      details::buffer fingerprint_value;
      std::size_t fingerprint_size;
      bool fingerprint_null;

      // name
      //
      details::buffer name_value;
      std::size_t name_size;
      bool name_null;

      // organization
      //
      details::buffer organization_value;
      std::size_t organization_size;
      bool organization_null;

      // email
      //
      details::buffer email_value;
      std::size_t email_size;
      bool email_null;

      // pem
      //
      details::buffer pem_value;
      std::size_t pem_size;
      bool pem_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 5UL;
  };

  // tenant
  //
  template <typename A>
  struct query_columns< ::brep::tenant, id_pgsql, A >
  {
    // id
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::string,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    id_type_;

    static const id_type_ id;

    // creation_timestamp
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::uint64_t,
        pgsql::id_bigint >::query_type,
      pgsql::id_bigint >
    creation_timestamp_type_;

    static const creation_timestamp_type_ creation_timestamp;

    // archived
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        bool,
        pgsql::id_boolean >::query_type,
      pgsql::id_boolean >
    archived_type_;

    static const archived_type_ archived;
  };

  template <typename A>
  const typename query_columns< ::brep::tenant, id_pgsql, A >::id_type_
  query_columns< ::brep::tenant, id_pgsql, A >::
  id (A::table_name, "\"id\"", 0);

  template <typename A>
  const typename query_columns< ::brep::tenant, id_pgsql, A >::creation_timestamp_type_
  query_columns< ::brep::tenant, id_pgsql, A >::
  creation_timestamp (A::table_name, "\"creation_timestamp\"", 0);

  template <typename A>
  const typename query_columns< ::brep::tenant, id_pgsql, A >::archived_type_
  query_columns< ::brep::tenant, id_pgsql, A >::
  archived (A::table_name, "\"archived\"", 0);

  template <typename A>
  struct pointer_query_columns< ::brep::tenant, id_pgsql, A >:
    query_columns< ::brep::tenant, id_pgsql, A >
  {
  };

  template <>
  class access::object_traits_impl< ::brep::tenant, id_pgsql >:
    public access::object_traits< ::brep::tenant >
  {
    public:
    struct id_image_type
    {
      details::buffer id_value;
      std::size_t id_size;
      bool id_null;

      std::size_t version;
    };

    struct image_type
    {
      // id
      //
      details::buffer id_value;
      std::size_t id_size;
      bool id_null;

      // creation_timestamp
      //
      long long creation_timestamp_value;
      bool creation_timestamp_null;

      // archived
      //
      bool archived_value;
      bool archived_null;

      std::size_t version;
    };

    struct extra_statement_cache_type;

    using object_traits<object_type>::id;

    static id_type
    id (const image_type&);

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static void
    bind (pgsql::bind*, id_image_type&);

    static bool
    init (image_type&,
          const object_type&,
          pgsql::statement_kind);

    static void
    init (object_type&,
          const image_type&,
          database*);

    static void
    init (id_image_type&, const id_type&);

    typedef pgsql::object_statements<object_type> statements_type;

    typedef pgsql::query_base query_base_type;

    static const std::size_t column_count = 3UL;
    static const std::size_t id_column_count = 1UL;
    static const std::size_t inverse_column_count = 0UL;
    static const std::size_t readonly_column_count = 0UL;
    static const std::size_t managed_optimistic_column_count = 0UL;

    static const std::size_t separate_load_column_count = 0UL;
    static const std::size_t separate_update_column_count = 0UL;

    static const bool versioned = false;

    static const char persist_statement[];
    static const char find_statement[];
    static const char update_statement[];
    static const char erase_statement[];
    static const char query_statement[];
    static const char erase_query_statement[];

    static const char table_name[];

    static void
    persist (database&, const object_type&);

    static pointer_type
    find (database&, const id_type&);

    static bool
    find (database&, const id_type&, object_type&);

    static bool
    reload (database&, object_type&);

    static void
    update (database&, const object_type&);

    static void
    erase (database&, const id_type&);

    static void
    erase (database&, const object_type&);

    static result<object_type>
    query (database&, const query_base_type&);

    static unsigned long long
    erase_query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char persist_statement_name[];
    static const char find_statement_name[];
    static const char update_statement_name[];
    static const char erase_statement_name[];
    static const char query_statement_name[];
    static const char erase_query_statement_name[];

    static const unsigned int persist_statement_types[];
    static const unsigned int find_statement_types[];
    static const unsigned int update_statement_types[];

    public:
    static bool
    find_ (statements_type&,
           const id_type*);

    static void
    load_ (statements_type&,
           object_type&,
           bool reload);
  };

  template <>
  class access::object_traits_impl< ::brep::tenant, id_common >:
    public access::object_traits_impl< ::brep::tenant, id_pgsql >
  {
  };

  // tenant_id
  //
  template <>
  class access::view_traits_impl< ::brep::tenant_id, id_pgsql >:
    public access::view_traits< ::brep::tenant_id >
  {
    public:
    struct image_type
    {
      // value
      //
      details::buffer value_value;
      std::size_t value_size;
      bool value_null;

      std::size_t version;
    };

    typedef pgsql::view_statements<view_type> statements_type;

    typedef pgsql::query_base query_base_type;
    struct query_columns;

    static const bool versioned = false;

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&);

    static void
    init (view_type&,
          const image_type&,
          database*);

    static const std::size_t column_count = 1UL;

    static query_base_type
    query_statement (const query_base_type&);

    static result<view_type>
    query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char query_statement_name[];
  };

  template <>
  class access::view_traits_impl< ::brep::tenant_id, id_common >:
    public access::view_traits_impl< ::brep::tenant_id, id_pgsql >
  {
  };

  // repository
  //
  template <typename A>
  struct query_columns< ::brep::repository, id_pgsql, A >
  {
    // id
    //
    struct id_class_
    {
      id_class_ ()
      {
      }

      // tenant
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      tenant_type_;

      static const tenant_type_ tenant;

      // canonical_name
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      canonical_name_type_;

      static const canonical_name_type_ canonical_name;
    };

    static const id_class_ id;

    // location
    //
    struct location_class_
    {
      location_class_ ()
      {
      }

      // url
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      url_type_;

      static const url_type_ url;

      // type
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      type_type_;

      static const type_type_ type;
    };

    static const location_class_ location;

    // display_name
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::string,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    display_name_type_;

    static const display_name_type_ display_name;

    // priority
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::uint16_t,
        pgsql::id_integer >::query_type,
      pgsql::id_integer >
    priority_type_;

    static const priority_type_ priority;

    // interface_url
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    interface_url_type_;

    static const interface_url_type_ interface_url;

    // email
    //
    struct email_class_
    {
      email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const email_class_ email;

    // summary
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    summary_type_;

    static const summary_type_ summary;

    // description
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    description_type_;

    static const description_type_ description;

    // cache_location
    //
    struct cache_location_class_
    {
      cache_location_class_ ()
      {
      }

      // url
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      url_type_;

      static const url_type_ url;

      // type
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      type_type_;

      static const type_type_ type;
    };

    static const cache_location_class_ cache_location;

    // certificate
    //
    struct certificate_class_
    {
      certificate_class_ ()
      {
      }

      // fingerprint
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      fingerprint_type_;

      static const fingerprint_type_ fingerprint;

      // name
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      name_type_;

      static const name_type_ name;

      // organization
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      organization_type_;

      static const organization_type_ organization;

      // email
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      email_type_;

      static const email_type_ email;

      // pem
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      pem_type_;

      static const pem_type_ pem;
    };

    static const certificate_class_ certificate;

    // packages_timestamp
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::uint64_t,
        pgsql::id_bigint >::query_type,
      pgsql::id_bigint >
    packages_timestamp_type_;

    static const packages_timestamp_type_ packages_timestamp;

    // repositories_timestamp
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::uint64_t,
        pgsql::id_bigint >::query_type,
      pgsql::id_bigint >
    repositories_timestamp_type_;

    static const repositories_timestamp_type_ repositories_timestamp;

    // internal
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        bool,
        pgsql::id_boolean >::query_type,
      pgsql::id_boolean >
    internal_type_;

    static const internal_type_ internal;

    // buildable
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        bool,
        pgsql::id_boolean >::query_type,
      pgsql::id_boolean >
    buildable_type_;

    static const buildable_type_ buildable;
  };

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::id_class_::tenant_type_
  query_columns< ::brep::repository, id_pgsql, A >::id_class_::
  tenant (A::table_name, "\"tenant\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::id_class_::canonical_name_type_
  query_columns< ::brep::repository, id_pgsql, A >::id_class_::
  canonical_name (A::table_name, "\"canonical_name\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::id_class_
  query_columns< ::brep::repository, id_pgsql, A >::id;

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::location_class_::url_type_
  query_columns< ::brep::repository, id_pgsql, A >::location_class_::
  url (A::table_name, "\"location_url\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::location_class_::type_type_
  query_columns< ::brep::repository, id_pgsql, A >::location_class_::
  type (A::table_name, "\"location_type\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::location_class_
  query_columns< ::brep::repository, id_pgsql, A >::location;

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::display_name_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  display_name (A::table_name, "\"display_name\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::priority_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  priority (A::table_name, "\"priority\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::interface_url_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  interface_url (A::table_name, "\"interface_url\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::email_class_::value_type_
  query_columns< ::brep::repository, id_pgsql, A >::email_class_::
  value (A::table_name, "\"email\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::email_class_::comment_type_
  query_columns< ::brep::repository, id_pgsql, A >::email_class_::
  comment (A::table_name, "\"email_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::email_class_
  query_columns< ::brep::repository, id_pgsql, A >::email;

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::summary_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  summary (A::table_name, "\"summary\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::description_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  description (A::table_name, "\"description\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_::url_type_
  query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_::
  url (A::table_name, "\"cache_location_url\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_::type_type_
  query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_::
  type (A::table_name, "\"cache_location_type\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::cache_location_class_
  query_columns< ::brep::repository, id_pgsql, A >::cache_location;

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::fingerprint_type_
  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
  fingerprint (A::table_name, "\"certificate_fingerprint\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::name_type_
  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
  name (A::table_name, "\"certificate_name\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::organization_type_
  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
  organization (A::table_name, "\"certificate_organization\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::email_type_
  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
  email (A::table_name, "\"certificate_email\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::pem_type_
  query_columns< ::brep::repository, id_pgsql, A >::certificate_class_::
  pem (A::table_name, "\"certificate_pem\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::certificate_class_
  query_columns< ::brep::repository, id_pgsql, A >::certificate;

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::packages_timestamp_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  packages_timestamp (A::table_name, "\"packages_timestamp\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::repositories_timestamp_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  repositories_timestamp (A::table_name, "\"repositories_timestamp\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::internal_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  internal (A::table_name, "\"internal\"", 0);

  template <typename A>
  const typename query_columns< ::brep::repository, id_pgsql, A >::buildable_type_
  query_columns< ::brep::repository, id_pgsql, A >::
  buildable (A::table_name, "\"buildable\"", 0);

  template <typename A>
  struct pointer_query_columns< ::brep::repository, id_pgsql, A >:
    query_columns< ::brep::repository, id_pgsql, A >
  {
  };

  template <>
  class access::object_traits_impl< ::brep::repository, id_pgsql >:
    public access::object_traits< ::brep::repository >
  {
    public:
    struct id_image_type
    {
      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type id_value;

      std::size_t version;
    };

    struct image_type
    {
      // id
      //
      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type id_value;

      // location
      //
      composite_value_traits< ::brep::_repository_location, id_pgsql >::image_type location_value;

      // display_name
      //
      details::buffer display_name_value;
      std::size_t display_name_size;
      bool display_name_null;

      // priority
      //
      int priority_value;
      bool priority_null;

      // interface_url
      //
      details::buffer interface_url_value;
      std::size_t interface_url_size;
      bool interface_url_null;

      // email
      //
      composite_value_traits< ::bpkg::email, id_pgsql >::image_type email_value;

      // summary
      //
      details::buffer summary_value;
      std::size_t summary_size;
      bool summary_null;

      // description
      //
      details::buffer description_value;
      std::size_t description_size;
      bool description_null;

      // cache_location
      //
      composite_value_traits< ::brep::_repository_location, id_pgsql >::image_type cache_location_value;

      // certificate
      //
      composite_value_traits< ::brep::certificate, id_pgsql >::image_type certificate_value;

      // packages_timestamp
      //
      long long packages_timestamp_value;
      bool packages_timestamp_null;

      // repositories_timestamp
      //
      long long repositories_timestamp_value;
      bool repositories_timestamp_null;

      // internal
      //
      bool internal_value;
      bool internal_null;

      // buildable
      //
      bool buildable_value;
      bool buildable_null;

      std::size_t version;
    };

    struct extra_statement_cache_type;

    // complements
    //
    struct complements_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 2UL;
      static const std::size_t data_column_count = 5UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< complements_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< ::brep::repository_id, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // prerequisites
    //
    struct prerequisites_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 2UL;
      static const std::size_t data_column_count = 5UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::std::vector< ::odb::lazy_weak_ptr< ::brep::repository > > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< prerequisites_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< ::brep::repository_id, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    using object_traits<object_type>::id;

    static id_type
    id (const image_type&);

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static void
    bind (pgsql::bind*, id_image_type&);

    static bool
    init (image_type&,
          const object_type&,
          pgsql::statement_kind);

    static void
    init (object_type&,
          const image_type&,
          database*);

    static void
    init (id_image_type&, const id_type&);

    typedef pgsql::object_statements<object_type> statements_type;

    typedef pgsql::query_base query_base_type;

    static const std::size_t column_count = 22UL;
    static const std::size_t id_column_count = 2UL;
    static const std::size_t inverse_column_count = 0UL;
    static const std::size_t readonly_column_count = 0UL;
    static const std::size_t managed_optimistic_column_count = 0UL;

    static const std::size_t separate_load_column_count = 0UL;
    static const std::size_t separate_update_column_count = 0UL;

    static const bool versioned = false;

    static const char persist_statement[];
    static const char find_statement[];
    static const char update_statement[];
    static const char erase_statement[];
    static const char query_statement[];
    static const char erase_query_statement[];

    static const char table_name[];

    static void
    persist (database&, const object_type&);

    static pointer_type
    find (database&, const id_type&);

    static bool
    find (database&, const id_type&, object_type&);

    static bool
    reload (database&, object_type&);

    static void
    update (database&, const object_type&);

    static void
    erase (database&, const id_type&);

    static void
    erase (database&, const object_type&);

    static result<object_type>
    query (database&, const query_base_type&);

    static unsigned long long
    erase_query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char persist_statement_name[];
    static const char find_statement_name[];
    static const char update_statement_name[];
    static const char erase_statement_name[];
    static const char query_statement_name[];
    static const char erase_query_statement_name[];

    static const unsigned int persist_statement_types[];
    static const unsigned int find_statement_types[];
    static const unsigned int update_statement_types[];

    public:
    static bool
    find_ (statements_type&,
           const id_type*);

    static void
    load_ (statements_type&,
           object_type&,
           bool reload);
  };

  template <>
  class access::object_traits_impl< ::brep::repository, id_common >:
    public access::object_traits_impl< ::brep::repository, id_pgsql >
  {
  };

  // _license_key
  //
  template <>
  class access::composite_value_traits< ::brep::package::_license_key, id_pgsql >
  {
    public:
    typedef ::brep::package::_license_key value_type;

    struct image_type
    {
      // outer
      //
      long long outer_value;
      bool outer_null;

      // inner
      //
      long long inner_value;
      bool inner_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 2UL;
  };

  // _dependency_key
  //
  template <>
  class access::composite_value_traits< ::brep::package::_dependency_key, id_pgsql >
  {
    public:
    typedef ::brep::package::_dependency_key value_type;

    struct image_type
    {
      // outer
      //
      long long outer_value;
      bool outer_null;

      // inner
      //
      long long inner_value;
      bool inner_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 2UL;
  };

  // _requirement_key
  //
  template <>
  class access::composite_value_traits< ::brep::package::_requirement_key, id_pgsql >
  {
    public:
    typedef ::brep::package::_requirement_key value_type;

    struct image_type
    {
      // outer
      //
      long long outer_value;
      bool outer_null;

      // inner
      //
      long long inner_value;
      bool inner_null;
    };

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static bool
    init (image_type&,
          const value_type&,
          pgsql::statement_kind);

    static void
    init (value_type&,
          const image_type&,
          database*);

    static bool
    get_null (const image_type&);

    static void
    set_null (image_type&,
              pgsql::statement_kind);

    static const std::size_t column_count = 2UL;
  };

  // package
  //
  template <typename A>
  struct pointer_query_columns< ::brep::package, id_pgsql, A >
  {
    // id
    //
    struct id_class_
    {
      id_class_ ()
      {
      }

      // tenant
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      tenant_type_;

      static const tenant_type_ tenant;

      // name
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::bpkg::package_name,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      name_type_;

      static const name_type_ name;

      // version
      //
      struct version_class_1_
      {
        version_class_1_ ()
        {
        }

        // epoch
        //
        typedef
        pgsql::query_column<
          pgsql::value_traits<
            ::uint16_t,
            pgsql::id_integer >::query_type,
          pgsql::id_integer >
        epoch_type_;

        static const epoch_type_ epoch;

        // canonical_upstream
        //
        typedef
        pgsql::query_column<
          pgsql::value_traits<
            ::std::string,
            pgsql::id_string >::query_type,
          pgsql::id_string >
        canonical_upstream_type_;

        static const canonical_upstream_type_ canonical_upstream;

        // canonical_release
        //
        typedef
        pgsql::query_column<
          pgsql::value_traits<
            ::std::string,
            pgsql::id_string >::query_type,
          pgsql::id_string >
        canonical_release_type_;

        static const canonical_release_type_ canonical_release;

        // revision
        //
        typedef
        pgsql::query_column<
          pgsql::value_traits<
            ::uint16_t,
            pgsql::id_integer >::query_type,
          pgsql::id_integer >
        revision_type_;

        static const revision_type_ revision;
      };

      static const version_class_1_ version;
    };

    static const id_class_ id;

    // version
    //
    struct version_class_
    {
      version_class_ ()
      {
      }

      // upstream
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      upstream_type_;

      static const upstream_type_ upstream;

      // release
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::basic_string< char >,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      release_type_;

      static const release_type_ release;
    };

    static const version_class_ version;

    // upstream_version
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    upstream_version_type_;

    static const upstream_version_type_ upstream_version;

    // project
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::bpkg::package_name,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    project_type_;

    static const project_type_ project;

    // priority
    //
    struct priority_class_
    {
      priority_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::bpkg::priority::value_type,
          pgsql::id_integer >::query_type,
        pgsql::id_integer >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const priority_class_ priority;

    // summary
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::string,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    summary_type_;

    static const summary_type_ summary;

    // description
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    description_type_;

    static const description_type_ description;

    // description_type
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    description_type_type_;

    static const description_type_type_ description_type;

    // changes
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::string,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    changes_type_;

    static const changes_type_ changes;

    // url
    //
    struct url_class_
    {
      url_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const url_class_ url;

    // doc_url
    //
    struct doc_url_class_
    {
      doc_url_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const doc_url_class_ doc_url;

    // src_url
    //
    struct src_url_class_
    {
      src_url_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const src_url_class_ src_url;

    // package_url
    //
    struct package_url_class_
    {
      package_url_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const package_url_class_ package_url;

    // email
    //
    struct email_class_
    {
      email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const email_class_ email;

    // package_email
    //
    struct package_email_class_
    {
      package_email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const package_email_class_ package_email;

    // build_email
    //
    struct build_email_class_
    {
      build_email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const build_email_class_ build_email;

    // build_warning_email
    //
    struct build_warning_email_class_
    {
      build_warning_email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const build_warning_email_class_ build_warning_email;

    // build_error_email
    //
    struct build_error_email_class_
    {
      build_error_email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const build_error_email_class_ build_error_email;

    // internal_repository
    //
    struct internal_repository_class_
    {
      internal_repository_class_ ()
      {
      }

      // tenant
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      tenant_type_;

      static const tenant_type_ tenant;

      // canonical_name
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      canonical_name_type_;

      static const canonical_name_type_ canonical_name;
    };

    static const internal_repository_class_ internal_repository;

    // location
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    location_type_;

    static const location_type_ location;

    // fragment
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    fragment_type_;

    static const fragment_type_ fragment;

    // sha256sum
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    sha256sum_type_;

    static const sha256sum_type_ sha256sum;

    // buildable
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        bool,
        pgsql::id_boolean >::query_type,
      pgsql::id_boolean >
    buildable_type_;

    static const buildable_type_ buildable;

    // unbuildable_reason
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    unbuildable_reason_type_;

    static const unbuildable_reason_type_ unbuildable_reason;

    // search_index
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::brep::weighted_text,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    search_index_type_;

    static const search_index_type_ search_index;
  };

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::tenant_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::
  tenant (A::table_name, "\"tenant\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::name_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::
  name (A::table_name, "\"name\"", "(?)::CITEXT");

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::epoch_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
  epoch (A::table_name, "\"version_epoch\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::canonical_upstream_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
  canonical_upstream (A::table_name, "\"version_canonical_upstream\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::canonical_release_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
  canonical_release (A::table_name, "\"version_canonical_release\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::revision_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
  revision (A::table_name, "\"version_revision\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_
  pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_::version;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::id_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::id;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_::upstream_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_::
  upstream (A::table_name, "\"version_upstream\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_::release_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_::
  release (A::table_name, "\"version_release\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::version_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::version;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::upstream_version_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  upstream_version (A::table_name, "\"upstream_version\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::project_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  project (A::table_name, "\"project\"", "(?)::CITEXT");

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_::
  value (A::table_name, "\"priority\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_::
  comment (A::table_name, "\"priority_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::priority_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::priority;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::summary_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  summary (A::table_name, "\"summary\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::description_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  description (A::table_name, "\"description\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::description_type_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  description_type (A::table_name, "\"description_type\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::changes_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  changes (A::table_name, "\"changes\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_::
  value (A::table_name, "\"url\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_::
  comment (A::table_name, "\"url_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::url_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::url;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::
  value (A::table_name, "\"doc_url\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::
  comment (A::table_name, "\"doc_url_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::doc_url;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_::
  value (A::table_name, "\"src_url\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_::
  comment (A::table_name, "\"src_url_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::src_url_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::src_url;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_::
  value (A::table_name, "\"package_url\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_::
  comment (A::table_name, "\"package_url_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_url_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::package_url;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_::
  value (A::table_name, "\"email\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_::
  comment (A::table_name, "\"email_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::email_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::email;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_::
  value (A::table_name, "\"package_email\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_::
  comment (A::table_name, "\"package_email_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::package_email_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::package_email;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_::
  value (A::table_name, "\"build_email\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_::
  comment (A::table_name, "\"build_email_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_email_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_email;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::
  value (A::table_name, "\"build_warning_email\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::
  comment (A::table_name, "\"build_warning_email_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_warning_email;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::value_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::
  value (A::table_name, "\"build_error_email\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::comment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::
  comment (A::table_name, "\"build_error_email_comment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::build_error_email;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_::tenant_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_::
  tenant (A::table_name, "\"internal_repository_tenant\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_::canonical_name_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_::
  canonical_name (A::table_name, "\"internal_repository_canonical_name\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository_class_
  pointer_query_columns< ::brep::package, id_pgsql, A >::internal_repository;

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::location_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  location (A::table_name, "\"location\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::fragment_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  fragment (A::table_name, "\"fragment\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::sha256sum_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  sha256sum (A::table_name, "\"sha256sum\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::buildable_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  buildable (A::table_name, "\"buildable\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::unbuildable_reason_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  unbuildable_reason (A::table_name, "\"unbuildable_reason\"", 0);

  template <typename A>
  const typename pointer_query_columns< ::brep::package, id_pgsql, A >::search_index_type_
  pointer_query_columns< ::brep::package, id_pgsql, A >::
  search_index (A::table_name, "\"search_index\"", "to_tsvector((?)::weighted_text)");

  template <>
  class access::object_traits_impl< ::brep::package, id_pgsql >:
    public access::object_traits< ::brep::package >
  {
    public:
    struct id_image_type
    {
      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;

      std::size_t version;
    };

    struct image_type
    {
      // id
      //
      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;

      // version
      //
      composite_value_traits< ::brep::package::upstream_version_type, id_pgsql >::image_type version_value;

      // upstream_version
      //
      details::buffer upstream_version_value;
      std::size_t upstream_version_size;
      bool upstream_version_null;

      // project
      //
      details::buffer project_value;
      std::size_t project_size;
      bool project_null;

      // priority
      //
      composite_value_traits< ::brep::package::priority_type, id_pgsql >::image_type priority_value;

      // summary
      //
      details::buffer summary_value;
      std::size_t summary_size;
      bool summary_null;

      // description
      //
      details::buffer description_value;
      std::size_t description_size;
      bool description_null;

      // description_type
      //
      details::buffer description_type_value;
      std::size_t description_type_size;
      bool description_type_null;

      // changes
      //
      details::buffer changes_value;
      std::size_t changes_size;
      bool changes_null;

      // url
      //
      composite_value_traits< ::bpkg::manifest_url, id_pgsql >::image_type url_value;

      // doc_url
      //
      composite_value_traits< ::bpkg::manifest_url, id_pgsql >::image_type doc_url_value;

      // src_url
      //
      composite_value_traits< ::bpkg::manifest_url, id_pgsql >::image_type src_url_value;

      // package_url
      //
      composite_value_traits< ::bpkg::manifest_url, id_pgsql >::image_type package_url_value;

      // email
      //
      composite_value_traits< ::bpkg::email, id_pgsql >::image_type email_value;

      // package_email
      //
      composite_value_traits< ::bpkg::email, id_pgsql >::image_type package_email_value;

      // build_email
      //
      composite_value_traits< ::bpkg::email, id_pgsql >::image_type build_email_value;

      // build_warning_email
      //
      composite_value_traits< ::bpkg::email, id_pgsql >::image_type build_warning_email_value;

      // build_error_email
      //
      composite_value_traits< ::bpkg::email, id_pgsql >::image_type build_error_email_value;

      // internal_repository
      //
      composite_value_traits< ::brep::repository_id, id_pgsql >::image_type internal_repository_value;

      // location
      //
      details::buffer location_value;
      std::size_t location_size;
      bool location_null;

      // fragment
      //
      details::buffer fragment_value;
      std::size_t fragment_size;
      bool fragment_null;

      // sha256sum
      //
      details::buffer sha256sum_value;
      std::size_t sha256sum_size;
      bool sha256sum_null;

      // buildable
      //
      bool buildable_value;
      bool buildable_null;

      // unbuildable_reason
      //
      details::buffer unbuildable_reason_value;
      std::size_t unbuildable_reason_size;
      bool unbuildable_reason_null;

      // search_index
      //
      details::buffer search_index_value;
      std::size_t search_index_size;
      bool search_index_null;

      std::size_t version;
    };

    struct extra_statement_cache_type;

    // license_alternatives
    //
    struct license_alternatives_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 8UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::brep::package::license_alternatives_type container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< license_alternatives_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< value_type, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // licenses
    //
    struct licenses_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 9UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::std::map< ::odb::nested_key< ::bpkg::licenses >, ::std::basic_string< char > > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::key_type key_type;
      typedef container_traits_type::value_type value_type;

      typedef map_functions<key_type, value_type> functions_type;
      typedef pgsql::container_statements< licenses_traits > statements_type;

      struct data_image_type
      {
        // key
        //
        composite_value_traits< key_type, id_pgsql >::image_type key_value;

        // value
        //
        details::buffer value_value;
        std::size_t value_size;
        bool value_null;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            const key_type*,
            const value_type&);

      static void
      init (key_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (const key_type&, const value_type&, void*);

      static bool
      select (key_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // topics
    //
    struct topics_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 8UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::butl::small_vector< ::std::basic_string< char >, 5 > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< topics_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        details::buffer value_value;
        std::size_t value_size;
        bool value_null;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // keywords
    //
    struct keywords_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 8UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::butl::small_vector< ::std::basic_string< char >, 5 > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< keywords_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        details::buffer value_value;
        std::size_t value_size;
        bool value_null;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // dependencies
    //
    struct dependencies_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 10UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::brep::package::dependencies_type container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< dependencies_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< value_type, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // dependency_alternatives
    //
    struct dependency_alternatives_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 29UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::std::map< ::odb::nested_key< ::brep::dependency_alternatives >, ::brep::dependency > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::key_type key_type;
      typedef container_traits_type::value_type value_type;

      typedef map_functions<key_type, value_type> functions_type;
      typedef pgsql::container_statements< dependency_alternatives_traits > statements_type;

      struct data_image_type
      {
        // key
        //
        composite_value_traits< key_type, id_pgsql >::image_type key_value;

        // value
        //
        composite_value_traits< value_type, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            const key_type*,
            const value_type&);

      static void
      init (key_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (const key_type&, const value_type&, void*);

      static bool
      select (key_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // requirements
    //
    struct requirements_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 10UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::brep::package::requirements_type container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< requirements_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< value_type, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // requirement_alternatives
    //
    struct requirement_alternatives_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 9UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::std::map< ::odb::nested_key< ::bpkg::requirement_alternatives >, ::std::basic_string< char > > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::key_type key_type;
      typedef container_traits_type::value_type value_type;

      typedef map_functions<key_type, value_type> functions_type;
      typedef pgsql::container_statements< requirement_alternatives_traits > statements_type;

      struct data_image_type
      {
        // key
        //
        composite_value_traits< key_type, id_pgsql >::image_type key_value;

        // value
        //
        details::buffer value_value;
        std::size_t value_size;
        bool value_null;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            const key_type*,
            const value_type&);

      static void
      init (key_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (const key_type&, const value_type&, void*);

      static bool
      select (key_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // tests
    //
    struct tests_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 29UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::butl::small_vector< ::brep::test_dependency, 1 > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< tests_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< value_type, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // builds
    //
    struct builds_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 9UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::brep::build_class_exprs container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< builds_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< value_type, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // build_constraints
    //
    struct build_constraints_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 11UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::brep::package::build_constraints_type container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< build_constraints_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< value_type, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // other_repositories
    //
    struct other_repositories_traits
    {
      static const char select_name[];
      static const char insert_name[];
      static const char delete_name[];

      static const unsigned int insert_types[];

      static const std::size_t id_column_count = 6UL;
      static const std::size_t data_column_count = 9UL;

      static const bool versioned = false;

      static const char insert_statement[];
      static const char select_statement[];
      static const char delete_statement[];

      typedef ::std::vector< ::odb::lazy_shared_ptr< ::brep::repository > > container_type;
      typedef
      odb::access::container_traits<container_type>
      container_traits_type;
      typedef container_traits_type::index_type index_type;
      typedef container_traits_type::value_type value_type;

      typedef ordered_functions<index_type, value_type> functions_type;
      typedef pgsql::container_statements< other_repositories_traits > statements_type;

      struct data_image_type
      {
        // index
        //
        long long index_value;
        bool index_null;

        // value
        //
        composite_value_traits< ::brep::repository_id, id_pgsql >::image_type value_value;

        std::size_t version;
      };

      static void
      bind (pgsql::bind*,
            const pgsql::bind* id,
            std::size_t id_size,
            data_image_type&);

      static void
      grow (data_image_type&,
            bool*);

      static void
      init (data_image_type&,
            index_type*,
            const value_type&);

      static void
      init (index_type&,
            value_type&,
            const data_image_type&,
            database*);

      static void
      insert (index_type, const value_type&, void*);

      static bool
      select (index_type&, value_type&, void*);

      static void
      delete_ (void*);

      static void
      persist (const container_type&,
               statements_type&);

      static void
      load (container_type&,
            statements_type&);

      static void
      update (const container_type&,
              statements_type&);

      static void
      erase (statements_type&);
    };

    // build_section
    //
    struct build_section_traits
    {
      typedef object_traits_impl<object_type, id_pgsql>::image_type image_type;
      typedef object_traits_impl<object_type, id_pgsql>::id_image_type id_image_type;

      static const std::size_t id_column_count = 6UL;
      static const std::size_t managed_optimistic_load_column_count = 0UL;
      static const std::size_t load_column_count = 0UL;
      static const std::size_t managed_optimistic_update_column_count = 0UL;
      static const std::size_t update_column_count = 0UL;

      static const bool versioned = false;

      static void
      load (extra_statement_cache_type&, object_type&);

      static void
      update (extra_statement_cache_type&, const object_type&);
    };

    struct internal_repository_tag;

    using object_traits<object_type>::id;

    static id_type
    id (const image_type&);

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&,
          pgsql::statement_kind);

    static void
    bind (pgsql::bind*, id_image_type&);

    static bool
    init (image_type&,
          const object_type&,
          pgsql::statement_kind);

    static void
    init (object_type&,
          const image_type&,
          database*);

    static void
    init (id_image_type&, const id_type&);

    typedef pgsql::object_statements<object_type> statements_type;

    typedef pgsql::query_base query_base_type;

    static const std::size_t column_count = 42UL;
    static const std::size_t id_column_count = 6UL;
    static const std::size_t inverse_column_count = 0UL;
    static const std::size_t readonly_column_count = 0UL;
    static const std::size_t managed_optimistic_column_count = 0UL;

    static const std::size_t separate_load_column_count = 0UL;
    static const std::size_t separate_update_column_count = 0UL;

    static const bool versioned = false;

    static const char persist_statement[];
    static const char find_statement[];
    static const char update_statement[];
    static const char erase_statement[];
    static const char query_statement[];
    static const char erase_query_statement[];

    static const char table_name[];

    static void
    persist (database&, const object_type&);

    static pointer_type
    find (database&, const id_type&);

    static bool
    find (database&, const id_type&, object_type&);

    static bool
    reload (database&, object_type&);

    static void
    update (database&, const object_type&);

    static void
    erase (database&, const id_type&);

    static void
    erase (database&, const object_type&);

    static bool
    load (connection&, object_type&, section&);

    static bool
    update (connection&, const object_type&, const section&);

    static result<object_type>
    query (database&, const query_base_type&);

    static unsigned long long
    erase_query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char persist_statement_name[];
    static const char find_statement_name[];
    static const char update_statement_name[];
    static const char erase_statement_name[];
    static const char query_statement_name[];
    static const char erase_query_statement_name[];

    static const unsigned int persist_statement_types[];
    static const unsigned int find_statement_types[];
    static const unsigned int update_statement_types[];

    public:
    static bool
    find_ (statements_type&,
           const id_type*);

    static void
    load_ (statements_type&,
           object_type&,
           bool reload);
  };

  template <>
  class access::object_traits_impl< ::brep::package, id_common >:
    public access::object_traits_impl< ::brep::package, id_pgsql >
  {
  };

  // latest_package_search_rank
  //
  template <>
  class access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >:
    public access::view_traits< ::brep::latest_package_search_rank >
  {
    public:
    struct image_type
    {
      // id
      //
      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;

      // rank
      //
      double rank_value;
      bool rank_null;

      std::size_t version;
    };

    typedef pgsql::view_statements<view_type> statements_type;

    typedef pgsql::query_base query_base_type;
    struct query_columns
    {
    };

    static const bool versioned = false;

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&);

    static void
    init (view_type&,
          const image_type&,
          database*);

    static const std::size_t column_count = 7UL;

    static query_base_type
    query_statement (const query_base_type&);

    static result<view_type>
    query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char query_statement_name[];
  };

  template <>
  class access::view_traits_impl< ::brep::latest_package_search_rank, id_common >:
    public access::view_traits_impl< ::brep::latest_package_search_rank, id_pgsql >
  {
  };

  // latest_package_count
  //
  template <>
  class access::view_traits_impl< ::brep::latest_package_count, id_pgsql >:
    public access::view_traits< ::brep::latest_package_count >
  {
    public:
    struct image_type
    {
      // result
      //
      long long result_value;
      bool result_null;

      std::size_t version;
    };

    typedef pgsql::view_statements<view_type> statements_type;

    typedef pgsql::query_base query_base_type;
    struct query_columns
    {
    };

    static const bool versioned = false;

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&);

    static void
    init (view_type&,
          const image_type&,
          database*);

    static const std::size_t column_count = 1UL;

    static query_base_type
    query_statement (const query_base_type&);

    static result<view_type>
    query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char query_statement_name[];
  };

  template <>
  class access::view_traits_impl< ::brep::latest_package_count, id_common >:
    public access::view_traits_impl< ::brep::latest_package_count, id_pgsql >
  {
  };

  // package_search_rank
  //
  template <>
  class access::view_traits_impl< ::brep::package_search_rank, id_pgsql >:
    public access::view_traits< ::brep::package_search_rank >
  {
    public:
    struct image_type
    {
      // id
      //
      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;

      // rank
      //
      double rank_value;
      bool rank_null;

      std::size_t version;
    };

    typedef pgsql::view_statements<view_type> statements_type;

    typedef pgsql::query_base query_base_type;
    struct query_columns
    {
    };

    static const bool versioned = false;

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&);

    static void
    init (view_type&,
          const image_type&,
          database*);

    static const std::size_t column_count = 7UL;

    static query_base_type
    query_statement (const query_base_type&);

    static result<view_type>
    query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char query_statement_name[];
  };

  template <>
  class access::view_traits_impl< ::brep::package_search_rank, id_common >:
    public access::view_traits_impl< ::brep::package_search_rank, id_pgsql >
  {
  };

  // package_count
  //
  template <>
  class access::view_traits_impl< ::brep::package_count, id_pgsql >:
    public access::view_traits< ::brep::package_count >
  {
    public:
    struct image_type
    {
      // result
      //
      long long result_value;
      bool result_null;

      std::size_t version;
    };

    typedef pgsql::view_statements<view_type> statements_type;

    typedef pgsql::query_base query_base_type;
    struct query_columns
    {
    };

    static const bool versioned = false;

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&);

    static void
    init (view_type&,
          const image_type&,
          database*);

    static const std::size_t column_count = 1UL;

    static query_base_type
    query_statement (const query_base_type&);

    static result<view_type>
    query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char query_statement_name[];
  };

  template <>
  class access::view_traits_impl< ::brep::package_count, id_common >:
    public access::view_traits_impl< ::brep::package_count, id_pgsql >
  {
  };

  // latest_package
  //
  template <>
  class access::view_traits_impl< ::brep::latest_package, id_pgsql >:
    public access::view_traits< ::brep::latest_package >
  {
    public:
    struct image_type
    {
      // id
      //
      composite_value_traits< ::brep::package_id, id_pgsql >::image_type id_value;

      std::size_t version;
    };

    typedef pgsql::view_statements<view_type> statements_type;

    typedef pgsql::query_base query_base_type;
    struct query_columns
    {
    };

    static const bool versioned = false;

    static bool
    grow (image_type&,
          bool*);

    static void
    bind (pgsql::bind*,
          image_type&);

    static void
    init (view_type&,
          const image_type&,
          database*);

    static const std::size_t column_count = 6UL;

    static query_base_type
    query_statement (const query_base_type&);

    static result<view_type>
    query (database&, const query_base_type&);

    static odb::details::shared_ptr<prepared_query_impl>
    prepare_query (connection&, const char*, const query_base_type&);

    static odb::details::shared_ptr<result_impl>
    execute_query (prepared_query_impl&);

    static const char query_statement_name[];
  };

  template <>
  class access::view_traits_impl< ::brep::latest_package, id_common >:
    public access::view_traits_impl< ::brep::latest_package, id_pgsql >
  {
  };

  // tenant
  //
  // tenant_id
  //
  struct access::view_traits_impl< ::brep::tenant_id, id_pgsql >::query_columns:
    odb::pointer_query_columns<
      ::brep::tenant,
      id_pgsql,
      odb::access::object_traits_impl< ::brep::tenant, id_pgsql > >
  {
  };

  // repository
  //
  // package
  //
  template <>
  struct alias_traits<
    ::brep::repository,
    id_pgsql,
    access::object_traits_impl< ::brep::package, id_pgsql >::internal_repository_tag>
  {
    static const char table_name[];
  };

  template <>
  struct query_columns_base< ::brep::package, id_pgsql >
  {
    // internal_repository
    //
    typedef
    odb::alias_traits<
      ::brep::repository,
      id_pgsql,
      access::object_traits_impl< ::brep::package, id_pgsql >::internal_repository_tag>
    internal_repository_alias_;
  };

  template <typename A>
  struct query_columns< ::brep::package, id_pgsql, A >:
    query_columns_base< ::brep::package, id_pgsql >
  {
    // id
    //
    struct id_class_
    {
      id_class_ ()
      {
      }

      // tenant
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      tenant_type_;

      static const tenant_type_ tenant;

      // name
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::bpkg::package_name,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      name_type_;

      static const name_type_ name;

      // version
      //
      struct version_class_1_
      {
        version_class_1_ ()
        {
        }

        // epoch
        //
        typedef
        pgsql::query_column<
          pgsql::value_traits<
            ::uint16_t,
            pgsql::id_integer >::query_type,
          pgsql::id_integer >
        epoch_type_;

        static const epoch_type_ epoch;

        // canonical_upstream
        //
        typedef
        pgsql::query_column<
          pgsql::value_traits<
            ::std::string,
            pgsql::id_string >::query_type,
          pgsql::id_string >
        canonical_upstream_type_;

        static const canonical_upstream_type_ canonical_upstream;

        // canonical_release
        //
        typedef
        pgsql::query_column<
          pgsql::value_traits<
            ::std::string,
            pgsql::id_string >::query_type,
          pgsql::id_string >
        canonical_release_type_;

        static const canonical_release_type_ canonical_release;

        // revision
        //
        typedef
        pgsql::query_column<
          pgsql::value_traits<
            ::uint16_t,
            pgsql::id_integer >::query_type,
          pgsql::id_integer >
        revision_type_;

        static const revision_type_ revision;
      };

      static const version_class_1_ version;
    };

    static const id_class_ id;

    // version
    //
    struct version_class_
    {
      version_class_ ()
      {
      }

      // upstream
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      upstream_type_;

      static const upstream_type_ upstream;

      // release
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::basic_string< char >,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      release_type_;

      static const release_type_ release;
    };

    static const version_class_ version;

    // upstream_version
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    upstream_version_type_;

    static const upstream_version_type_ upstream_version;

    // project
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::bpkg::package_name,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    project_type_;

    static const project_type_ project;

    // priority
    //
    struct priority_class_
    {
      priority_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::bpkg::priority::value_type,
          pgsql::id_integer >::query_type,
        pgsql::id_integer >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const priority_class_ priority;

    // summary
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::string,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    summary_type_;

    static const summary_type_ summary;

    // description
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    description_type_;

    static const description_type_ description;

    // description_type
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    description_type_type_;

    static const description_type_type_ description_type;

    // changes
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::string,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    changes_type_;

    static const changes_type_ changes;

    // url
    //
    struct url_class_
    {
      url_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const url_class_ url;

    // doc_url
    //
    struct doc_url_class_
    {
      doc_url_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const doc_url_class_ doc_url;

    // src_url
    //
    struct src_url_class_
    {
      src_url_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const src_url_class_ src_url;

    // package_url
    //
    struct package_url_class_
    {
      package_url_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const package_url_class_ package_url;

    // email
    //
    struct email_class_
    {
      email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const email_class_ email;

    // package_email
    //
    struct package_email_class_
    {
      package_email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const package_email_class_ package_email;

    // build_email
    //
    struct build_email_class_
    {
      build_email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const build_email_class_ build_email;

    // build_warning_email
    //
    struct build_warning_email_class_
    {
      build_warning_email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const build_warning_email_class_ build_warning_email;

    // build_error_email
    //
    struct build_error_email_class_
    {
      build_error_email_class_ ()
      {
      }

      // value
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      value_type_;

      static const value_type_ value;

      // comment
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      comment_type_;

      static const comment_type_ comment;
    };

    static const build_error_email_class_ build_error_email;

    // internal_repository
    //
    struct internal_repository_column_class_
    {
      internal_repository_column_class_ ()
      {
      }

      // tenant
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      tenant_type_;

      static const tenant_type_ tenant;

      // canonical_name
      //
      typedef
      pgsql::query_column<
        pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::query_type,
        pgsql::id_string >
      canonical_name_type_;

      static const canonical_name_type_ canonical_name;
    };

    typedef
    odb::query_pointer<
      odb::pointer_query_columns<
        ::brep::repository,
        id_pgsql,
        internal_repository_alias_ > >
    internal_repository_pointer_type_;

    struct internal_repository_type_: internal_repository_pointer_type_, internal_repository_column_class_
    {
      internal_repository_type_ ()
      {
      }
    };

    static const internal_repository_type_ internal_repository;

    // location
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    location_type_;

    static const location_type_ location;

    // fragment
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    fragment_type_;

    static const fragment_type_ fragment;

    // sha256sum
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    sha256sum_type_;

    static const sha256sum_type_ sha256sum;

    // buildable
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        bool,
        pgsql::id_boolean >::query_type,
      pgsql::id_boolean >
    buildable_type_;

    static const buildable_type_ buildable;

    // unbuildable_reason
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::std::basic_string< char >,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    unbuildable_reason_type_;

    static const unbuildable_reason_type_ unbuildable_reason;

    // search_index
    //
    typedef
    pgsql::query_column<
      pgsql::value_traits<
        ::brep::weighted_text,
        pgsql::id_string >::query_type,
      pgsql::id_string >
    search_index_type_;

    static const search_index_type_ search_index;
  };

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::tenant_type_
  query_columns< ::brep::package, id_pgsql, A >::id_class_::
  tenant (A::table_name, "\"tenant\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::name_type_
  query_columns< ::brep::package, id_pgsql, A >::id_class_::
  name (A::table_name, "\"name\"", "(?)::CITEXT");

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::epoch_type_
  query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
  epoch (A::table_name, "\"version_epoch\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::canonical_upstream_type_
  query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
  canonical_upstream (A::table_name, "\"version_canonical_upstream\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::canonical_release_type_
  query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
  canonical_release (A::table_name, "\"version_canonical_release\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::revision_type_
  query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_::
  revision (A::table_name, "\"version_revision\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_::version_class_1_
  query_columns< ::brep::package, id_pgsql, A >::id_class_::version;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::id_class_
  query_columns< ::brep::package, id_pgsql, A >::id;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::version_class_::upstream_type_
  query_columns< ::brep::package, id_pgsql, A >::version_class_::
  upstream (A::table_name, "\"version_upstream\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::version_class_::release_type_
  query_columns< ::brep::package, id_pgsql, A >::version_class_::
  release (A::table_name, "\"version_release\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::version_class_
  query_columns< ::brep::package, id_pgsql, A >::version;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::upstream_version_type_
  query_columns< ::brep::package, id_pgsql, A >::
  upstream_version (A::table_name, "\"upstream_version\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::project_type_
  query_columns< ::brep::package, id_pgsql, A >::
  project (A::table_name, "\"project\"", "(?)::CITEXT");

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::priority_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::priority_class_::
  value (A::table_name, "\"priority\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::priority_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::priority_class_::
  comment (A::table_name, "\"priority_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::priority_class_
  query_columns< ::brep::package, id_pgsql, A >::priority;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::summary_type_
  query_columns< ::brep::package, id_pgsql, A >::
  summary (A::table_name, "\"summary\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::description_type_
  query_columns< ::brep::package, id_pgsql, A >::
  description (A::table_name, "\"description\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::description_type_type_
  query_columns< ::brep::package, id_pgsql, A >::
  description_type (A::table_name, "\"description_type\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::changes_type_
  query_columns< ::brep::package, id_pgsql, A >::
  changes (A::table_name, "\"changes\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::url_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::url_class_::
  value (A::table_name, "\"url\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::url_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::url_class_::
  comment (A::table_name, "\"url_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::url_class_
  query_columns< ::brep::package, id_pgsql, A >::url;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::
  value (A::table_name, "\"doc_url\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::doc_url_class_::
  comment (A::table_name, "\"doc_url_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::doc_url_class_
  query_columns< ::brep::package, id_pgsql, A >::doc_url;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::src_url_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::src_url_class_::
  value (A::table_name, "\"src_url\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::src_url_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::src_url_class_::
  comment (A::table_name, "\"src_url_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::src_url_class_
  query_columns< ::brep::package, id_pgsql, A >::src_url;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::package_url_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::package_url_class_::
  value (A::table_name, "\"package_url\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::package_url_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::package_url_class_::
  comment (A::table_name, "\"package_url_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::package_url_class_
  query_columns< ::brep::package, id_pgsql, A >::package_url;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::email_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::email_class_::
  value (A::table_name, "\"email\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::email_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::email_class_::
  comment (A::table_name, "\"email_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::email_class_
  query_columns< ::brep::package, id_pgsql, A >::email;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::package_email_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::package_email_class_::
  value (A::table_name, "\"package_email\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::package_email_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::package_email_class_::
  comment (A::table_name, "\"package_email_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::package_email_class_
  query_columns< ::brep::package, id_pgsql, A >::package_email;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_email_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::build_email_class_::
  value (A::table_name, "\"build_email\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_email_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::build_email_class_::
  comment (A::table_name, "\"build_email_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_email_class_
  query_columns< ::brep::package, id_pgsql, A >::build_email;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::
  value (A::table_name, "\"build_warning_email\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_::
  comment (A::table_name, "\"build_warning_email_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_warning_email_class_
  query_columns< ::brep::package, id_pgsql, A >::build_warning_email;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::value_type_
  query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::
  value (A::table_name, "\"build_error_email\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::comment_type_
  query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_::
  comment (A::table_name, "\"build_error_email_comment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::build_error_email_class_
  query_columns< ::brep::package, id_pgsql, A >::build_error_email;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::internal_repository_column_class_::tenant_type_
  query_columns< ::brep::package, id_pgsql, A >::internal_repository_column_class_::
  tenant (A::table_name, "\"internal_repository_tenant\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::internal_repository_column_class_::canonical_name_type_
  query_columns< ::brep::package, id_pgsql, A >::internal_repository_column_class_::
  canonical_name (A::table_name, "\"internal_repository_canonical_name\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::internal_repository_type_
  query_columns< ::brep::package, id_pgsql, A >::internal_repository;

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::location_type_
  query_columns< ::brep::package, id_pgsql, A >::
  location (A::table_name, "\"location\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::fragment_type_
  query_columns< ::brep::package, id_pgsql, A >::
  fragment (A::table_name, "\"fragment\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::sha256sum_type_
  query_columns< ::brep::package, id_pgsql, A >::
  sha256sum (A::table_name, "\"sha256sum\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::buildable_type_
  query_columns< ::brep::package, id_pgsql, A >::
  buildable (A::table_name, "\"buildable\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::unbuildable_reason_type_
  query_columns< ::brep::package, id_pgsql, A >::
  unbuildable_reason (A::table_name, "\"unbuildable_reason\"", 0);

  template <typename A>
  const typename query_columns< ::brep::package, id_pgsql, A >::search_index_type_
  query_columns< ::brep::package, id_pgsql, A >::
  search_index (A::table_name, "\"search_index\"", "to_tsvector((?)::weighted_text)");
}

#include <libbrep/package-odb.ixx>

#include <odb/post.hxx>

#endif // LIBBREP_PACKAGE_ODB_HXX