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

#include <odb/pre.hxx>

#include <libbrep/build-package-odb.hxx>

#include <cassert>
#include <cstring>  // std::memcpy


#include <odb/pgsql/traits.hxx>
#include <odb/pgsql/database.hxx>
#include <odb/pgsql/transaction.hxx>
#include <odb/pgsql/connection.hxx>
#include <odb/pgsql/statement.hxx>
#include <odb/pgsql/statement-cache.hxx>
#include <odb/pgsql/simple-object-statements.hxx>
#include <odb/pgsql/view-statements.hxx>
#include <odb/pgsql/container-statements.hxx>
#include <odb/pgsql/exceptions.hxx>
#include <odb/pgsql/prepared-query.hxx>
#include <odb/pgsql/simple-object-result.hxx>
#include <odb/pgsql/view-result.hxx>

namespace odb
{
  // build_tenant
  //

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  persist_statement_name[] = "persist_brep_build_tenant";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  find_statement_name[] = "find_brep_build_tenant";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  erase_statement_name[] = "erase_brep_build_tenant";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  query_statement_name[] = "query_brep_build_tenant";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  erase_query_statement_name[] = "erase_query_brep_build_tenant";

  const unsigned int access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  persist_statement_types[] =
  {
    pgsql::text_oid,
    pgsql::bool_oid
  };

  const unsigned int access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  find_statement_types[] =
  {
    pgsql::text_oid
  };

  struct access::object_traits_impl< ::brep::build_tenant, id_pgsql >::extra_statement_cache_type
  {
    extra_statement_cache_type (
      pgsql::connection&,
      image_type&,
      id_image_type&,
      pgsql::binding&,
      pgsql::binding&,
      pgsql::native_binding&,
      const unsigned int*)
    {
    }
  };

  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::id_type
  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  id (const image_type& i)
  {
    pgsql::database* db (0);
    ODB_POTENTIALLY_UNUSED (db);

    id_type id;
    {
      pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::set_value (
        id,
        i.id_value,
        i.id_size,
        i.id_null);
    }

    return id;
  }

  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  grow (image_type& i,
        bool* t)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (t);

    bool grew (false);

    // id
    //
    if (t[0UL])
    {
      i.id_value.capacity (i.id_size);
      grew = true;
    }

    // archived
    //
    t[1UL] = 0;

    return grew;
  }

  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  bind (pgsql::bind* b,
        image_type& i,
        pgsql::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace pgsql;

    assert (sk != statement_update);

    std::size_t n (0);

    // id
    //
    b[n].type = pgsql::bind::text;
    b[n].buffer = i.id_value.data ();
    b[n].capacity = i.id_value.capacity ();
    b[n].size = &i.id_size;
    b[n].is_null = &i.id_null;
    n++;

    // archived
    //
    b[n].type = pgsql::bind::boolean_;
    b[n].buffer = &i.archived_value;
    b[n].is_null = &i.archived_null;
    n++;
  }

  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  bind (pgsql::bind* b, id_image_type& i)
  {
    std::size_t n (0);
    b[n].type = pgsql::bind::text;
    b[n].buffer = i.id_value.data ();
    b[n].capacity = i.id_value.capacity ();
    b[n].size = &i.id_size;
    b[n].is_null = &i.id_null;
  }

  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  init (image_type& i,
        const object_type& o,
        pgsql::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace pgsql;

    assert (sk != statement_update);

    bool grew (false);

    // id
    //
    {
      ::std::string const& v =
        o.id;

      bool is_null (false);
      std::size_t size (0);
      std::size_t cap (i.id_value.capacity ());
      pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::set_image (
        i.id_value,
        size,
        is_null,
        v);
      i.id_null = is_null;
      i.id_size = size;
      grew = grew || (cap != i.id_value.capacity ());
    }

    // archived
    //
    {
      bool const& v =
        o.archived;

      bool is_null (false);
      pgsql::value_traits<
          bool,
          pgsql::id_boolean >::set_image (
        i.archived_value, is_null, v);
      i.archived_null = is_null;
    }

    return grew;
  }

  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  init (object_type& o,
        const image_type& i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (db);

    // id
    //
    {
      ::std::string& v =
        o.id;

      pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::set_value (
        v,
        i.id_value,
        i.id_size,
        i.id_null);
    }

    // archived
    //
    {
      bool& v =
        o.archived;

      pgsql::value_traits<
          bool,
          pgsql::id_boolean >::set_value (
        v,
        i.archived_value,
        i.archived_null);
    }
  }

  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  init (id_image_type& i, const id_type& id)
  {
    bool grew (false);
    {
      bool is_null (false);
      std::size_t size (0);
      std::size_t cap (i.id_value.capacity ());
      pgsql::value_traits<
          ::std::string,
          pgsql::id_string >::set_image (
        i.id_value,
        size,
        is_null,
        id);
      i.id_null = is_null;
      i.id_size = size;
      grew = grew || (cap != i.id_value.capacity ());
    }

    if (grew)
      i.version++;
  }

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::persist_statement[] =
  "INSERT INTO \"build_tenant\" "
  "(\"id\", "
  "\"archived\") "
  "VALUES "
  "($1, $2)";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::find_statement[] =
  "SELECT "
  "\"build_tenant\".\"id\", "
  "\"build_tenant\".\"archived\" "
  "FROM \"build_tenant\" "
  "WHERE \"build_tenant\".\"id\"=$1";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::erase_statement[] =
  "DELETE FROM \"build_tenant\" "
  "WHERE \"id\"=$1";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::query_statement[] =
  "SELECT "
  "\"build_tenant\".\"id\", "
  "\"build_tenant\".\"archived\" "
  "FROM \"build_tenant\"";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::erase_query_statement[] =
  "DELETE FROM \"build_tenant\"";

  const char access::object_traits_impl< ::brep::build_tenant, id_pgsql >::table_name[] =
  "\"build_tenant\"";

  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  persist (database& db, const object_type& obj)
  {
    ODB_POTENTIALLY_UNUSED (db);

    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    callback (db,
              obj,
              callback_event::pre_persist);

    image_type& im (sts.image ());
    binding& imb (sts.insert_image_binding ());

    if (init (im, obj, statement_insert))
      im.version++;

    if (im.version != sts.insert_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_insert);
      sts.insert_image_version (im.version);
      imb.version++;
    }

    insert_statement& st (sts.persist_statement ());
    if (!st.execute ())
      throw object_already_persistent ();

    callback (db,
              obj,
              callback_event::post_persist);
  }

  void access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  erase (database& db, const id_type& id)
  {
    using namespace pgsql;

    ODB_POTENTIALLY_UNUSED (db);

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    id_image_type& i (sts.id_image ());
    init (i, id);

    binding& idb (sts.id_image_binding ());
    if (i.version != sts.id_image_version () || idb.version == 0)
    {
      bind (idb.bind, i);
      sts.id_image_version (i.version);
      idb.version++;
    }

    if (sts.erase_statement ().execute () != 1)
      throw object_not_persistent ();

    pointer_cache_traits::erase (db, id);
  }

  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::pointer_type
  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  find (database& db, const id_type& id)
  {
    using namespace pgsql;

    {
      pointer_type p (pointer_cache_traits::find (db, id));

      if (!pointer_traits::null_ptr (p))
        return p;
    }

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);

    if (l.locked ())
    {
      if (!find_ (sts, &id))
        return pointer_type ();
    }

    pointer_type p (
      access::object_factory<object_type, pointer_type>::create ());
    pointer_traits::guard pg (p);

    pointer_cache_traits::insert_guard ig (
      pointer_cache_traits::insert (db, id, p));

    object_type& obj (pointer_traits::get_ref (p));

    if (l.locked ())
    {
      select_statement& st (sts.find_statement ());
      ODB_POTENTIALLY_UNUSED (st);

      callback (db, obj, callback_event::pre_load);
      init (obj, sts.image (), &db);
      load_ (sts, obj, false);
      sts.load_delayed (0);
      l.unlock ();
      callback (db, obj, callback_event::post_load);
      pointer_cache_traits::load (ig.position ());
    }
    else
      sts.delay_load (id, obj, ig.position ());

    ig.release ();
    pg.release ();
    return p;
  }

  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  find (database& db, const id_type& id, object_type& obj)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);
    assert (l.locked ()) /* Must be a top-level call. */;

    if (!find_ (sts, &id))
      return false;

    select_statement& st (sts.find_statement ());
    ODB_POTENTIALLY_UNUSED (st);

    reference_cache_traits::position_type pos (
      reference_cache_traits::insert (db, id, obj));
    reference_cache_traits::insert_guard ig (pos);

    callback (db, obj, callback_event::pre_load);
    init (obj, sts.image (), &db);
    load_ (sts, obj, false);
    sts.load_delayed (0);
    l.unlock ();
    callback (db, obj, callback_event::post_load);
    reference_cache_traits::load (pos);
    ig.release ();
    return true;
  }

  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  reload (database& db, object_type& obj)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);
    assert (l.locked ()) /* Must be a top-level call. */;

    const id_type& id (object_traits_impl::id (obj));
    if (!find_ (sts, &id))
      return false;

    select_statement& st (sts.find_statement ());
    ODB_POTENTIALLY_UNUSED (st);

    callback (db, obj, callback_event::pre_load);
    init (obj, sts.image (), &db);
    load_ (sts, obj, true);
    sts.load_delayed (0);
    l.unlock ();
    callback (db, obj, callback_event::post_load);
    return true;
  }

  bool access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  find_ (statements_type& sts,
         const id_type* id)
  {
    using namespace pgsql;

    id_image_type& i (sts.id_image ());
    init (i, *id);

    binding& idb (sts.id_image_binding ());
    if (i.version != sts.id_image_version () || idb.version == 0)
    {
      bind (idb.bind, i);
      sts.id_image_version (i.version);
      idb.version++;
    }

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    select_statement& st (sts.find_statement ());

    st.execute ();
    auto_result ar (st);
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      if (grow (im, sts.select_image_truncated ()))
        im.version++;

      if (im.version != sts.select_image_version ())
      {
        bind (imb.bind, im, statement_select);
        sts.select_image_version (im.version);
        imb.version++;
        st.refetch ();
      }
    }

    return r != select_statement::no_data;
  }

  result< access::object_traits_impl< ::brep::build_tenant, id_pgsql >::object_type >
  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  query (database&, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    std::string text (query_statement);
    if (!q.empty ())
    {
      text += " ";
      text += q.clause ();
    }

    q.init_parameters ();
    shared_ptr<select_statement> st (
      new (shared) select_statement (
        sts.connection (),
        query_statement_name,
        text,
        false,
        true,
        q.parameter_types (),
        q.parameter_count (),
        q.parameters_binding (),
        imb));

    st->execute ();
    st->deallocate ();

    shared_ptr< odb::object_result_impl<object_type> > r (
      new (shared) pgsql::object_result_impl<object_type> (
        q, st, sts, 0));

    return result<object_type> (r);
  }

  unsigned long long access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  erase_query (database&, const query_base_type& q)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    std::string text (erase_query_statement);
    if (!q.empty ())
    {
      text += ' ';
      text += q.clause ();
    }

    q.init_parameters ();
    delete_statement st (
      conn,
      erase_query_statement_name,
      text,
      q.parameter_types (),
      q.parameter_count (),
      q.parameters_binding ());

    return st.execute ();
  }

  odb::details::shared_ptr<prepared_query_impl>
  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  prepare_query (connection& c, const char* n, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      static_cast<pgsql::connection&> (c));

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    std::string text (query_statement);
    if (!q.empty ())
    {
      text += " ";
      text += q.clause ();
    }

    shared_ptr<pgsql::prepared_query_impl> r (
      new (shared) pgsql::prepared_query_impl (conn));
    r->name = n;
    r->execute = &execute_query;
    r->query = q;
    r->stmt.reset (
      new (shared) select_statement (
        sts.connection (),
        n,
        text,
        false,
        true,
        r->query.parameter_types (),
        r->query.parameter_count (),
        r->query.parameters_binding (),
        imb));

    return r;
  }

  odb::details::shared_ptr<result_impl>
  access::object_traits_impl< ::brep::build_tenant, id_pgsql >::
  execute_query (prepared_query_impl& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::prepared_query_impl& pq (
      static_cast<pgsql::prepared_query_impl&> (q));
    shared_ptr<select_statement> st (
      odb::details::inc_ref (
        static_cast<select_statement*> (pq.stmt.get ())));

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    // The connection used by the current transaction and the
    // one used to prepare this statement must be the same.
    //
    assert (&conn == &st->connection ());

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    pq.query.init_parameters ();
    st->execute ();

    return shared_ptr<result_impl> (
      new (shared) pgsql::object_result_impl<object_type> (
        pq.query, st, sts, 0));
  }

  // build_repository
  //

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  persist_statement_name[] = "persist_brep_build_repository";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  find_statement_name[] = "find_brep_build_repository";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  erase_statement_name[] = "erase_brep_build_repository";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  query_statement_name[] = "query_brep_build_repository";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  erase_query_statement_name[] = "erase_query_brep_build_repository";

  const unsigned int access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  persist_statement_types[] =
  {
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::text_oid
  };

  const unsigned int access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  find_statement_types[] =
  {
    pgsql::text_oid,
    pgsql::text_oid
  };

  struct access::object_traits_impl< ::brep::build_repository, id_pgsql >::extra_statement_cache_type
  {
    extra_statement_cache_type (
      pgsql::connection&,
      image_type&,
      id_image_type&,
      pgsql::binding&,
      pgsql::binding&,
      pgsql::native_binding&,
      const unsigned int*)
    {
    }
  };

  access::object_traits_impl< ::brep::build_repository, id_pgsql >::id_type
  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  id (const image_type& i)
  {
    pgsql::database* db (0);
    ODB_POTENTIALLY_UNUSED (db);

    id_type id;
    {
      composite_value_traits< ::brep::repository_id, id_pgsql >::init (
        id,
        i.id_value,
        db);
    }

    return id;
  }

  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  grow (image_type& i,
        bool* t)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (t);

    bool grew (false);

    // id
    //
    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
          i.id_value, t + 0UL))
      grew = true;

    // location
    //
    if (composite_value_traits< ::brep::_repository_location, id_pgsql >::grow (
          i.location_value, t + 2UL))
      grew = true;

    // certificate_fingerprint
    //
    if (t[4UL])
    {
      i.certificate_fingerprint_value.capacity (i.certificate_fingerprint_size);
      grew = true;
    }

    return grew;
  }

  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  bind (pgsql::bind* b,
        image_type& i,
        pgsql::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace pgsql;

    assert (sk != statement_update);

    std::size_t n (0);

    // id
    //
    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
      b + n, i.id_value, sk);
    n += 2UL;

    // location
    //
    composite_value_traits< ::brep::_repository_location, id_pgsql >::bind (
      b + n, i.location_value, sk);
    n += 2UL;

    // certificate_fingerprint
    //
    b[n].type = pgsql::bind::text;
    b[n].buffer = i.certificate_fingerprint_value.data ();
    b[n].capacity = i.certificate_fingerprint_value.capacity ();
    b[n].size = &i.certificate_fingerprint_size;
    b[n].is_null = &i.certificate_fingerprint_null;
    n++;
  }

  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  bind (pgsql::bind* b, id_image_type& i)
  {
    std::size_t n (0);
    pgsql::statement_kind sk (pgsql::statement_select);
    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
      b + n, i.id_value, sk);
  }

  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  init (image_type& i,
        const object_type& o,
        pgsql::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace pgsql;

    assert (sk != statement_update);

    bool grew (false);

    // id
    //
    {
      ::brep::repository_id const& v =
        o.id;

      if (composite_value_traits< ::brep::repository_id, id_pgsql >::init (
            i.id_value,
            v,
            sk))
        grew = true;
    }

    // location
    //
    {
      ::bpkg::repository_location const& v =
        o.location;

      // From common.hxx:285:14
      ::brep::_repository_location const& vt =
        brep::_repository_location 
      {
         (v).url (), (v).empty () ? brep::repository_type::pkg : (v).type () 
      };


      if (composite_value_traits< ::brep::_repository_location, id_pgsql >::init (
            i.location_value,
            vt,
            sk))
        grew = true;
    }

    // certificate_fingerprint
    //
    {
      ::butl::optional< ::std::basic_string< char > > const& v =
        o.certificate_fingerprint;

      bool is_null (true);
      std::size_t size (0);
      std::size_t cap (i.certificate_fingerprint_value.capacity ());
      pgsql::value_traits<
          ::butl::optional< ::std::basic_string< char > >,
          pgsql::id_string >::set_image (
        i.certificate_fingerprint_value,
        size,
        is_null,
        v);
      i.certificate_fingerprint_null = is_null;
      i.certificate_fingerprint_size = size;
      grew = grew || (cap != i.certificate_fingerprint_value.capacity ());
    }

    return grew;
  }

  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  init (object_type& o,
        const image_type& i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (db);

    // id
    //
    {
      ::brep::repository_id& v =
        o.id;

      composite_value_traits< ::brep::repository_id, id_pgsql >::init (
        v,
        i.id_value,
        db);
    }

    // location
    //
    {
      // From build-package.hxx:63:7
      ::bpkg::repository_location v;

      ::brep::_repository_location vt;

      composite_value_traits< ::brep::_repository_location, id_pgsql >::init (
        vt,
        i.location_value,
        db);

      // From common.hxx:285:14
      v = brep::repository_location (std::move ((vt).url), (vt).type);
      // From build-package.hxx:63:7
      o.location = std::move (v);
      assert (o.canonical_name == o.location.canonical_name ());
    }

    // certificate_fingerprint
    //
    {
      ::butl::optional< ::std::basic_string< char > >& v =
        o.certificate_fingerprint;

      pgsql::value_traits<
          ::butl::optional< ::std::basic_string< char > >,
          pgsql::id_string >::set_value (
        v,
        i.certificate_fingerprint_value,
        i.certificate_fingerprint_size,
        i.certificate_fingerprint_null);
    }
  }

  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  init (id_image_type& i, const id_type& id)
  {
    bool grew (false);
    pgsql::statement_kind sk (pgsql::statement_select);
    {
      if (composite_value_traits< ::brep::repository_id, id_pgsql >::init (
            i.id_value,
            id,
            sk))
        grew = true;
    }

    if (grew)
      i.version++;
  }

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::persist_statement[] =
  "INSERT INTO \"build_repository\" "
  "(\"tenant\", "
  "\"canonical_name\", "
  "\"location_url\", "
  "\"location_type\", "
  "\"certificate_fingerprint\") "
  "VALUES "
  "($1, $2, $3, $4, $5)";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::find_statement[] =
  "SELECT "
  "\"build_repository\".\"tenant\", "
  "\"build_repository\".\"canonical_name\", "
  "\"build_repository\".\"location_url\", "
  "\"build_repository\".\"location_type\", "
  "\"build_repository\".\"certificate_fingerprint\" "
  "FROM \"build_repository\" "
  "WHERE \"build_repository\".\"tenant\"=$1 AND \"build_repository\".\"canonical_name\"=$2";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::erase_statement[] =
  "DELETE FROM \"build_repository\" "
  "WHERE \"tenant\"=$1 AND \"canonical_name\"=$2";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::query_statement[] =
  "SELECT "
  "\"build_repository\".\"tenant\", "
  "\"build_repository\".\"canonical_name\", "
  "\"build_repository\".\"location_url\", "
  "\"build_repository\".\"location_type\", "
  "\"build_repository\".\"certificate_fingerprint\" "
  "FROM \"build_repository\"";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::erase_query_statement[] =
  "DELETE FROM \"build_repository\"";

  const char access::object_traits_impl< ::brep::build_repository, id_pgsql >::table_name[] =
  "\"build_repository\"";

  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  persist (database& db, const object_type& obj)
  {
    ODB_POTENTIALLY_UNUSED (db);

    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    callback (db,
              obj,
              callback_event::pre_persist);

    image_type& im (sts.image ());
    binding& imb (sts.insert_image_binding ());

    if (init (im, obj, statement_insert))
      im.version++;

    if (im.version != sts.insert_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_insert);
      sts.insert_image_version (im.version);
      imb.version++;
    }

    insert_statement& st (sts.persist_statement ());
    if (!st.execute ())
      throw object_already_persistent ();

    callback (db,
              obj,
              callback_event::post_persist);
  }

  void access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  erase (database& db, const id_type& id)
  {
    using namespace pgsql;

    ODB_POTENTIALLY_UNUSED (db);

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    id_image_type& i (sts.id_image ());
    init (i, id);

    binding& idb (sts.id_image_binding ());
    if (i.version != sts.id_image_version () || idb.version == 0)
    {
      bind (idb.bind, i);
      sts.id_image_version (i.version);
      idb.version++;
    }

    if (sts.erase_statement ().execute () != 1)
      throw object_not_persistent ();

    pointer_cache_traits::erase (db, id);
  }

  access::object_traits_impl< ::brep::build_repository, id_pgsql >::pointer_type
  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  find (database& db, const id_type& id)
  {
    using namespace pgsql;

    {
      pointer_type p (pointer_cache_traits::find (db, id));

      if (!pointer_traits::null_ptr (p))
        return p;
    }

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);

    if (l.locked ())
    {
      if (!find_ (sts, &id))
        return pointer_type ();
    }

    pointer_type p (
      access::object_factory<object_type, pointer_type>::create ());
    pointer_traits::guard pg (p);

    pointer_cache_traits::insert_guard ig (
      pointer_cache_traits::insert (db, id, p));

    object_type& obj (pointer_traits::get_ref (p));

    if (l.locked ())
    {
      select_statement& st (sts.find_statement ());
      ODB_POTENTIALLY_UNUSED (st);

      callback (db, obj, callback_event::pre_load);
      init (obj, sts.image (), &db);
      load_ (sts, obj, false);
      sts.load_delayed (0);
      l.unlock ();
      callback (db, obj, callback_event::post_load);
      pointer_cache_traits::load (ig.position ());
    }
    else
      sts.delay_load (id, obj, ig.position ());

    ig.release ();
    pg.release ();
    return p;
  }

  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  find (database& db, const id_type& id, object_type& obj)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);
    assert (l.locked ()) /* Must be a top-level call. */;

    if (!find_ (sts, &id))
      return false;

    select_statement& st (sts.find_statement ());
    ODB_POTENTIALLY_UNUSED (st);

    reference_cache_traits::position_type pos (
      reference_cache_traits::insert (db, id, obj));
    reference_cache_traits::insert_guard ig (pos);

    callback (db, obj, callback_event::pre_load);
    init (obj, sts.image (), &db);
    load_ (sts, obj, false);
    sts.load_delayed (0);
    l.unlock ();
    callback (db, obj, callback_event::post_load);
    reference_cache_traits::load (pos);
    ig.release ();
    return true;
  }

  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  reload (database& db, object_type& obj)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);
    assert (l.locked ()) /* Must be a top-level call. */;

    const id_type& id (object_traits_impl::id (obj));
    if (!find_ (sts, &id))
      return false;

    select_statement& st (sts.find_statement ());
    ODB_POTENTIALLY_UNUSED (st);

    callback (db, obj, callback_event::pre_load);
    init (obj, sts.image (), &db);
    load_ (sts, obj, true);
    sts.load_delayed (0);
    l.unlock ();
    callback (db, obj, callback_event::post_load);
    return true;
  }

  bool access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  find_ (statements_type& sts,
         const id_type* id)
  {
    using namespace pgsql;

    id_image_type& i (sts.id_image ());
    init (i, *id);

    binding& idb (sts.id_image_binding ());
    if (i.version != sts.id_image_version () || idb.version == 0)
    {
      bind (idb.bind, i);
      sts.id_image_version (i.version);
      idb.version++;
    }

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    select_statement& st (sts.find_statement ());

    st.execute ();
    auto_result ar (st);
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      if (grow (im, sts.select_image_truncated ()))
        im.version++;

      if (im.version != sts.select_image_version ())
      {
        bind (imb.bind, im, statement_select);
        sts.select_image_version (im.version);
        imb.version++;
        st.refetch ();
      }
    }

    return r != select_statement::no_data;
  }

  result< access::object_traits_impl< ::brep::build_repository, id_pgsql >::object_type >
  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  query (database&, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    std::string text (query_statement);
    if (!q.empty ())
    {
      text += " ";
      text += q.clause ();
    }

    q.init_parameters ();
    shared_ptr<select_statement> st (
      new (shared) select_statement (
        sts.connection (),
        query_statement_name,
        text,
        false,
        true,
        q.parameter_types (),
        q.parameter_count (),
        q.parameters_binding (),
        imb));

    st->execute ();
    st->deallocate ();

    shared_ptr< odb::object_result_impl<object_type> > r (
      new (shared) pgsql::object_result_impl<object_type> (
        q, st, sts, 0));

    return result<object_type> (r);
  }

  unsigned long long access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  erase_query (database&, const query_base_type& q)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    std::string text (erase_query_statement);
    if (!q.empty ())
    {
      text += ' ';
      text += q.clause ();
    }

    q.init_parameters ();
    delete_statement st (
      conn,
      erase_query_statement_name,
      text,
      q.parameter_types (),
      q.parameter_count (),
      q.parameters_binding ());

    return st.execute ();
  }

  odb::details::shared_ptr<prepared_query_impl>
  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  prepare_query (connection& c, const char* n, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      static_cast<pgsql::connection&> (c));

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    std::string text (query_statement);
    if (!q.empty ())
    {
      text += " ";
      text += q.clause ();
    }

    shared_ptr<pgsql::prepared_query_impl> r (
      new (shared) pgsql::prepared_query_impl (conn));
    r->name = n;
    r->execute = &execute_query;
    r->query = q;
    r->stmt.reset (
      new (shared) select_statement (
        sts.connection (),
        n,
        text,
        false,
        true,
        r->query.parameter_types (),
        r->query.parameter_count (),
        r->query.parameters_binding (),
        imb));

    return r;
  }

  odb::details::shared_ptr<result_impl>
  access::object_traits_impl< ::brep::build_repository, id_pgsql >::
  execute_query (prepared_query_impl& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::prepared_query_impl& pq (
      static_cast<pgsql::prepared_query_impl&> (q));
    shared_ptr<select_statement> st (
      odb::details::inc_ref (
        static_cast<select_statement*> (pq.stmt.get ())));

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    // The connection used by the current transaction and the
    // one used to prepare this statement must be the same.
    //
    assert (&conn == &st->connection ());

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    pq.query.init_parameters ();
    st->execute ();

    return shared_ptr<result_impl> (
      new (shared) pgsql::object_result_impl<object_type> (
        pq.query, st, sts, 0));
  }

  // build_test_dependency
  //

  bool access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
  grow (image_type& i,
        bool* t)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (t);

    bool grew (false);

    // name
    //
    if (t[0UL])
    {
      i.name_value.capacity (i.name_size);
      grew = true;
    }

    // package
    //
    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
          i.package_value, t + 1UL))
      grew = true;

    return grew;
  }

  void access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
  bind (pgsql::bind* b,
        image_type& i,
        pgsql::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (b);
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace pgsql;

    std::size_t n (0);
    ODB_POTENTIALLY_UNUSED (n);

    // name
    //
    b[n].type = pgsql::bind::text;
    b[n].buffer = i.name_value.data ();
    b[n].capacity = i.name_value.capacity ();
    b[n].size = &i.name_size;
    b[n].is_null = &i.name_null;
    n++;

    // package
    //
    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
      b + n, i.package_value, sk);
    n += 6UL;
  }

  bool access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
  init (image_type& i,
        const value_type& o,
        pgsql::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace pgsql;

    bool grew (false);

    // name
    //
    {
      ::bpkg::package_name const& v =
        o.name;

      bool is_null (false);
      std::size_t size (0);
      std::size_t cap (i.name_value.capacity ());
      pgsql::value_traits<
          ::bpkg::package_name,
          pgsql::id_string >::set_image (
        i.name_value,
        size,
        is_null,
        v);
      i.name_null = is_null;
      i.name_size = size;
      grew = grew || (cap != i.name_value.capacity ());
    }

    // package
    //
    {
      ::odb::lazy_shared_ptr< ::brep::build_package > const& v =
        o.package;

      typedef object_traits< ::brep::build_package > obj_traits;
      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::build_package > > ptr_traits;

      bool is_null (ptr_traits::null_ptr (v));
      if (!is_null)
      {
        const obj_traits::id_type& ptr_id (
          ptr_traits::object_id< ptr_traits::element_type  > (v));

        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
              i.package_value,
              ptr_id,
              sk))
          grew = true;
      }
      else
        composite_value_traits< obj_traits::id_type, id_pgsql >::set_null (i.package_value, sk);
    }

    return grew;
  }

  void access::composite_value_traits< ::brep::build_test_dependency, id_pgsql >::
  init (value_type& o,
        const image_type&  i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (db);

    // name
    //
    {
      ::bpkg::package_name& v =
        o.name;

      pgsql::value_traits<
          ::bpkg::package_name,
          pgsql::id_string >::set_value (
        v,
        i.name_value,
        i.name_size,
        i.name_null);
    }

    // package
    //
    {
      ::odb::lazy_shared_ptr< ::brep::build_package >& v =
        o.package;

      typedef object_traits< ::brep::build_package > obj_traits;
      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::build_package > > ptr_traits;

      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
            i.package_value))
        v = ptr_traits::pointer_type ();
      else
      {
        obj_traits::id_type ptr_id;
        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
          ptr_id,
          i.package_value,
          db);

        v = ptr_traits::pointer_type (
          *static_cast<pgsql::database*> (db), ptr_id);
      }
    }
  }

  // build_package
  //

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
  persist_statement_name[] = "persist_brep_build_package";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
  find_statement_name[] = "find_brep_build_package";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
  erase_statement_name[] = "erase_brep_build_package";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
  query_statement_name[] = "query_brep_build_package";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::
  erase_query_statement_name[] = "erase_query_brep_build_package";

  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::
  persist_statement_types[] =
  {
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::bool_oid
  };

  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::
  find_statement_types[] =
  {
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid
  };

  const char alias_traits<  ::brep::build_repository,
    id_pgsql,
    access::object_traits_impl< ::brep::build_package, id_pgsql >::internal_repository_tag>::
  table_name[] = "\"internal_repository\"";

  struct access::object_traits_impl< ::brep::build_package, id_pgsql >::extra_statement_cache_type
  {
    pgsql::container_statements_impl< tests_traits > tests;
    pgsql::container_statements_impl< builds_traits > builds;
    pgsql::container_statements_impl< constraints_traits > constraints;

    extra_statement_cache_type (
      pgsql::connection& c,
      image_type&,
      id_image_type&,
      pgsql::binding& id,
      pgsql::binding&,
      pgsql::native_binding& idn,
      const unsigned int* idt)
    : tests (c, id, idn, idt),
      builds (c, id, idn, idt),
      constraints (c, id, idn, idt)
    {
    }
  };

  // tests
  //

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  select_name[] = "select_brep_build_package_tests";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  insert_name[] = "insert_brep_build_package_tests";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  delete_name[] = "delete_brep_build_package_tests";

  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  insert_types[] =
  {
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::int8_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid
  };

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  select_statement[] =
  "SELECT "
  "\"build_package_tests\".\"index\", "
  "\"build_package_tests\".\"test_name\"::TEXT, "
  "\"build_package_tests\".\"test_package_tenant\", "
  "\"build_package_tests\".\"test_package_name\"::TEXT, "
  "\"build_package_tests\".\"test_package_version_epoch\", "
  "\"build_package_tests\".\"test_package_version_canonical_upstream\", "
  "\"build_package_tests\".\"test_package_version_canonical_release\", "
  "\"build_package_tests\".\"test_package_version_revision\" "
  "FROM \"build_package_tests\" "
  "WHERE \"build_package_tests\".\"tenant\"=$1 AND \"build_package_tests\".\"name\"=$2::CITEXT AND \"build_package_tests\".\"version_epoch\"=$3 AND \"build_package_tests\".\"version_canonical_upstream\"=$4 AND \"build_package_tests\".\"version_canonical_release\"=$5 AND \"build_package_tests\".\"version_revision\"=$6 ORDER BY \"build_package_tests\".\"index\"";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  insert_statement[] =
  "INSERT INTO \"build_package_tests\" "
  "(\"tenant\", "
  "\"name\", "
  "\"version_epoch\", "
  "\"version_canonical_upstream\", "
  "\"version_canonical_release\", "
  "\"version_revision\", "
  "\"index\", "
  "\"test_name\", "
  "\"test_package_tenant\", "
  "\"test_package_name\", "
  "\"test_package_version_epoch\", "
  "\"test_package_version_canonical_upstream\", "
  "\"test_package_version_canonical_release\", "
  "\"test_package_version_revision\") "
  "VALUES "
  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8::CITEXT, $9, $10::CITEXT, $11, $12, $13, $14)";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  delete_statement[] =
  "DELETE FROM \"build_package_tests\" "
  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  bind (pgsql::bind* b,
        const pgsql::bind* id,
        std::size_t id_size,
        data_image_type& d)
  {
    using namespace pgsql;

    statement_kind sk (statement_select);
    ODB_POTENTIALLY_UNUSED (sk);

    size_t n (0);

    // object_id
    //
    if (id != 0)
      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
    n += id_size;

    // index
    //
    b[n].type = pgsql::bind::bigint;
    b[n].buffer = &d.index_value;
    b[n].is_null = &d.index_null;
    n++;

    // value
    //
    composite_value_traits< value_type, id_pgsql >::bind (
      b + n, d.value_value, sk);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  grow (data_image_type& i,
        bool* t)
  {
    bool grew (false);

    // index
    //
    t[0UL] = 0;

    // value
    //
    if (composite_value_traits< value_type, id_pgsql >::grow (
          i.value_value, t + 1UL))
      grew = true;

    if (grew)
      i.version++;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  init (data_image_type& i,
        index_type* j,
        const value_type& v)
  {
    using namespace pgsql;

    statement_kind sk (statement_insert);
    ODB_POTENTIALLY_UNUSED (sk);

    bool grew (false);

    // index
    //
    if (j != 0)
    {
      bool is_null (false);
      pgsql::value_traits<
          index_type,
          pgsql::id_bigint >::set_image (
        i.index_value, is_null, *j);
      i.index_null = is_null;
    }

    // value
    //
    {
      if (composite_value_traits< value_type, id_pgsql >::init (
            i.value_value,
            v,
            sk))
        grew = true;
    }

    if (grew)
      i.version++;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  init (index_type& j,
        value_type& v,
        const data_image_type& i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (db);

    // index
    //
    {
      pgsql::value_traits<
          index_type,
          pgsql::id_bigint >::set_value (
        j,
        i.index_value,
        i.index_null);
    }

    // value
    //
    {
      composite_value_traits< value_type, id_pgsql >::init (
        v,
        i.value_value,
        db);
    }
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  insert (index_type i, const value_type& v, void* d)
  {
    using namespace pgsql;

    statements_type& sts (*static_cast< statements_type* > (d));
    data_image_type& di (sts.data_image ());

    init (di, &i, v);

    if (sts.data_binding_test_version ())
    {
      const binding& id (sts.id_binding ());
      bind (sts.data_bind (), id.bind, id.count, di);
      sts.data_binding_update_version ();
    }

    if (!sts.insert_statement ().execute ())
      throw object_already_persistent ();
  }

  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  select (index_type& i, value_type& v, void* d)
  {
    using namespace pgsql;
    using pgsql::select_statement;

    statements_type& sts (*static_cast< statements_type* > (d));
    data_image_type& di (sts.data_image ());

    init (i, v, di, &sts.connection ().database ());

    select_statement& st (sts.select_statement ());
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      grow (di, sts.select_image_truncated ());

      if (sts.data_binding_test_version ())
      {
        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
        sts.data_binding_update_version ();
        st.refetch ();
      }
    }

    return r != select_statement::no_data;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  delete_ (void* d)
  {
    using namespace pgsql;

    statements_type& sts (*static_cast< statements_type* > (d));
    sts.delete_statement ().execute ();
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  persist (const container_type& c,
           statements_type& sts)
  {
    using namespace pgsql;

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::persist (c, fs);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  load (container_type& c,
        statements_type& sts)
  {
    using namespace pgsql;
    using pgsql::select_statement;

    const binding& id (sts.id_binding ());

    if (sts.data_binding_test_version ())
    {
      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
      sts.data_binding_update_version ();
    }

    select_statement& st (sts.select_statement ());
    st.execute ();
    auto_result ar (st);
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      data_image_type& di (sts.data_image ());
      grow (di, sts.select_image_truncated ());

      if (sts.data_binding_test_version ())
      {
        bind (sts.data_bind (), 0, id.count, di);
        sts.data_binding_update_version ();
        st.refetch ();
      }
    }

    bool more (r != select_statement::no_data);

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::load (c, more, fs);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::tests_traits::
  erase (statements_type& sts)
  {
    using namespace pgsql;

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::erase (fs);
  }

  // builds
  //

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  select_name[] = "select_brep_build_package_builds";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  insert_name[] = "insert_brep_build_package_builds";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  delete_name[] = "delete_brep_build_package_builds";

  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  insert_types[] =
  {
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::int8_oid,
    pgsql::text_oid,
    pgsql::text_oid
  };

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  select_statement[] =
  "SELECT "
  "\"build_package_builds\".\"index\", "
  "\"build_package_builds\".\"expression\", "
  "\"build_package_builds\".\"comment\" "
  "FROM \"build_package_builds\" "
  "WHERE \"build_package_builds\".\"tenant\"=$1 AND \"build_package_builds\".\"name\"=$2::CITEXT AND \"build_package_builds\".\"version_epoch\"=$3 AND \"build_package_builds\".\"version_canonical_upstream\"=$4 AND \"build_package_builds\".\"version_canonical_release\"=$5 AND \"build_package_builds\".\"version_revision\"=$6 ORDER BY \"build_package_builds\".\"index\"";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  insert_statement[] =
  "INSERT INTO \"build_package_builds\" "
  "(\"tenant\", "
  "\"name\", "
  "\"version_epoch\", "
  "\"version_canonical_upstream\", "
  "\"version_canonical_release\", "
  "\"version_revision\", "
  "\"index\", "
  "\"expression\", "
  "\"comment\") "
  "VALUES "
  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9)";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  delete_statement[] =
  "DELETE FROM \"build_package_builds\" "
  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  bind (pgsql::bind* b,
        const pgsql::bind* id,
        std::size_t id_size,
        data_image_type& d)
  {
    using namespace pgsql;

    statement_kind sk (statement_select);
    ODB_POTENTIALLY_UNUSED (sk);

    size_t n (0);

    // object_id
    //
    if (id != 0)
      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
    n += id_size;

    // index
    //
    b[n].type = pgsql::bind::bigint;
    b[n].buffer = &d.index_value;
    b[n].is_null = &d.index_null;
    n++;

    // value
    //
    composite_value_traits< value_type, id_pgsql >::bind (
      b + n, d.value_value, sk);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  grow (data_image_type& i,
        bool* t)
  {
    bool grew (false);

    // index
    //
    t[0UL] = 0;

    // value
    //
    if (composite_value_traits< value_type, id_pgsql >::grow (
          i.value_value, t + 1UL))
      grew = true;

    if (grew)
      i.version++;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  init (data_image_type& i,
        index_type* j,
        const value_type& v)
  {
    using namespace pgsql;

    statement_kind sk (statement_insert);
    ODB_POTENTIALLY_UNUSED (sk);

    bool grew (false);

    // index
    //
    if (j != 0)
    {
      bool is_null (false);
      pgsql::value_traits<
          index_type,
          pgsql::id_bigint >::set_image (
        i.index_value, is_null, *j);
      i.index_null = is_null;
    }

    // value
    //
    {
      if (composite_value_traits< value_type, id_pgsql >::init (
            i.value_value,
            v,
            sk))
        grew = true;
    }

    if (grew)
      i.version++;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  init (index_type& j,
        value_type& v,
        const data_image_type& i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (db);

    // index
    //
    {
      pgsql::value_traits<
          index_type,
          pgsql::id_bigint >::set_value (
        j,
        i.index_value,
        i.index_null);
    }

    // value
    //
    {
      composite_value_traits< value_type, id_pgsql >::init (
        v,
        i.value_value,
        db);
    }
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  insert (index_type i, const value_type& v, void* d)
  {
    using namespace pgsql;

    statements_type& sts (*static_cast< statements_type* > (d));
    data_image_type& di (sts.data_image ());

    init (di, &i, v);

    if (sts.data_binding_test_version ())
    {
      const binding& id (sts.id_binding ());
      bind (sts.data_bind (), id.bind, id.count, di);
      sts.data_binding_update_version ();
    }

    if (!sts.insert_statement ().execute ())
      throw object_already_persistent ();
  }

  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  select (index_type& i, value_type& v, void* d)
  {
    using namespace pgsql;
    using pgsql::select_statement;

    statements_type& sts (*static_cast< statements_type* > (d));
    data_image_type& di (sts.data_image ());

    init (i, v, di, &sts.connection ().database ());

    select_statement& st (sts.select_statement ());
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      grow (di, sts.select_image_truncated ());

      if (sts.data_binding_test_version ())
      {
        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
        sts.data_binding_update_version ();
        st.refetch ();
      }
    }

    return r != select_statement::no_data;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  delete_ (void* d)
  {
    using namespace pgsql;

    statements_type& sts (*static_cast< statements_type* > (d));
    sts.delete_statement ().execute ();
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  persist (const container_type& c,
           statements_type& sts)
  {
    using namespace pgsql;

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::persist (c, fs);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  load (container_type& c,
        statements_type& sts)
  {
    using namespace pgsql;
    using pgsql::select_statement;

    const binding& id (sts.id_binding ());

    if (sts.data_binding_test_version ())
    {
      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
      sts.data_binding_update_version ();
    }

    select_statement& st (sts.select_statement ());
    st.execute ();
    auto_result ar (st);
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      data_image_type& di (sts.data_image ());
      grow (di, sts.select_image_truncated ());

      if (sts.data_binding_test_version ())
      {
        bind (sts.data_bind (), 0, id.count, di);
        sts.data_binding_update_version ();
        st.refetch ();
      }
    }

    bool more (r != select_statement::no_data);

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::load (c, more, fs);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::builds_traits::
  erase (statements_type& sts)
  {
    using namespace pgsql;

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::erase (fs);
  }

  // constraints
  //

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  select_name[] = "select_brep_build_package_constraints";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  insert_name[] = "insert_brep_build_package_constraints";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  delete_name[] = "delete_brep_build_package_constraints";

  const unsigned int access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  insert_types[] =
  {
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::int4_oid,
    pgsql::int8_oid,
    pgsql::bool_oid,
    pgsql::text_oid,
    pgsql::text_oid,
    pgsql::text_oid
  };

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  select_statement[] =
  "SELECT "
  "\"build_package_constraints\".\"index\", "
  "\"build_package_constraints\".\"exclusion\", "
  "\"build_package_constraints\".\"config\", "
  "\"build_package_constraints\".\"target\", "
  "\"build_package_constraints\".\"comment\" "
  "FROM \"build_package_constraints\" "
  "WHERE \"build_package_constraints\".\"tenant\"=$1 AND \"build_package_constraints\".\"name\"=$2::CITEXT AND \"build_package_constraints\".\"version_epoch\"=$3 AND \"build_package_constraints\".\"version_canonical_upstream\"=$4 AND \"build_package_constraints\".\"version_canonical_release\"=$5 AND \"build_package_constraints\".\"version_revision\"=$6 ORDER BY \"build_package_constraints\".\"index\"";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  insert_statement[] =
  "INSERT INTO \"build_package_constraints\" "
  "(\"tenant\", "
  "\"name\", "
  "\"version_epoch\", "
  "\"version_canonical_upstream\", "
  "\"version_canonical_release\", "
  "\"version_revision\", "
  "\"index\", "
  "\"exclusion\", "
  "\"config\", "
  "\"target\", "
  "\"comment\") "
  "VALUES "
  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11)";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  delete_statement[] =
  "DELETE FROM \"build_package_constraints\" "
  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  bind (pgsql::bind* b,
        const pgsql::bind* id,
        std::size_t id_size,
        data_image_type& d)
  {
    using namespace pgsql;

    statement_kind sk (statement_select);
    ODB_POTENTIALLY_UNUSED (sk);

    size_t n (0);

    // object_id
    //
    if (id != 0)
      std::memcpy (&b[n], id, id_size * sizeof (id[0]));
    n += id_size;

    // index
    //
    b[n].type = pgsql::bind::bigint;
    b[n].buffer = &d.index_value;
    b[n].is_null = &d.index_null;
    n++;

    // value
    //
    composite_value_traits< value_type, id_pgsql >::bind (
      b + n, d.value_value, sk);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  grow (data_image_type& i,
        bool* t)
  {
    bool grew (false);

    // index
    //
    t[0UL] = 0;

    // value
    //
    if (composite_value_traits< value_type, id_pgsql >::grow (
          i.value_value, t + 1UL))
      grew = true;

    if (grew)
      i.version++;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  init (data_image_type& i,
        index_type* j,
        const value_type& v)
  {
    using namespace pgsql;

    statement_kind sk (statement_insert);
    ODB_POTENTIALLY_UNUSED (sk);

    bool grew (false);

    // index
    //
    if (j != 0)
    {
      bool is_null (false);
      pgsql::value_traits<
          index_type,
          pgsql::id_bigint >::set_image (
        i.index_value, is_null, *j);
      i.index_null = is_null;
    }

    // value
    //
    {
      if (composite_value_traits< value_type, id_pgsql >::init (
            i.value_value,
            v,
            sk))
        grew = true;
    }

    if (grew)
      i.version++;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  init (index_type& j,
        value_type& v,
        const data_image_type& i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (db);

    // index
    //
    {
      pgsql::value_traits<
          index_type,
          pgsql::id_bigint >::set_value (
        j,
        i.index_value,
        i.index_null);
    }

    // value
    //
    {
      composite_value_traits< value_type, id_pgsql >::init (
        v,
        i.value_value,
        db);
    }
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  insert (index_type i, const value_type& v, void* d)
  {
    using namespace pgsql;

    statements_type& sts (*static_cast< statements_type* > (d));
    data_image_type& di (sts.data_image ());

    init (di, &i, v);

    if (sts.data_binding_test_version ())
    {
      const binding& id (sts.id_binding ());
      bind (sts.data_bind (), id.bind, id.count, di);
      sts.data_binding_update_version ();
    }

    if (!sts.insert_statement ().execute ())
      throw object_already_persistent ();
  }

  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  select (index_type& i, value_type& v, void* d)
  {
    using namespace pgsql;
    using pgsql::select_statement;

    statements_type& sts (*static_cast< statements_type* > (d));
    data_image_type& di (sts.data_image ());

    init (i, v, di, &sts.connection ().database ());

    select_statement& st (sts.select_statement ());
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      grow (di, sts.select_image_truncated ());

      if (sts.data_binding_test_version ())
      {
        bind (sts.data_bind (), 0, sts.id_binding ().count, di);
        sts.data_binding_update_version ();
        st.refetch ();
      }
    }

    return r != select_statement::no_data;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  delete_ (void* d)
  {
    using namespace pgsql;

    statements_type& sts (*static_cast< statements_type* > (d));
    sts.delete_statement ().execute ();
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  persist (const container_type& c,
           statements_type& sts)
  {
    using namespace pgsql;

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::persist (c, fs);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  load (container_type& c,
        statements_type& sts)
  {
    using namespace pgsql;
    using pgsql::select_statement;

    const binding& id (sts.id_binding ());

    if (sts.data_binding_test_version ())
    {
      bind (sts.data_bind (), id.bind, id.count, sts.data_image ());
      sts.data_binding_update_version ();
    }

    select_statement& st (sts.select_statement ());
    st.execute ();
    auto_result ar (st);
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      data_image_type& di (sts.data_image ());
      grow (di, sts.select_image_truncated ());

      if (sts.data_binding_test_version ())
      {
        bind (sts.data_bind (), 0, id.count, di);
        sts.data_binding_update_version ();
        st.refetch ();
      }
    }

    bool more (r != select_statement::no_data);

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::load (c, more, fs);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::constraints_traits::
  erase (statements_type& sts)
  {
    using namespace pgsql;

    functions_type& fs (sts.functions ());
    fs.ordered_ = true;
    container_traits_type::erase (fs);
  }

  access::object_traits_impl< ::brep::build_package, id_pgsql >::id_type
  access::object_traits_impl< ::brep::build_package, id_pgsql >::
  id (const image_type& i)
  {
    pgsql::database* db (0);
    ODB_POTENTIALLY_UNUSED (db);

    id_type id;
    {
      composite_value_traits< ::brep::package_id, id_pgsql >::init (
        id,
        i.id_value,
        db);
    }

    return id;
  }

  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
  grow (image_type& i,
        bool* t)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (t);

    bool grew (false);

    // id
    //
    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
          i.id_value, t + 0UL))
      grew = true;

    // version
    //
    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
          i.version_value, t + 6UL))
      grew = true;

    // internal_repository
    //
    if (composite_value_traits< ::brep::repository_id, id_pgsql >::grow (
          i.internal_repository_value, t + 8UL))
      grew = true;

    // buildable
    //
    t[10UL] = 0;

    return grew;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
  bind (pgsql::bind* b,
        image_type& i,
        pgsql::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace pgsql;

    assert (sk != statement_update);

    std::size_t n (0);

    // id
    //
    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
      b + n, i.id_value, sk);
    n += 6UL;

    // version
    //
    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
      b + n, i.version_value, sk);
    n += 2UL;

    // internal_repository
    //
    composite_value_traits< ::brep::repository_id, id_pgsql >::bind (
      b + n, i.internal_repository_value, sk);
    n += 2UL;

    // buildable
    //
    b[n].type = pgsql::bind::boolean_;
    b[n].buffer = &i.buildable_value;
    b[n].is_null = &i.buildable_null;
    n++;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
  bind (pgsql::bind* b, id_image_type& i)
  {
    std::size_t n (0);
    pgsql::statement_kind sk (pgsql::statement_select);
    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
      b + n, i.id_value, sk);
  }

  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
  init (image_type& i,
        const object_type& o,
        pgsql::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace pgsql;

    assert (sk != statement_update);

    bool grew (false);

    // id
    //
    {
      ::brep::package_id const& v =
        o.id;

      if (composite_value_traits< ::brep::package_id, id_pgsql >::init (
            i.id_value,
            v,
            sk))
        grew = true;
    }

    // version
    //
    {
      ::brep::upstream_version const& v =
        o.version;

      if (composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
            i.version_value,
            v,
            sk))
        grew = true;
    }

    // internal_repository
    //
    {
      ::odb::lazy_shared_ptr< ::brep::build_repository > const& v =
        o.internal_repository;

      typedef object_traits< ::brep::build_repository > obj_traits;
      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::build_repository > > ptr_traits;

      bool is_null (ptr_traits::null_ptr (v));
      if (!is_null)
      {
        const obj_traits::id_type& ptr_id (
          ptr_traits::object_id< ptr_traits::element_type  > (v));

        if (composite_value_traits< obj_traits::id_type, id_pgsql >::init (
              i.internal_repository_value,
              ptr_id,
              sk))
          grew = true;
      }
      else
        composite_value_traits< obj_traits::id_type, id_pgsql >::set_null (i.internal_repository_value, sk);
    }

    // buildable
    //
    {
      bool const& v =
        o.buildable;

      bool is_null (false);
      pgsql::value_traits<
          bool,
          pgsql::id_boolean >::set_image (
        i.buildable_value, is_null, v);
      i.buildable_null = is_null;
    }

    return grew;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
  init (object_type& o,
        const image_type& i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (db);

    // id
    //
    {
      ::brep::package_id& v =
        o.id;

      composite_value_traits< ::brep::package_id, id_pgsql >::init (
        v,
        i.id_value,
        db);
    }

    // version
    //
    {
      // From build-package.hxx:117:32
      ::brep::upstream_version v;

      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
        v,
        i.version_value,
        db);

      // From build-package.hxx:117:32
      o.version.init (o.id.version, (v));
    }

    // internal_repository
    //
    {
      ::odb::lazy_shared_ptr< ::brep::build_repository >& v =
        o.internal_repository;

      typedef object_traits< ::brep::build_repository > obj_traits;
      typedef odb::pointer_traits< ::odb::lazy_shared_ptr< ::brep::build_repository > > ptr_traits;

      if (composite_value_traits< obj_traits::id_type, id_pgsql >::get_null (
            i.internal_repository_value))
        v = ptr_traits::pointer_type ();
      else
      {
        obj_traits::id_type ptr_id;
        composite_value_traits< obj_traits::id_type, id_pgsql >::init (
          ptr_id,
          i.internal_repository_value,
          db);

        v = ptr_traits::pointer_type (
          *static_cast<pgsql::database*> (db), ptr_id);
      }
    }

    // buildable
    //
    {
      bool& v =
        o.buildable;

      pgsql::value_traits<
          bool,
          pgsql::id_boolean >::set_value (
        v,
        i.buildable_value,
        i.buildable_null);
    }
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
  init (id_image_type& i, const id_type& id)
  {
    bool grew (false);
    pgsql::statement_kind sk (pgsql::statement_select);
    {
      if (composite_value_traits< ::brep::package_id, id_pgsql >::init (
            i.id_value,
            id,
            sk))
        grew = true;
    }

    if (grew)
      i.version++;
  }

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::persist_statement[] =
  "INSERT INTO \"build_package\" "
  "(\"tenant\", "
  "\"name\", "
  "\"version_epoch\", "
  "\"version_canonical_upstream\", "
  "\"version_canonical_release\", "
  "\"version_revision\", "
  "\"version_upstream\", "
  "\"version_release\", "
  "\"internal_repository_tenant\", "
  "\"internal_repository_canonical_name\", "
  "\"buildable\") "
  "VALUES "
  "($1, $2::CITEXT, $3, $4, $5, $6, $7, $8, $9, $10, $11)";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::find_statement[] =
  "SELECT "
  "\"build_package\".\"tenant\", "
  "\"build_package\".\"name\"::TEXT, "
  "\"build_package\".\"version_epoch\", "
  "\"build_package\".\"version_canonical_upstream\", "
  "\"build_package\".\"version_canonical_release\", "
  "\"build_package\".\"version_revision\", "
  "\"build_package\".\"version_upstream\", "
  "\"build_package\".\"version_release\", "
  "\"build_package\".\"internal_repository_tenant\", "
  "\"build_package\".\"internal_repository_canonical_name\", "
  "\"build_package\".\"buildable\" "
  "FROM \"build_package\" "
  "WHERE \"build_package\".\"tenant\"=$1 AND \"build_package\".\"name\"=$2::CITEXT AND \"build_package\".\"version_epoch\"=$3 AND \"build_package\".\"version_canonical_upstream\"=$4 AND \"build_package\".\"version_canonical_release\"=$5 AND \"build_package\".\"version_revision\"=$6";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::erase_statement[] =
  "DELETE FROM \"build_package\" "
  "WHERE \"tenant\"=$1 AND \"name\"=$2::CITEXT AND \"version_epoch\"=$3 AND \"version_canonical_upstream\"=$4 AND \"version_canonical_release\"=$5 AND \"version_revision\"=$6";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::query_statement[] =
  "SELECT\n"
  "\"build_package\".\"tenant\",\n"
  "\"build_package\".\"name\"::TEXT,\n"
  "\"build_package\".\"version_epoch\",\n"
  "\"build_package\".\"version_canonical_upstream\",\n"
  "\"build_package\".\"version_canonical_release\",\n"
  "\"build_package\".\"version_revision\",\n"
  "\"build_package\".\"version_upstream\",\n"
  "\"build_package\".\"version_release\",\n"
  "\"build_package\".\"internal_repository_tenant\",\n"
  "\"build_package\".\"internal_repository_canonical_name\",\n"
  "\"build_package\".\"buildable\"\n"
  "FROM \"build_package\"\n"
  "LEFT JOIN \"build_repository\" AS \"internal_repository\" ON \"internal_repository\".\"tenant\"=\"build_package\".\"internal_repository_tenant\" AND \"internal_repository\".\"canonical_name\"=\"build_package\".\"internal_repository_canonical_name\"";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::erase_query_statement[] =
  "DELETE FROM \"build_package\"";

  const char access::object_traits_impl< ::brep::build_package, id_pgsql >::table_name[] =
  "\"build_package\"";

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
  persist (database& db, const object_type& obj)
  {
    ODB_POTENTIALLY_UNUSED (db);

    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    callback (db,
              obj,
              callback_event::pre_persist);

    image_type& im (sts.image ());
    binding& imb (sts.insert_image_binding ());

    if (init (im, obj, statement_insert))
      im.version++;

    if (im.version != sts.insert_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_insert);
      sts.insert_image_version (im.version);
      imb.version++;
    }

    insert_statement& st (sts.persist_statement ());
    if (!st.execute ())
      throw object_already_persistent ();

    id_image_type& i (sts.id_image ());
    init (i, id (obj));

    binding& idb (sts.id_image_binding ());
    if (i.version != sts.id_image_version () || idb.version == 0)
    {
      bind (idb.bind, i);
      sts.id_image_version (i.version);
      idb.version++;
    }

    extra_statement_cache_type& esc (sts.extra_statement_cache ());

    // tests
    //
    {
      ::butl::small_vector< ::brep::build_test_dependency, 1 > const& v =
        obj.tests;

      tests_traits::persist (
        v,
        esc.tests);
    }

    // builds
    //
    {
      ::brep::build_class_exprs const& v =
        obj.builds;

      builds_traits::persist (
        v,
        esc.builds);
    }

    // constraints
    //
    {
      ::brep::build_constraints const& v =
        obj.constraints;

      constraints_traits::persist (
        v,
        esc.constraints);
    }

    callback (db,
              obj,
              callback_event::post_persist);
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
  erase (database& db, const id_type& id)
  {
    using namespace pgsql;

    ODB_POTENTIALLY_UNUSED (db);

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    id_image_type& i (sts.id_image ());
    init (i, id);

    binding& idb (sts.id_image_binding ());
    if (i.version != sts.id_image_version () || idb.version == 0)
    {
      bind (idb.bind, i);
      sts.id_image_version (i.version);
      idb.version++;
    }

    extra_statement_cache_type& esc (sts.extra_statement_cache ());

    // tests
    //
    {
      tests_traits::erase (
        esc.tests);
    }

    // builds
    //
    {
      builds_traits::erase (
        esc.builds);
    }

    // constraints
    //
    {
      constraints_traits::erase (
        esc.constraints);
    }

    if (sts.erase_statement ().execute () != 1)
      throw object_not_persistent ();

    pointer_cache_traits::erase (db, id);
  }

  access::object_traits_impl< ::brep::build_package, id_pgsql >::pointer_type
  access::object_traits_impl< ::brep::build_package, id_pgsql >::
  find (database& db, const id_type& id)
  {
    using namespace pgsql;

    {
      pointer_type p (pointer_cache_traits::find (db, id));

      if (!pointer_traits::null_ptr (p))
        return p;
    }

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);

    if (l.locked ())
    {
      if (!find_ (sts, &id))
        return pointer_type ();
    }

    pointer_type p (
      access::object_factory<object_type, pointer_type>::create ());
    pointer_traits::guard pg (p);

    pointer_cache_traits::insert_guard ig (
      pointer_cache_traits::insert (db, id, p));

    object_type& obj (pointer_traits::get_ref (p));

    if (l.locked ())
    {
      select_statement& st (sts.find_statement ());
      ODB_POTENTIALLY_UNUSED (st);

      callback (db, obj, callback_event::pre_load);
      init (obj, sts.image (), &db);
      load_ (sts, obj, false);
      sts.load_delayed (0);
      l.unlock ();
      callback (db, obj, callback_event::post_load);
      pointer_cache_traits::load (ig.position ());
    }
    else
      sts.delay_load (id, obj, ig.position ());

    ig.release ();
    pg.release ();
    return p;
  }

  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
  find (database& db, const id_type& id, object_type& obj)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);
    assert (l.locked ()) /* Must be a top-level call. */;

    if (!find_ (sts, &id))
      return false;

    select_statement& st (sts.find_statement ());
    ODB_POTENTIALLY_UNUSED (st);

    reference_cache_traits::position_type pos (
      reference_cache_traits::insert (db, id, obj));
    reference_cache_traits::insert_guard ig (pos);

    callback (db, obj, callback_event::pre_load);
    init (obj, sts.image (), &db);
    load_ (sts, obj, false);
    sts.load_delayed (0);
    l.unlock ();
    callback (db, obj, callback_event::post_load);
    reference_cache_traits::load (pos);
    ig.release ();
    return true;
  }

  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
  reload (database& db, object_type& obj)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    statements_type::auto_lock l (sts);
    assert (l.locked ()) /* Must be a top-level call. */;

    const id_type& id (object_traits_impl::id (obj));
    if (!find_ (sts, &id))
      return false;

    select_statement& st (sts.find_statement ());
    ODB_POTENTIALLY_UNUSED (st);

    callback (db, obj, callback_event::pre_load);
    init (obj, sts.image (), &db);
    load_ (sts, obj, true);
    sts.load_delayed (0);
    l.unlock ();
    callback (db, obj, callback_event::post_load);
    return true;
  }

  bool access::object_traits_impl< ::brep::build_package, id_pgsql >::
  find_ (statements_type& sts,
         const id_type* id)
  {
    using namespace pgsql;

    id_image_type& i (sts.id_image ());
    init (i, *id);

    binding& idb (sts.id_image_binding ());
    if (i.version != sts.id_image_version () || idb.version == 0)
    {
      bind (idb.bind, i);
      sts.id_image_version (i.version);
      idb.version++;
    }

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    select_statement& st (sts.find_statement ());

    st.execute ();
    auto_result ar (st);
    select_statement::result r (st.fetch ());

    if (r == select_statement::truncated)
    {
      if (grow (im, sts.select_image_truncated ()))
        im.version++;

      if (im.version != sts.select_image_version ())
      {
        bind (imb.bind, im, statement_select);
        sts.select_image_version (im.version);
        imb.version++;
        st.refetch ();
      }
    }

    return r != select_statement::no_data;
  }

  void access::object_traits_impl< ::brep::build_package, id_pgsql >::
  load_ (statements_type& sts,
         object_type& obj,
         bool reload)
  {
    ODB_POTENTIALLY_UNUSED (reload);

    extra_statement_cache_type& esc (sts.extra_statement_cache ());

    // tests
    //
    {
      ::butl::small_vector< ::brep::build_test_dependency, 1 >& v =
        obj.tests;

      tests_traits::load (
        v,
        esc.tests);
    }

    // builds
    //
    {
      ::brep::build_class_exprs& v =
        obj.builds;

      builds_traits::load (
        v,
        esc.builds);
    }

    // constraints
    //
    {
      ::brep::build_constraints& v =
        obj.constraints;

      constraints_traits::load (
        v,
        esc.constraints);
    }
  }

  result< access::object_traits_impl< ::brep::build_package, id_pgsql >::object_type >
  access::object_traits_impl< ::brep::build_package, id_pgsql >::
  query (database&, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    std::string text (query_statement);
    if (!q.empty ())
    {
      text += "\n";
      text += q.clause ();
    }

    q.init_parameters ();
    shared_ptr<select_statement> st (
      new (shared) select_statement (
        sts.connection (),
        query_statement_name,
        text,
        true,
        true,
        q.parameter_types (),
        q.parameter_count (),
        q.parameters_binding (),
        imb));

    st->execute ();
    st->deallocate ();

    shared_ptr< odb::object_result_impl<object_type> > r (
      new (shared) pgsql::object_result_impl<object_type> (
        q, st, sts, 0));

    return result<object_type> (r);
  }

  unsigned long long access::object_traits_impl< ::brep::build_package, id_pgsql >::
  erase_query (database&, const query_base_type& q)
  {
    using namespace pgsql;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    std::string text (erase_query_statement);
    if (!q.empty ())
    {
      text += ' ';
      text += q.clause ();
    }

    q.init_parameters ();
    delete_statement st (
      conn,
      erase_query_statement_name,
      text,
      q.parameter_types (),
      q.parameter_count (),
      q.parameters_binding ());

    return st.execute ();
  }

  odb::details::shared_ptr<prepared_query_impl>
  access::object_traits_impl< ::brep::build_package, id_pgsql >::
  prepare_query (connection& c, const char* n, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      static_cast<pgsql::connection&> (c));

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    std::string text (query_statement);
    if (!q.empty ())
    {
      text += "\n";
      text += q.clause ();
    }

    shared_ptr<pgsql::prepared_query_impl> r (
      new (shared) pgsql::prepared_query_impl (conn));
    r->name = n;
    r->execute = &execute_query;
    r->query = q;
    r->stmt.reset (
      new (shared) select_statement (
        sts.connection (),
        n,
        text,
        true,
        true,
        r->query.parameter_types (),
        r->query.parameter_count (),
        r->query.parameters_binding (),
        imb));

    return r;
  }

  odb::details::shared_ptr<result_impl>
  access::object_traits_impl< ::brep::build_package, id_pgsql >::
  execute_query (prepared_query_impl& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::prepared_query_impl& pq (
      static_cast<pgsql::prepared_query_impl&> (q));
    shared_ptr<select_statement> st (
      odb::details::inc_ref (
        static_cast<select_statement*> (pq.stmt.get ())));

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    // The connection used by the current transaction and the
    // one used to prepare this statement must be the same.
    //
    assert (&conn == &st->connection ());

    statements_type& sts (
      conn.statement_cache ().find_object<object_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.select_image_binding ());

    if (im.version != sts.select_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_select);
      sts.select_image_version (im.version);
      imb.version++;
    }

    pq.query.init_parameters ();
    st->execute ();

    return shared_ptr<result_impl> (
      new (shared) pgsql::object_result_impl<object_type> (
        pq.query, st, sts, 0));
  }

  // buildable_package
  //

  const char access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
  query_statement_name[] = "query_brep_buildable_package";

  bool access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
  grow (image_type& i,
        bool* t)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (t);

    bool grew (false);

    // id
    //
    if (composite_value_traits< ::brep::package_id, id_pgsql >::grow (
          i.id_value, t + 0UL))
      grew = true;

    // version
    //
    if (composite_value_traits< ::brep::upstream_version, id_pgsql >::grow (
          i.version_value, t + 6UL))
      grew = true;

    // archived
    //
    t[8UL] = 0;

    return grew;
  }

  void access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
  bind (pgsql::bind* b,
        image_type& i)
  {
    using namespace pgsql;

    pgsql::statement_kind sk (statement_select);
    ODB_POTENTIALLY_UNUSED (sk);

    std::size_t n (0);

    // id
    //
    composite_value_traits< ::brep::package_id, id_pgsql >::bind (
      b + n, i.id_value, sk);
    n += 6UL;

    // version
    //
    composite_value_traits< ::brep::upstream_version, id_pgsql >::bind (
      b + n, i.version_value, sk);
    n += 2UL;

    // archived
    //
    b[n].type = pgsql::bind::boolean_;
    b[n].buffer = &i.archived_value;
    b[n].is_null = &i.archived_null;
    n++;
  }

  void access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
  init (view_type& o,
        const image_type& i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (db);

    // id
    //
    {
      ::brep::package_id& v =
        o.id;

      composite_value_traits< ::brep::package_id, id_pgsql >::init (
        v,
        i.id_value,
        db);
    }

    // version
    //
    {
      // From build-package.hxx:148:32
      ::brep::upstream_version v;

      composite_value_traits< ::brep::upstream_version, id_pgsql >::init (
        v,
        i.version_value,
        db);

      // From build-package.hxx:148:32
      o.version.init (o.id.version, (v));
    }

    // archived
    //
    {
      bool& v =
        o.archived;

      pgsql::value_traits<
          bool,
          pgsql::id_boolean >::set_value (
        v,
        i.archived_value,
        i.archived_null);
    }
  }

  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::query_base_type
  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
  query_statement (const query_base_type& q)
  {
    query_base_type r (
      "SELECT "
      "\"build_package\".\"tenant\", "
      "\"build_package\".\"name\"::TEXT, "
      "\"build_package\".\"version_epoch\", "
      "\"build_package\".\"version_canonical_upstream\", "
      "\"build_package\".\"version_canonical_release\", "
      "\"build_package\".\"version_revision\", "
      "\"build_package\".\"version_upstream\", "
      "\"build_package\".\"version_release\", "
      "\"build_tenant\".\"archived\" ");

    r += "FROM \"build_package\"";

    r += " INNER JOIN \"build_repository\" ON";
    // From build-package.hxx:134:5
    r += query_columns::build_package::buildable && brep::operator == (query_columns::build_package::internal_repository, query_columns::build_repository::id);

    r += " LEFT JOIN \"build_tenant\" ON";
    // From build-package.hxx:138:5
    r += query_columns::build_package::id.tenant == query_columns::build_tenant::id;

    if (!q.empty ())
    {
      r += " ";
      r += q.clause_prefix ();
      r += q;
    }

    return r;
  }

  result< access::view_traits_impl< ::brep::buildable_package, id_pgsql >::view_type >
  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
  query (database&, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_view<view_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.image_binding ());

    if (im.version != sts.image_version () || imb.version == 0)
    {
      bind (imb.bind, im);
      sts.image_version (im.version);
      imb.version++;
    }

    const query_base_type& qs (query_statement (q));
    qs.init_parameters ();
    shared_ptr<select_statement> st (
      new (shared) select_statement (
        sts.connection (),
        query_statement_name,
        qs.clause (),
        false,
        true,
        qs.parameter_types (),
        qs.parameter_count (),
        qs.parameters_binding (),
        imb));

    st->execute ();
    st->deallocate ();

    shared_ptr< odb::view_result_impl<view_type> > r (
      new (shared) pgsql::view_result_impl<view_type> (
        qs, st, sts, 0));

    return result<view_type> (r);
  }

  odb::details::shared_ptr<prepared_query_impl>
  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
  prepare_query (connection& c, const char* n, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      static_cast<pgsql::connection&> (c));
    statements_type& sts (
      conn.statement_cache ().find_view<view_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.image_binding ());

    if (im.version != sts.image_version () || imb.version == 0)
    {
      bind (imb.bind, im);
      sts.image_version (im.version);
      imb.version++;
    }

    shared_ptr<pgsql::prepared_query_impl> r (
      new (shared) pgsql::prepared_query_impl (conn));
    r->name = n;
    r->execute = &execute_query;
    r->query = query_statement (q);
    r->stmt.reset (
      new (shared) select_statement (
        sts.connection (),
        n,
        r->query.clause (),
        false,
        true,
        r->query.parameter_types (),
        r->query.parameter_count (),
        r->query.parameters_binding (),
        imb));

    return r;
  }

  odb::details::shared_ptr<result_impl>
  access::view_traits_impl< ::brep::buildable_package, id_pgsql >::
  execute_query (prepared_query_impl& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::prepared_query_impl& pq (
      static_cast<pgsql::prepared_query_impl&> (q));
    shared_ptr<select_statement> st (
      odb::details::inc_ref (
        static_cast<select_statement*> (pq.stmt.get ())));

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    // The connection used by the current transaction and the
    // one used to prepare this statement must be the same.
    //
    assert (&conn == &st->connection ());

    statements_type& sts (
      conn.statement_cache ().find_view<view_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.image_binding ());

    if (im.version != sts.image_version () || imb.version == 0)
    {
      bind (imb.bind, im);
      sts.image_version (im.version);
      imb.version++;
    }

    pq.query.init_parameters ();
    st->execute ();

    return shared_ptr<result_impl> (
      new (shared) pgsql::view_result_impl<view_type> (
        pq.query, st, sts, 0));
  }

  // buildable_package_count
  //

  const char access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
  query_statement_name[] = "query_brep_buildable_package_count";

  bool access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
  grow (image_type& i,
        bool* t)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (t);

    bool grew (false);

    // result
    //
    t[0UL] = 0;

    return grew;
  }

  void access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
  bind (pgsql::bind* b,
        image_type& i)
  {
    using namespace pgsql;

    pgsql::statement_kind sk (statement_select);
    ODB_POTENTIALLY_UNUSED (sk);

    std::size_t n (0);

    // result
    //
    b[n].type = pgsql::bind::bigint;
    b[n].buffer = &i.result_value;
    b[n].is_null = &i.result_null;
    n++;
  }

  void access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
  init (view_type& o,
        const image_type& i,
        database* db)
  {
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (db);

    // result
    //
    {
      ::std::size_t& v =
        o.result;

      pgsql::value_traits<
          ::std::size_t,
          pgsql::id_bigint >::set_value (
        v,
        i.result_value,
        i.result_null);
    }
  }

  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::query_base_type
  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
  query_statement (const query_base_type& q)
  {
    query_base_type r (
      "SELECT "
      "count(\"build_package\".\"name\") ");

    r += "FROM \"build_package\"";

    r += " INNER JOIN \"build_repository\" ON";
    // From build-package.hxx:153:5
    r += query_columns::build_package::buildable && brep::operator == (query_columns::build_package::internal_repository, query_columns::build_repository::id);

    r += " LEFT JOIN \"build_tenant\" ON";
    // From build-package.hxx:157:5
    r += query_columns::build_package::id.tenant == query_columns::build_tenant::id;

    if (!q.empty ())
    {
      r += " ";
      r += q.clause_prefix ();
      r += q;
    }

    return r;
  }

  result< access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::view_type >
  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
  query (database&, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());
    statements_type& sts (
      conn.statement_cache ().find_view<view_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.image_binding ());

    if (im.version != sts.image_version () || imb.version == 0)
    {
      bind (imb.bind, im);
      sts.image_version (im.version);
      imb.version++;
    }

    const query_base_type& qs (query_statement (q));
    qs.init_parameters ();
    shared_ptr<select_statement> st (
      new (shared) select_statement (
        sts.connection (),
        query_statement_name,
        qs.clause (),
        false,
        true,
        qs.parameter_types (),
        qs.parameter_count (),
        qs.parameters_binding (),
        imb));

    st->execute ();
    st->deallocate ();

    shared_ptr< odb::view_result_impl<view_type> > r (
      new (shared) pgsql::view_result_impl<view_type> (
        qs, st, sts, 0));

    return result<view_type> (r);
  }

  odb::details::shared_ptr<prepared_query_impl>
  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
  prepare_query (connection& c, const char* n, const query_base_type& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::connection& conn (
      static_cast<pgsql::connection&> (c));
    statements_type& sts (
      conn.statement_cache ().find_view<view_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.image_binding ());

    if (im.version != sts.image_version () || imb.version == 0)
    {
      bind (imb.bind, im);
      sts.image_version (im.version);
      imb.version++;
    }

    shared_ptr<pgsql::prepared_query_impl> r (
      new (shared) pgsql::prepared_query_impl (conn));
    r->name = n;
    r->execute = &execute_query;
    r->query = query_statement (q);
    r->stmt.reset (
      new (shared) select_statement (
        sts.connection (),
        n,
        r->query.clause (),
        false,
        true,
        r->query.parameter_types (),
        r->query.parameter_count (),
        r->query.parameters_binding (),
        imb));

    return r;
  }

  odb::details::shared_ptr<result_impl>
  access::view_traits_impl< ::brep::buildable_package_count, id_pgsql >::
  execute_query (prepared_query_impl& q)
  {
    using namespace pgsql;
    using odb::details::shared;
    using odb::details::shared_ptr;

    pgsql::prepared_query_impl& pq (
      static_cast<pgsql::prepared_query_impl&> (q));
    shared_ptr<select_statement> st (
      odb::details::inc_ref (
        static_cast<select_statement*> (pq.stmt.get ())));

    pgsql::connection& conn (
      pgsql::transaction::current ().connection ());

    // The connection used by the current transaction and the
    // one used to prepare this statement must be the same.
    //
    assert (&conn == &st->connection ());

    statements_type& sts (
      conn.statement_cache ().find_view<view_type> ());

    image_type& im (sts.image ());
    binding& imb (sts.image_binding ());

    if (im.version != sts.image_version () || imb.version == 0)
    {
      bind (imb.bind, im);
      sts.image_version (im.version);
      imb.version++;
    }

    pq.query.init_parameters ();
    st->execute ();

    return shared_ptr<result_impl> (
      new (shared) pgsql::view_result_impl<view_type> (
        pq.query, st, sts, 0));
  }
}

#include <odb/post.hxx>