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

#include <odb/pre.hxx>

#include "person-odb.hxx"

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


#include <odb/oracle/traits.hxx>
#include <odb/oracle/database.hxx>
#include <odb/oracle/transaction.hxx>
#include <odb/oracle/connection.hxx>
#include <odb/oracle/statement.hxx>
#include <odb/oracle/statement-cache.hxx>
#include <odb/oracle/simple-object-statements.hxx>
#include <odb/oracle/container-statements.hxx>
#include <odb/oracle/exceptions.hxx>

namespace odb
{
  // person
  //

  struct access::object_traits_impl< ::person, id_oracle >::extra_statement_cache_type
  {
    extra_statement_cache_type (
      oracle::connection&,
      image_type&,
      oracle::binding&,
      oracle::binding&)
    {
    }
  };

  access::object_traits_impl< ::person, id_oracle >::id_type
  access::object_traits_impl< ::person, id_oracle >::
  id (const id_image_type& i)
  {
    oracle::database* db (0);
    ODB_POTENTIALLY_UNUSED (db);

    id_type id;
    {
      oracle::value_traits<
          long unsigned int,
          oracle::id_big_int >::set_value (
        id,
        i.id_value,
        i.id_size,
        i.id_indicator == -1);
    }

    return id;
  }

  void access::object_traits_impl< ::person, id_oracle >::
  bind (oracle::bind* b,
        image_type& i,
        oracle::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace oracle;

    std::size_t n (0);

    // id
    //
    if (sk != statement_insert && sk != statement_update)
    {
      b[n].type = oracle::bind::number;
      b[n].buffer = i.id_value;
      b[n].capacity = static_cast<ub4> (sizeof (i.id_value));
      b[n].size = &i.id_size;
      b[n].indicator = &i.id_indicator;
      n++;
    }

    // num
    //
    b[n].type = oracle::bind::uinteger;
    b[n].buffer = &i.num_value;
    b[n].capacity = 4;
    b[n].size = 0;
    b[n].indicator = &i.num_indicator;
    n++;

    // str
    //
    b[n].type = oracle::bind::clob;
    b[n].buffer = &i.str_lob;
    b[n].indicator = &i.str_indicator;
    b[n].callback = &i.str_callback;

    n++;
  }

  void access::object_traits_impl< ::person, id_oracle >::
  bind (oracle::bind* b, id_image_type& i)
  {
    std::size_t n (0);
    b[n].type = oracle::bind::number;
    b[n].buffer = i.id_value;
    b[n].capacity = static_cast<ub4> (sizeof (i.id_value));
    b[n].size = &i.id_size;
    b[n].indicator = &i.id_indicator;
  }

  void access::object_traits_impl< ::person, id_oracle >::
  init (image_type& i,
        const object_type& o,
        oracle::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace oracle;

    // num
    //
    {
      unsigned int const& v =
        o.num;

      bool is_null (false);
      oracle::value_traits<
          unsigned int,
          oracle::id_int32 >::set_image (
        i.num_value, is_null, v);
      i.num_indicator = is_null ? -1 : 0;
    }

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

      bool is_null (false);
      i.str_lob.position = 0;
      oracle::value_traits<
          ::std::string,
          oracle::id_clob >::set_image (
        i.str_callback.callback.param,
        i.str_callback.context.param,
        is_null,
        v);
      i.str_indicator = is_null ? -1 : 0;
    }
  }

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

    // id
    //
    {
      long unsigned int& v =
        o.id;

      oracle::value_traits<
          long unsigned int,
          oracle::id_big_int >::set_value (
        v,
        i.id_value,
        i.id_size,
        i.id_indicator == -1);
    }

    // num
    //
    {
      unsigned int& v =
        o.num;

      oracle::value_traits<
          unsigned int,
          oracle::id_int32 >::set_value (
        v,
        i.num_value,
        i.num_indicator == -1);
    }

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

      oracle::value_traits<
          ::std::string,
          oracle::id_clob >::set_value (
        v,
        i.str_callback.callback.result,
        i.str_callback.context.result,
        i.str_indicator == -1);
    }
  }

  void access::object_traits_impl< ::person, id_oracle >::
  init (id_image_type& i, const id_type& id)
  {
    {
      bool is_null (false);
      std::size_t size (0);
      oracle::value_traits<
          long unsigned int,
          oracle::id_big_int >::set_image (
        i.id_value,
        size,
        is_null,
        id);
      i.id_indicator = is_null ? -1 : 0;
      i.id_size = static_cast<ub2> (size);
    }
  }

  const char access::object_traits_impl< ::person, id_oracle >::persist_statement[] =
  "INSERT INTO \"person\" "
  "(\"id\", "
  "\"num\", "
  "\"str\") "
  "VALUES "
  "(\"person_seq\".nextval, :1, :2) "
  "RETURNING \"id\" INTO :3";

  const char access::object_traits_impl< ::person, id_oracle >::find_statement[] =
  "SELECT "
  "\"person\".\"id\", "
  "\"person\".\"num\", "
  "\"person\".\"str\" "
  "FROM \"person\" "
  "WHERE \"person\".\"id\"=:1";

  const char access::object_traits_impl< ::person, id_oracle >::update_statement[] =
  "UPDATE \"person\" "
  "SET "
  "\"num\"=:1, "
  "\"str\"=:2 "
  "WHERE \"id\"=:3";

  const char access::object_traits_impl< ::person, id_oracle >::erase_statement[] =
  "DELETE FROM \"person\" "
  "WHERE \"id\"=:1";

  void access::object_traits_impl< ::person, id_oracle >::
  persist (database& db, object_type** objs, std::size_t n,
           multiple_exceptions* mex)
  {
    ODB_POTENTIALLY_UNUSED (db);
    assert (n <= batch);

    using namespace oracle;

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

    for (std::size_t i (0); i != n; ++i)
    {
      object_type& obj (*objs[i]);

      callback (db,
                static_cast<const object_type&> (obj),
                callback_event::pre_persist);

      init (sts.image (i), obj, statement_insert);
    }

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

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

    // @@ TMP. Why tmp?
    bind (sts.id_image_binding ().bind, sts.id_image ());

    insert_statement& st (sts.persist_statement ());
    n = st.execute (n, mex); // Set to actual number of rows attempted.

    for (std::size_t i (0); i != n; ++i)
    {
      bool r (st.result (i)); // Sets current in mex.

      if (mex != 0)
      {
        if ((*mex)[i] != 0) // Pending exception.
          continue;

        if (!r)
        {
          mex->insert (i, object_already_persistent ());
          continue;
        }

        if (mex->fatal ()) // Don't do any extra work.
          continue;
      }
      else if (!r)
        throw object_already_persistent ();

      object_type& obj (*objs[i]);

      obj.id = id (sts.id_image (i));

      callback (db,
                static_cast<const object_type&> (obj),
                callback_event::post_persist);
    }
  }

  void access::object_traits_impl< ::person, id_oracle >::
  update (database& db, const object_type& obj)
  {
    ODB_POTENTIALLY_UNUSED (db);

    using namespace oracle;
    using oracle::update_statement;

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

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

    const id_type& id (
      obj.id);
    id_image_type& idi (sts.id_image ());
    init (idi, id);

    image_type& im (sts.image ());
    init (im, obj, statement_update);

    bool u (false);
    binding& imb (sts.update_image_binding ());
    if (im.version != sts.update_image_version () ||
        imb.version == 0)
    {
      bind (imb.bind, im, statement_update);
      sts.update_image_version (im.version);
      imb.version++;
      u = true;
    }

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

      sts.update_id_image_version (idi.version);

      if (!u)
        imb.version++;
    }

    update_statement& st (sts.update_statement ());
    if (st.execute () == 0)
      throw object_not_persistent ();

    callback (db, obj, callback_event::post_update);
    pointer_cache_traits::update (db, obj);
  }

  void access::object_traits_impl< ::person, id_oracle >::
  erase (database& db, const id_type& id)
  {
    using namespace oracle;

    ODB_POTENTIALLY_UNUSED (db);

    oracle::connection& conn (
      oracle::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< ::person, id_oracle >::pointer_type
  access::object_traits_impl< ::person, id_oracle >::
  find (database& db, const id_type& id)
  {
    using namespace oracle;

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

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

    oracle::connection& conn (
      oracle::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);
      st.stream_result ();
      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< ::person, id_oracle >::
  find (database& db, const id_type& id, object_type& obj)
  {
    using namespace oracle;

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

    statements_type::auto_lock l (sts);

    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);
    st.stream_result ();
    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< ::person, id_oracle >::
  reload (database& db, object_type& obj)
  {
    using namespace oracle;

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

    statements_type::auto_lock l (sts);

    const id_type& id  (
      obj.id);

    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);
    st.stream_result ();
    load_ (sts, obj, true);
    sts.load_delayed (0);
    l.unlock ();
    callback (db, obj, callback_event::post_load);
    return true;
  }

  bool access::object_traits_impl< ::person, id_oracle >::
  find_ (statements_type& sts,
         const id_type* id)
  {
    using namespace oracle;

    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 ());

    return r != select_statement::no_data;
  }
}

#include <odb/post.hxx>