#include <bzs/db/protocol/tdap/client/trdormapi.h>
#include <bzs/db/protocol/tdap/client/databaseManager.h>
#include <boost/iterator/iterator_facade.hpp>
#include <iostream>
#include <vector>
using namespace bzs::db::protocol::tdap::client;
using namespace bzs::db::protocol::tdap;
class user;
typedef boost::shared_ptr<user> user_ptr;
typedef std::vector<user_ptr> user_ptr_list;
typedef std::vector<user*> user_list;
typedef boost::shared_ptr<user_list> user_list_ptr;
class group;
typedef boost::shared_ptr<group> group_ptr;
typedef std::vector<group_ptr> group_ptr_list;
typedef std::vector<group*> group_list;
typedef boost::shared_ptr<group_list> group_list_ptr;
class group
{
int m_id;
std::string m_name;
mutable user_ptr_list* m_users;
protected:
group(void* owner) : m_id(0), m_users(NULL) {}
public:
~group() { delete m_users; }
int id() const { return m_id; }
const std::string& name() const { return m_name; }
void setId(int v) { m_id = v; }
void setName(const char* v) { m_name = v; }
user_ptr_list& users() const
{
if (!m_users)
m_users = new user_ptr_list;
return *m_users;
}
static group* create(void* owner) { return new group(owner); };
};
group* create(group_ptr_list& m, int)
{
return group::create(&m);
}
class group_fdi
{
public:
short id;
short name;
{
}
};
group_fdi* createFdi(group_fdi*)
{
return new group_fdi();
}
void destroyFdi(group_fdi* p)
{
delete p;
}
void initFdi(group_fdi* fdi,
table* tb)
{
fdi->init(tb);
}
class group_orm
{
const group_fdi& m_fdi;
public:
typedef group mdl_typename;
typedef group_fdi fdi_typename;
group_orm(const fdi_typename& fdi) : m_fdi(fdi) {}
bool compKeyValue(group& l, group& r, int keyNum) const
{
return l.id() < r.id();
}
void setKeyValues(group& g, const fields& fds, int keyNum)
{
fds[m_fdi.id] = g.id();
}
void writeMap(group& g, const fields& fds, int optipn)
{
fds[m_fdi.id] = g.id();
fds[m_fdi.name] = g.name();
}
void readMap(group& g, const fields& fds, int optipn)
{
g.setId(fds[m_fdi.id].i());
g.setName(fds[m_fdi.name].a_str());
}
void readAuntoincValue(group& g, const fields& fds, int optipn)
{
g.setId(fds[m_fdi.id].i());
}
const _TCHAR* getTableName() { return _T("group1"); }
};
class user
{
mutable group* m_grp;
int m_id;
int m_group_id;
std::string m_name;
std::string m_tel;
protected:
user(void* owner) : m_grp(NULL), m_id(0) {}
public:
~user() { delete m_grp; }
group* grp() const
{
if (m_grp == NULL)
{
m_grp = group::create(0);
m_grp->setId(m_group_id);
}
return m_grp;
}
int id() const { return m_id; }
int group_id() const { return m_group_id; }
const std::string& name() const { return m_name; }
const std::string& tel() const { return m_tel; }
void setId(int v) { m_id = v; }
void setGroup_id(int v) { m_group_id = v; }
void setName(const char* v) { m_name = v; }
void setTel(const char* v) { m_tel = v; }
static user* create(void* owner) { return new user(owner); };
};
class user_fdi
{
public:
short id;
short name;
short tel;
short group_id;
{
}
};
user_fdi* createFdi(user_fdi*)
{
return new user_fdi();
}
void destroyFdi(user_fdi* p)
{
delete p;
}
void initFdi(user_fdi* fdi,
table* tb)
{
fdi->init(tb);
}
class mdls;
class mdlsIterator
: public boost::iterator_facade<mdlsIterator, user*,
boost::random_access_traversal_tag>
{
friend class boost::iterator_core_access;
size_t m_index;
mdls* m_mdls;
user*& dereference() const;
void increment();
void decrement();
void advance(size_t n);
int distance_to(const mdlsIterator& r) const;
bool equal(const mdlsIterator& r) const;
public:
mdlsIterator(mdls* m, size_t index = 0);
};
class mdls
{
mutable std::vector<user*> m_users;
public:
void clear() { m_users.clear(); }
user*& item(size_t index) const { return m_users[index]; }
user* add(user* u)
{
m_users.push_back(u);
return u;
}
size_t size() { return m_users.size(); }
user* operator[](unsigned int index) const { return item(index); }
typedef user* item_type;
typedef mdlsIterator iterator;
};
user*& mdlsIterator::dereference() const
{
return m_mdls->item(m_index);
}
void mdlsIterator::increment()
{
++m_index;
}
void mdlsIterator::decrement()
{
--m_index;
}
void mdlsIterator::advance(size_t n)
{
m_index += n;
}
int mdlsIterator::distance_to(const mdlsIterator& r) const
{
return (int)(r.m_index - m_index);
}
bool mdlsIterator::equal(const mdlsIterator& r) const
{
return m_index == r.m_index;
}
mdlsIterator::mdlsIterator(mdls* m, size_t index) : m_index(index), m_mdls(m)
{
}
namespace bzs
{
namespace db
{
namespace protocol
{
namespace tdap
{
namespace client
{
template <> inline mdlsIterator begin(mdls& m)
{
return mdlsIterator(&m, 0);
}
template <> inline mdlsIterator end(mdls& m)
{
return mdlsIterator(&m, m.size());
}
#if (_MSC_VER || (__BCPLUSPLUS__ && !defined(__clang__)))
inline void push_back(mdls& m, user* u)
{
m.add(u);
}
#else
template <> inline void push_back(mdls& m, user* u)
{
m.add(u);
}
#endif
}
}
}
}
}
user* create(mdls& m, int)
{
return user::create(&m);
}
user* create(user_ptr_list& m, int)
{
return user::create(&m);
}
class user_orm
{
const user_fdi& m_fdi;
public:
user_orm(const user_fdi& fdi) : m_fdi(fdi) {}
bool compKeyValue(user& l, user& r, int keyNum) const
{
if (keyNum == 0)
return l.id() < r.id();
return 1;
}
void setKeyValues(user& u, const fields& fds, int keyNum)
{
fds[m_fdi.id] = u.id();
}
void writeMap(user& u, const fields& fds, int optipn)
{
fds[m_fdi.id] = u.id();
fds[m_fdi.name] = u.name();
fds[m_fdi.tel] = u.tel();
fds[m_fdi.group_id] = u.group_id();
}
void readMap(user& u, const fields& fds, int optipn)
{
u.setId(fds[m_fdi.id].i());
u.setGroup_id(fds[m_fdi.group_id].i());
u.setName(fds[m_fdi.name].a_str());
u.setTel(fds[m_fdi.tel].a_str());
}
void readAuntoincValue(user& u, const fields& fds, int optipn)
{
u.setId(fds[m_fdi.id].i());
}
const _TCHAR* getTableName() { return _T("user"); }
typedef user mdl_typename;
typedef user_fdi fdi_typename;
typedef mdlsHandler<user_orm, mdls> collection_orm_typename;
};
typedef user_orm::collection_orm_typename users_orm;
int isMatch(const fields& fds)
{
return filter_validate_value;
}
template <class T> void dumpUser(const T user)
{
std::cout << " id " << user->id() << std::endl;
std::cout << " name " << user->name() << std::endl;
std::cout << " group " << user->grp()->name() << std::endl;
std::cout << " tel " << user->tel() << std::endl << std::endl;
}
bool sortFunc2(const user* l, const user* r)
{
return l->name() < r->name();
}
{
static int find_group_id = 2;
static const char_td keynum_group = 1;
static const char_td primary_key = 0;
int id = 12;
user_ptr u(user::create(0));
u->setId(id);
u->setName("moriwaki");
u->setTel("81-999-9999");
u->setGroup_id(1);
ut.index(primary_key);
ut.save(*u);
ut.read(*u);
u->setTel("81-999-8888");
ut.update(*u);
ut.index(primary_key).keyValue(u->id());
u->setId(13);
bool noKeyValueFromObj = false;
ut.update(*u, noKeyValueFromObj);
ut.del(*u);
group_ptr grp(group::create(0));
gt.index(primary_key).keyValue(2).read(*grp, noKeyValueFromObj);
group* g = group::create(0);
g->setId(2);
gt.read(*g);
delete g;
ut.index(keynum_group).keyValue(find_group_id);
query q;
q.
select(_T(
"*")).
where(_T(
"group"), _T(
"="), find_group_id);
ut.read(users, q);
mdls m;
ut.index(keynum_group).keyValue(find_group_id).read(m, q);
users_orm users_hdr(m);
ut.readMap(users_hdr, q);
ut.index(keynum_group).keyValue(find_group_id).read(users, q, isMatch);
gt.index(primary_key);
std::vector<group_ptr> gmdls;
q.
select(_T(
"id"), _T(
"name")).
in(1, 2, 3);
gt.read(gmdls, q);
ut.index(keynum_group).keyValue(grp->id()).read(grp->users(), q);
query qe;
qe.
select(_T(
"id"), _T(
"name"));
gt.index(primary_key);
gt.readEach(users, &user::grp, qe);
gt.readEach(m, &user::grp, qe);
group_list_ptr grps(listup(users, &user::grp));
gt.index(primary_key).readEach(*grps, qe);
group_list_ptr grps2(listup(m, &user::grp));
gt.index(primary_key).readEach(*grps2, qe);
users.clear();
ut.index(0).keyValue(0).read(users, q.
all());
sort(users, &user::name, &user::id);
m.clear();
ut.index(0).keyValue(0).read(m, q);
sort(m, &user::name, &user::id);
std::sort(begin(m), end(m), &sortFunc2);
std::cout << "--- vector for each ---" << std::endl;
std::for_each(users.begin(), users.end(), dumpUser<user_ptr&>);
std::cout << "--- original collection for each ---" << std::endl;
std::for_each(begin(m), end(m), dumpUser<user*>);
tb->clearOwnerName();
}
#pragma argsused
int _tmain(int argc, _TCHAR* argv[])
{
try
{
_T("test"));
bool newConnection = false;
std::vector<user_ptr> users;
readUsers(mgr, users);
std::cout << "Read records success.\nRecord count = " << users.size()
<< std::endl;
return 0;
}
catch (bzs::rtl::exception& e)
{
std::tcout << _T("[ERROR] ") << *bzs::rtl::getMsg(e) << std::endl;
}
return 1;
}