diff options
Diffstat (limited to 'bulk/mssql/id/person-odb.cxx')
| -rw-r--r-- | bulk/mssql/id/person-odb.cxx | 569 |
1 files changed, 569 insertions, 0 deletions
diff --git a/bulk/mssql/id/person-odb.cxx b/bulk/mssql/id/person-odb.cxx new file mode 100644 index 0000000..48d535c --- /dev/null +++ b/bulk/mssql/id/person-odb.cxx @@ -0,0 +1,569 @@ +// 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/mssql/traits.hxx> +#include <odb/mssql/database.hxx> +#include <odb/mssql/transaction.hxx> +#include <odb/mssql/connection.hxx> +#include <odb/mssql/statement.hxx> +#include <odb/mssql/statement-cache.hxx> +#include <odb/mssql/simple-object-statements.hxx> +#include <odb/mssql/container-statements.hxx> +#include <odb/mssql/exceptions.hxx> + +namespace odb +{ + // person + // + + struct access::object_traits_impl< ::person, id_mssql >::extra_statement_cache_type + { + extra_statement_cache_type ( + mssql::connection&, + image_type&, + mssql::binding&, + mssql::binding&) + { + } + }; + + void access::object_traits_impl< ::person, id_mssql >:: + bind (mssql::bind* b, + image_type& i, + mssql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (sk); + + using namespace mssql; + + std::size_t n (0); + + // id + // + if (/*%%sk != statement_insert &&*/ sk != statement_update) + { + b[n].type = mssql::bind::bigint; + b[n].buffer = &i.id_value; + b[n].size_ind = &i.id_size_ind; + n++; + } + + // num + // + b[n].type = mssql::bind::int_; + b[n].buffer = &i.num_value; + b[n].size_ind = &i.num_size_ind; + n++; + + // str + // + b[n].type = mssql::bind::long_string; + b[n].buffer = &i.str_callback; + b[n].size_ind = &i.str_size_ind; + b[n].capacity = 0; + n++; + } + + void access::object_traits_impl< ::person, id_mssql >:: + bind (mssql::bind* b, id_image_type& i) + { + std::size_t n (0); + b[n].type = mssql::bind::bigint; + b[n].buffer = &i.id_value; + b[n].size_ind = &i.id_size_ind; + } + + void access::object_traits_impl< ::person, id_mssql >:: + init (image_type& i, + const object_type& o, + mssql::statement_kind sk) + { + ODB_POTENTIALLY_UNUSED (i); + ODB_POTENTIALLY_UNUSED (o); + ODB_POTENTIALLY_UNUSED (sk); + + using namespace mssql; + + // id %% + // + { + long unsigned int const& v = + o.id; + + bool is_null (false); + mssql::value_traits< + long unsigned int, + mssql::id_bigint >::set_image ( + i.id_value, is_null, v); + i.id_size_ind = is_null ? SQL_NULL_DATA : 0; + } + + // num + // + { + unsigned int const& v = + o.num; + + bool is_null (false); + mssql::value_traits< + unsigned int, + mssql::id_int >::set_image ( + i.num_value, is_null, v); + i.num_size_ind = is_null ? SQL_NULL_DATA : 0; + } + + // str + // + { + ::std::string const& v = + o.str; + + bool is_null (false); + mssql::value_traits< + ::std::string, + mssql::id_long_string >::set_image ( + i.str_callback.callback.param, + i.str_callback.context.param, + is_null, + v); + i.str_size_ind = is_null ? SQL_NULL_DATA : SQL_DATA_AT_EXEC; + } + } + + void access::object_traits_impl< ::person, id_mssql >:: + 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; + + mssql::value_traits< + long unsigned int, + mssql::id_bigint >::set_value ( + v, + i.id_value, + i.id_size_ind == SQL_NULL_DATA); + } + + // num + // + { + unsigned int& v = + o.num; + + mssql::value_traits< + unsigned int, + mssql::id_int >::set_value ( + v, + i.num_value, + i.num_size_ind == SQL_NULL_DATA); + } + + // str + // + { + ::std::string& v = + o.str; + + mssql::value_traits< + ::std::string, + mssql::id_long_string >::set_value ( + v, + i.str_callback.callback.result, + i.str_callback.context.result); + } + } + + void access::object_traits_impl< ::person, id_mssql >:: + init (id_image_type& i, const id_type& id) + { + { + bool is_null (false); + mssql::value_traits< + long unsigned int, + mssql::id_bigint >::set_image ( + i.id_value, is_null, id); + i.id_size_ind = is_null ? SQL_NULL_DATA : 0; + } + } + + const char access::object_traits_impl< ::person, id_mssql >::persist_statement[] = + "INSERT INTO [person] " + "([id], " // %% + "[num], " + "[str]) " + //%% "OUTPUT INSERTED.[id] " + "VALUES " + "(?, ?, ?)"; // %% + + const char access::object_traits_impl< ::person, id_mssql >::find_statement[] = + "SELECT " + "[person].[id], " + "[person].[num], " + "[person].[str] " + "FROM [person] " + "WHERE [person].[id]=?"; + + const char access::object_traits_impl< ::person, id_mssql >::update_statement[] = + "UPDATE [person] " + "SET " + "[num]=?, " + "[str]=? " + "WHERE [id]=?"; + + const char access::object_traits_impl< ::person, id_mssql >::erase_statement[] = + "DELETE FROM [person] " + "WHERE [id]=?"; + + void access::object_traits_impl< ::person, id_mssql >:: + persist (database& db, object_type** objs, std::size_t n, + multiple_exceptions* mex) + { + ODB_POTENTIALLY_UNUSED (db); + assert (n <= batch); + + using namespace mssql; + + mssql::connection& conn ( + mssql::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++; + } + + 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 = static_cast< id_type > (st.id ()); + + callback (db, + static_cast<const object_type&> (obj), + callback_event::post_persist); + } + } + + void access::object_traits_impl< ::person, id_mssql >:: + update (database& db, const object_type& obj) + { + ODB_POTENTIALLY_UNUSED (db); + + using namespace mssql; + using mssql::update_statement; + + callback (db, obj, callback_event::pre_update); + + mssql::transaction& tr (mssql::transaction::current ()); + mssql::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_mssql >:: + erase (database& db, const id_type& id) + { + using namespace mssql; + + ODB_POTENTIALLY_UNUSED (db); + + mssql::connection& conn ( + mssql::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_mssql >::pointer_type + access::object_traits_impl< ::person, id_mssql >:: + find (database& db, const id_type& id) + { + using namespace mssql; + + { + pointer_type p (pointer_cache_traits::find (db, id)); + + if (!pointer_traits::null_ptr (p)) + return p; + } + + mssql::connection& conn ( + mssql::transaction::current ().connection ()); + statements_type& sts ( + conn.statement_cache ().find_object<object_type> ()); + + statements_type::auto_lock l (sts); + auto_result ar; + + if (l.locked ()) + { + if (!find_ (sts, &id)) + return pointer_type (); + + ar.set (sts.find_statement ()); + } + + 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 (); + ar.free (); + 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_mssql >:: + find (database& db, const id_type& id, object_type& obj) + { + using namespace mssql; + + mssql::connection& conn ( + mssql::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); + + auto_result ar (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 (); + ar.free (); + 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_mssql >:: + reload (database& db, object_type& obj) + { + using namespace mssql; + + mssql::connection& conn ( + mssql::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); + + auto_result ar (st); + + callback (db, obj, callback_event::pre_load); + init (obj, sts.image (), &db); + st.stream_result (); + ar.free (); + 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_mssql >:: + find_ (statements_type& sts, + const id_type* id) + { + using namespace mssql; + + 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::no_data) + { + ar.release (); + return true; + } + else + return false; + } +} + +#include <odb/post.hxx> |