cppbessot/db/test-schema-v1.1/generated-sql-ddl/sqlite/TripAttemptResult-odb.cxx

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

#include <odb/pre.hxx>

#include "TripAttemptResult-odb.hxx"

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


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

namespace odb
{
  // TripAttemptResult
  //

  struct access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::extra_statement_cache_type
  {
    extra_statement_cache_type (
      sqlite::connection&,
      image_type&,
      id_image_type&,
      sqlite::binding&,
      sqlite::binding&)
    {
    }
  };

  access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::id_type
  access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  id (const image_type& i)
  {
    sqlite::database* db (0);
    ODB_POTENTIALLY_UNUSED (db);

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

    return id;
  }

  bool access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  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;
    }

    // result
    //
    if (t[1UL])
    {
      i.result_value.capacity (i.result_size);
      grew = true;
    }

    // retryReason
    //
    if (t[2UL])
    {
      i.retryReason_value.capacity (i.retryReason_size);
      grew = true;
    }

    // governmentSuspensionReason
    //
    if (t[3UL])
    {
      i.governmentSuspensionReason_value.capacity (i.governmentSuspensionReason_size);
      grew = true;
    }

    // governmentTerminationReason
    //
    if (t[4UL])
    {
      i.governmentTerminationReason_value.capacity (i.governmentTerminationReason_size);
      grew = true;
    }

    // complianceSuspensionReason
    //
    if (t[5UL])
    {
      i.complianceSuspensionReason_value.capacity (i.complianceSuspensionReason_size);
      grew = true;
    }

    // complianceTerminationReason
    //
    if (t[6UL])
    {
      i.complianceTerminationReason_value.capacity (i.complianceTerminationReason_size);
      grew = true;
    }

    // policySuspensionReason
    //
    if (t[7UL])
    {
      i.policySuspensionReason_value.capacity (i.policySuspensionReason_size);
      grew = true;
    }

    // policyTerminationReason
    //
    if (t[8UL])
    {
      i.policyTerminationReason_value.capacity (i.policyTerminationReason_size);
      grew = true;
    }

    // cancelationReason
    //
    if (t[9UL])
    {
      i.cancelationReason_value.capacity (i.cancelationReason_size);
      grew = true;
    }

    // failureReason
    //
    if (t[10UL])
    {
      i.failureReason_value.capacity (i.failureReason_size);
      grew = true;
    }

    // details
    //
    if (t[11UL])
    {
      i.details_value.capacity (i.details_size);
      grew = true;
    }

    return grew;
  }

  void access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  bind (sqlite::bind* b,
        image_type& i,
        sqlite::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace sqlite;

    std::size_t n (0);

    // id
    //
    if (sk != statement_update)
    {
      b[n].type = sqlite::image_traits<
        ::std::string,
        sqlite::id_text>::bind_value;
      b[n].buffer = i.id_value.data ();
      b[n].size = &i.id_size;
      b[n].capacity = i.id_value.capacity ();
      b[n].is_null = &i.id_null;
      n++;
    }

    // result
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.result_value.data ();
    b[n].size = &i.result_size;
    b[n].capacity = i.result_value.capacity ();
    b[n].is_null = &i.result_null;
    n++;

    // retryReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.retryReason_value.data ();
    b[n].size = &i.retryReason_size;
    b[n].capacity = i.retryReason_value.capacity ();
    b[n].is_null = &i.retryReason_null;
    n++;

    // governmentSuspensionReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.governmentSuspensionReason_value.data ();
    b[n].size = &i.governmentSuspensionReason_size;
    b[n].capacity = i.governmentSuspensionReason_value.capacity ();
    b[n].is_null = &i.governmentSuspensionReason_null;
    n++;

    // governmentTerminationReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.governmentTerminationReason_value.data ();
    b[n].size = &i.governmentTerminationReason_size;
    b[n].capacity = i.governmentTerminationReason_value.capacity ();
    b[n].is_null = &i.governmentTerminationReason_null;
    n++;

    // complianceSuspensionReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.complianceSuspensionReason_value.data ();
    b[n].size = &i.complianceSuspensionReason_size;
    b[n].capacity = i.complianceSuspensionReason_value.capacity ();
    b[n].is_null = &i.complianceSuspensionReason_null;
    n++;

    // complianceTerminationReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.complianceTerminationReason_value.data ();
    b[n].size = &i.complianceTerminationReason_size;
    b[n].capacity = i.complianceTerminationReason_value.capacity ();
    b[n].is_null = &i.complianceTerminationReason_null;
    n++;

    // policySuspensionReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.policySuspensionReason_value.data ();
    b[n].size = &i.policySuspensionReason_size;
    b[n].capacity = i.policySuspensionReason_value.capacity ();
    b[n].is_null = &i.policySuspensionReason_null;
    n++;

    // policyTerminationReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.policyTerminationReason_value.data ();
    b[n].size = &i.policyTerminationReason_size;
    b[n].capacity = i.policyTerminationReason_value.capacity ();
    b[n].is_null = &i.policyTerminationReason_null;
    n++;

    // cancelationReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.cancelationReason_value.data ();
    b[n].size = &i.cancelationReason_size;
    b[n].capacity = i.cancelationReason_value.capacity ();
    b[n].is_null = &i.cancelationReason_null;
    n++;

    // failureReason
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.failureReason_value.data ();
    b[n].size = &i.failureReason_size;
    b[n].capacity = i.failureReason_value.capacity ();
    b[n].is_null = &i.failureReason_null;
    n++;

    // details
    //
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.details_value.data ();
    b[n].size = &i.details_size;
    b[n].capacity = i.details_value.capacity ();
    b[n].is_null = &i.details_null;
    n++;
  }

  void access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  bind (sqlite::bind* b, id_image_type& i)
  {
    std::size_t n (0);
    b[n].type = sqlite::image_traits<
      ::std::string,
      sqlite::id_text>::bind_value;
    b[n].buffer = i.id_value.data ();
    b[n].size = &i.id_size;
    b[n].capacity = i.id_value.capacity ();
    b[n].is_null = &i.id_null;
  }

  bool access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  init (image_type& i,
        const object_type& o,
        sqlite::statement_kind sk)
  {
    ODB_POTENTIALLY_UNUSED (i);
    ODB_POTENTIALLY_UNUSED (o);
    ODB_POTENTIALLY_UNUSED (sk);

    using namespace sqlite;

    bool grew (false);

    // id
    //
    if (sk == statement_insert)
    {
      ::std::string const& v =
        o.id;

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

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

      bool is_null (false);
      std::size_t cap (i.result_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.result_value,
        i.result_size,
        is_null,
        v);
      i.result_null = is_null;
      grew = grew || (cap != i.result_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.retryReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.retryReason_value,
        i.retryReason_size,
        is_null,
        v);
      i.retryReason_null = is_null;
      grew = grew || (cap != i.retryReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.governmentSuspensionReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.governmentSuspensionReason_value,
        i.governmentSuspensionReason_size,
        is_null,
        v);
      i.governmentSuspensionReason_null = is_null;
      grew = grew || (cap != i.governmentSuspensionReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.governmentTerminationReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.governmentTerminationReason_value,
        i.governmentTerminationReason_size,
        is_null,
        v);
      i.governmentTerminationReason_null = is_null;
      grew = grew || (cap != i.governmentTerminationReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.complianceSuspensionReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.complianceSuspensionReason_value,
        i.complianceSuspensionReason_size,
        is_null,
        v);
      i.complianceSuspensionReason_null = is_null;
      grew = grew || (cap != i.complianceSuspensionReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.complianceTerminationReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.complianceTerminationReason_value,
        i.complianceTerminationReason_size,
        is_null,
        v);
      i.complianceTerminationReason_null = is_null;
      grew = grew || (cap != i.complianceTerminationReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.policySuspensionReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.policySuspensionReason_value,
        i.policySuspensionReason_size,
        is_null,
        v);
      i.policySuspensionReason_null = is_null;
      grew = grew || (cap != i.policySuspensionReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.policyTerminationReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.policyTerminationReason_value,
        i.policyTerminationReason_size,
        is_null,
        v);
      i.policyTerminationReason_null = is_null;
      grew = grew || (cap != i.policyTerminationReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.cancelationReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.cancelationReason_value,
        i.cancelationReason_size,
        is_null,
        v);
      i.cancelationReason_null = is_null;
      grew = grew || (cap != i.cancelationReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.failureReason_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.failureReason_value,
        i.failureReason_size,
        is_null,
        v);
      i.failureReason_null = is_null;
      grew = grew || (cap != i.failureReason_value.capacity ());
    }

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

      bool is_null (false);
      std::size_t cap (i.details_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.details_value,
        i.details_size,
        is_null,
        v);
      i.details_null = is_null;
      grew = grew || (cap != i.details_value.capacity ());
    }

    return grew;
  }

  void access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  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;

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

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.result_value,
        i.result_size,
        i.result_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.retryReason_value,
        i.retryReason_size,
        i.retryReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.governmentSuspensionReason_value,
        i.governmentSuspensionReason_size,
        i.governmentSuspensionReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.governmentTerminationReason_value,
        i.governmentTerminationReason_size,
        i.governmentTerminationReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.complianceSuspensionReason_value,
        i.complianceSuspensionReason_size,
        i.complianceSuspensionReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.complianceTerminationReason_value,
        i.complianceTerminationReason_size,
        i.complianceTerminationReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.policySuspensionReason_value,
        i.policySuspensionReason_size,
        i.policySuspensionReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.policyTerminationReason_value,
        i.policyTerminationReason_size,
        i.policyTerminationReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.cancelationReason_value,
        i.cancelationReason_size,
        i.cancelationReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.failureReason_value,
        i.failureReason_size,
        i.failureReason_null);
    }

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

      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_value (
        v,
        i.details_value,
        i.details_size,
        i.details_null);
    }
  }

  void access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  init (id_image_type& i, const id_type& id)
  {
    bool grew (false);
    {
      bool is_null (false);
      std::size_t cap (i.id_value.capacity ());
      sqlite::value_traits<
          ::std::string,
          sqlite::id_text >::set_image (
        i.id_value,
        i.id_size,
        is_null,
        id);
      i.id_null = is_null;
      grew = grew || (cap != i.id_value.capacity ());
    }

    if (grew)
      i.version++;
  }

  const char access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::persist_statement[] =
  "INSERT INTO \"TripAttemptResult\" "
  "(\"id\", "
  "\"result\", "
  "\"retryReason\", "
  "\"governmentSuspensionReason\", "
  "\"governmentTerminationReason\", "
  "\"complianceSuspensionReason\", "
  "\"complianceTerminationReason\", "
  "\"policySuspensionReason\", "
  "\"policyTerminationReason\", "
  "\"cancelationReason\", "
  "\"failureReason\", "
  "\"details\") "
  "VALUES "
  "(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";

  const char access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::find_statement[] =
  "SELECT "
  "\"TripAttemptResult\".\"id\", "
  "\"TripAttemptResult\".\"result\", "
  "\"TripAttemptResult\".\"retryReason\", "
  "\"TripAttemptResult\".\"governmentSuspensionReason\", "
  "\"TripAttemptResult\".\"governmentTerminationReason\", "
  "\"TripAttemptResult\".\"complianceSuspensionReason\", "
  "\"TripAttemptResult\".\"complianceTerminationReason\", "
  "\"TripAttemptResult\".\"policySuspensionReason\", "
  "\"TripAttemptResult\".\"policyTerminationReason\", "
  "\"TripAttemptResult\".\"cancelationReason\", "
  "\"TripAttemptResult\".\"failureReason\", "
  "\"TripAttemptResult\".\"details\" "
  "FROM \"TripAttemptResult\" "
  "WHERE \"TripAttemptResult\".\"id\"=?";

  const char access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::update_statement[] =
  "UPDATE \"TripAttemptResult\" "
  "SET "
  "\"result\"=?, "
  "\"retryReason\"=?, "
  "\"governmentSuspensionReason\"=?, "
  "\"governmentTerminationReason\"=?, "
  "\"complianceSuspensionReason\"=?, "
  "\"complianceTerminationReason\"=?, "
  "\"policySuspensionReason\"=?, "
  "\"policyTerminationReason\"=?, "
  "\"cancelationReason\"=?, "
  "\"failureReason\"=?, "
  "\"details\"=? "
  "WHERE \"id\"=?";

  const char access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::erase_statement[] =
  "DELETE FROM \"TripAttemptResult\" "
  "WHERE \"id\"=?";

  const char access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::query_statement[] =
  "SELECT "
  "\"TripAttemptResult\".\"id\", "
  "\"TripAttemptResult\".\"result\", "
  "\"TripAttemptResult\".\"retryReason\", "
  "\"TripAttemptResult\".\"governmentSuspensionReason\", "
  "\"TripAttemptResult\".\"governmentTerminationReason\", "
  "\"TripAttemptResult\".\"complianceSuspensionReason\", "
  "\"TripAttemptResult\".\"complianceTerminationReason\", "
  "\"TripAttemptResult\".\"policySuspensionReason\", "
  "\"TripAttemptResult\".\"policyTerminationReason\", "
  "\"TripAttemptResult\".\"cancelationReason\", "
  "\"TripAttemptResult\".\"failureReason\", "
  "\"TripAttemptResult\".\"details\" "
  "FROM \"TripAttemptResult\"";

  const char access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::erase_query_statement[] =
  "DELETE FROM \"TripAttemptResult\"";

  const char access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::table_name[] =
  "\"TripAttemptResult\"";

  void access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  persist (database& db, const object_type& obj)
  {
    ODB_POTENTIALLY_UNUSED (db);

    using namespace sqlite;

    sqlite::connection& conn (
      sqlite::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< ::models::TripAttemptResult, id_sqlite >::
  update (database& db, const object_type& obj)
  {
    ODB_POTENTIALLY_UNUSED (db);

    using namespace sqlite;
    using sqlite::update_statement;

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

    sqlite::transaction& tr (sqlite::transaction::current ());
    sqlite::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 ());
    if (init (im, obj, statement_update))
      im.version++;

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

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

      sts.update_id_image_version (idi.version);

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

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

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

  void access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  erase (database& db, const id_type& id)
  {
    using namespace sqlite;

    ODB_POTENTIALLY_UNUSED (db);

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

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

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

    sqlite::connection& conn (
      sqlite::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< ::models::TripAttemptResult, id_sqlite >::
  find (database& db, const id_type& id, object_type& obj)
  {
    using namespace sqlite;

    sqlite::connection& conn (
      sqlite::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);
    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< ::models::TripAttemptResult, id_sqlite >::
  reload (database& db, object_type& obj)
  {
    using namespace sqlite;

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

  bool access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  find_ (statements_type& sts,
         const id_type* id)
  {
    using namespace sqlite;

    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< ::models::TripAttemptResult, id_sqlite >::object_type >
  access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  query (database&, const query_base_type& q)
  {
    using namespace sqlite;
    using odb::details::shared;
    using odb::details::shared_ptr;

    sqlite::connection& conn (
      sqlite::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 (
        conn,
        text,
        false,
        true,
        q.parameters_binding (),
        imb));

    st->execute ();

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

    return result<object_type> (r);
  }

  unsigned long long access::object_traits_impl< ::models::TripAttemptResult, id_sqlite >::
  erase_query (database&, const query_base_type& q)
  {
    using namespace sqlite;

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

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

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

    return st.execute ();
  }
}

#include <odb/post.hxx>