From 0d0e4b23176f0b55d7948ffef9b9ffdad6a95973 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Thu, 14 Aug 2014 09:37:06 +0200 Subject: Draft implementation for INSERT --- bulk/oracle/orig/person-odb.cxx | 546 ++++++++++++++++++++++++++++++++++++++++ bulk/oracle/orig/person-odb.hxx | 218 ++++++++++++++++ bulk/oracle/orig/person-odb.ixx | 61 +++++ 3 files changed, 825 insertions(+) create mode 100644 bulk/oracle/orig/person-odb.cxx create mode 100644 bulk/oracle/orig/person-odb.hxx create mode 100644 bulk/oracle/orig/person-odb.ixx (limited to 'bulk/oracle/orig') diff --git a/bulk/oracle/orig/person-odb.cxx b/bulk/oracle/orig/person-odb.cxx new file mode 100644 index 0000000..e18ffae --- /dev/null +++ b/bulk/oracle/orig/person-odb.cxx @@ -0,0 +1,546 @@ +// This file was generated by ODB, object-relational mapping (ORM) +// compiler for C++. +// + +#include + +#include "person-odb.hxx" + +#include +#include // std::memcpy + + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +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 (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 (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 (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& obj) + { + ODB_POTENTIALLY_UNUSED (db); + + using namespace oracle; + + oracle::connection& conn ( + oracle::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object ()); + + callback (db, + static_cast (obj), + callback_event::pre_persist); + + image_type& im (sts.image ()); + binding& imb (sts.insert_image_binding ()); + + init (im, obj, statement_insert); + + 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 (); + + obj.id = static_cast< id_type > (st.id ()); + + callback (db, + static_cast (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 ()); + + 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 ()); + + 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 ()); + + statements_type::auto_lock l (sts); + + if (l.locked ()) + { + if (!find_ (sts, &id)) + return pointer_type (); + } + + pointer_type p ( + access::object_factory::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 ()); + + 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 ()); + + 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 diff --git a/bulk/oracle/orig/person-odb.hxx b/bulk/oracle/orig/person-odb.hxx new file mode 100644 index 0000000..460be54 --- /dev/null +++ b/bulk/oracle/orig/person-odb.hxx @@ -0,0 +1,218 @@ +// This file was generated by ODB, object-relational mapping (ORM) +// compiler for C++. +// + +#ifndef PERSON_ODB_HXX +#define PERSON_ODB_HXX + +#include + +#if (ODB_VERSION != 20302UL) +#error ODB runtime version mismatch +#endif + +#include + +#include "person.hxx" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include + +namespace odb +{ + // person + // + template <> + struct class_traits< ::person > + { + static const class_kind kind = class_object; + }; + + template <> + class access::object_traits< ::person > + { + public: + typedef ::person object_type; + typedef ::person* pointer_type; + typedef odb::pointer_traits pointer_traits; + + static const bool polymorphic = false; + + typedef long unsigned int id_type; + + static const bool auto_id = true; + + static const bool abstract = false; + + static id_type + id (const object_type&); + + typedef + no_op_pointer_cache_traits + pointer_cache_traits; + + typedef + no_op_reference_cache_traits + reference_cache_traits; + + static void + callback (database&, object_type&, callback_event); + + static void + callback (database&, const object_type&, callback_event); + }; +} + +#include + +#include +#include +#include +#include + +namespace odb +{ + // person + // + template <> + class access::object_traits_impl< ::person, id_oracle >: + public access::object_traits< ::person > + { + public: + struct id_image_type + { + char id_value[12]; + ub2 id_size; + sb2 id_indicator; + + std::size_t version; + }; + + struct image_type + { + // id + // + char id_value[12]; + ub2 id_size; + sb2 id_indicator; + + // num + // + unsigned int num_value; + sb2 num_indicator; + + // str + // + mutable oracle::lob_callback str_callback; + sb2 str_indicator; + oracle::lob str_lob; + + std::size_t version; + + oracle::change_callback* + change_callback () + { + return 0; + } + }; + + struct extra_statement_cache_type; + + using object_traits::id; + + static id_type + id (const id_image_type&); + + static void + bind (oracle::bind*, + image_type&, + oracle::statement_kind); + + static void + bind (oracle::bind*, id_image_type&); + + static void + init (image_type&, + const object_type&, + oracle::statement_kind); + + static void + init (object_type&, + const image_type&, + database*); + + static void + init (id_image_type&, const id_type&); + + typedef oracle::object_statements statements_type; + + static const std::size_t column_count = 3UL; + static const std::size_t id_column_count = 1UL; + static const std::size_t inverse_column_count = 0UL; + static const std::size_t readonly_column_count = 0UL; + static const std::size_t managed_optimistic_column_count = 0UL; + + static const std::size_t separate_load_column_count = 0UL; + static const std::size_t separate_update_column_count = 0UL; + + static const bool versioned = false; + + static const char persist_statement[]; + static const char find_statement[]; + static const char update_statement[]; + static const char erase_statement[]; + + static void + persist (database&, object_type&); + + static pointer_type + find (database&, const id_type&); + + static bool + find (database&, const id_type&, object_type&); + + static bool + reload (database&, object_type&); + + static void + update (database&, const object_type&); + + static void + erase (database&, const id_type&); + + static void + erase (database&, const object_type&); + + public: + static bool + find_ (statements_type&, + const id_type*); + + static void + load_ (statements_type&, + object_type&, + bool reload); + }; + + template <> + class access::object_traits_impl< ::person, id_common >: + public access::object_traits_impl< ::person, id_oracle > + { + }; +} + +#include "person-odb.ixx" + +#include + +#endif // PERSON_ODB_HXX diff --git a/bulk/oracle/orig/person-odb.ixx b/bulk/oracle/orig/person-odb.ixx new file mode 100644 index 0000000..d1763df --- /dev/null +++ b/bulk/oracle/orig/person-odb.ixx @@ -0,0 +1,61 @@ +// This file was generated by ODB, object-relational mapping (ORM) +// compiler for C++. +// + +namespace odb +{ + // person + // + + inline + access::object_traits< ::person >::id_type + access::object_traits< ::person >:: + id (const object_type& o) + { + return o.id; + } + + inline + void access::object_traits< ::person >:: + callback (database& db, object_type& x, callback_event e) + { + ODB_POTENTIALLY_UNUSED (db); + ODB_POTENTIALLY_UNUSED (x); + ODB_POTENTIALLY_UNUSED (e); + } + + inline + void access::object_traits< ::person >:: + callback (database& db, const object_type& x, callback_event e) + { + ODB_POTENTIALLY_UNUSED (db); + ODB_POTENTIALLY_UNUSED (x); + ODB_POTENTIALLY_UNUSED (e); + } +} + +namespace odb +{ + // person + // + + inline + void access::object_traits_impl< ::person, id_oracle >:: + erase (database& db, const object_type& obj) + { + callback (db, obj, callback_event::pre_erase); + erase (db, id (obj)); + callback (db, obj, callback_event::post_erase); + } + + inline + void access::object_traits_impl< ::person, id_oracle >:: + load_ (statements_type& sts, + object_type& obj, + bool) + { + ODB_POTENTIALLY_UNUSED (sts); + ODB_POTENTIALLY_UNUSED (obj); + } +} + -- cgit v1.1