transactd 1.2.0 → 2.0.0

data/source/bzs/db/protocol/tdap/client/trdormapi.h

@@ -1,5 +1,5 @@
-#ifndef trdormapiH
-#define trdormapiH
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_TRDORMAPI_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_TRDORMAPI_H
 /*=================================================================
    Copyright (C) 2013 BizStation Corp All rights reserved.
 
@@ -14,16 +14,16 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software 
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
    02111-1307, USA.
 =================================================================*/
-#include <bzs/db/protocol/tdap/client/trdboostapi.h>
-#include <iostream>
+#include "trdboostapi.h"
+#include "fieldNameAlias.h"
+#include "memRecord.h"
+#include "groupComp.h"
+#include <boost/shared_array.hpp>
 #include <vector>
-#include <tstring.h>
-#include <boost/noncopyable.hpp>
-#include <boost/lexical_cast.hpp>
 
 namespace bzs
 {
@@ -36,242 +36,109 @@ namespace tdap
 namespace client
 {
 
-class logic
-{
-    std::_tstring m_name;
-	std::_tstring m_value;
-	std::_tstring m_type;
-	combineType m_next;
+/** @cond INTERNAL */
+template <class Container>
+typename Container::key_type resolvKeyValue(Container& m,
+                                            const std::_tstring& name,
+                                            bool noexception = false);
 
-public:
+template <class Container> typename Container::iterator begin(Container& m);
 
-	logic(const _TCHAR* name, const _TCHAR* type, const _TCHAR* value, combineType next)
-		:m_name(name),m_type(type),m_value(value),m_next(next){}
-	logic(const _TCHAR* name, const _TCHAR* type, int value, combineType next)
-		:m_name(name),m_type(type),m_next(next)
-		{
-			_TCHAR buf[50];
-			m_value = _ltot(value, buf, 10);
-		}
-	logic(const _TCHAR* name, const _TCHAR* type, __int64 value, combineType next)
-		:m_name(name),m_type(type),m_next(next)
-		{
-			_TCHAR buf[50];
-			m_value = _i64tot(value, buf, 10);
-		}
-	logic(const _TCHAR* name, const _TCHAR* type, double value, combineType next)
-		:m_name(name),m_type(type),m_next(next)
-		{
-			_TCHAR buf[50];
-			_stprintf(buf, _T("%.*f"),15, value);
-			m_value = buf;
-		}
-};
+template <class Container> typename Container::iterator end(Container& m);
 
-class databaseManager : boost::noncopyable
-{
-    database* m_db;
-    database_ptr m_dbPtr;
-    std::vector<table_ptr> m_tables;
-    int findTable(const _TCHAR* name)
-    {
-        for (int i=0;i<(int)m_tables.size();++i)
-            if (_tcscmp(m_tables[i]->tableDef()->tableName(), name)==0)
-                return i;
-        return -1;
-    }
-public:
-    databaseManager(database_ptr db):m_dbPtr(db),m_db(db.get()){};
-    databaseManager(database* db):m_db(db){};
-    table_ptr table(const _TCHAR* name)
-    {
-        int index =  findTable(name);
-        if (index !=-1)
-            return  m_tables[index];
-        table_ptr t = openTable(m_db, name);
-        m_tables.push_back(t);
-        return t;
-    }
-    database* db(){return m_db;}
+template <class Container> void clear(Container& m);
 
-};
+template <class Container>
+void push_back(Container& m, typename Container::row_type c);
+
+template <class ROW_TYPE, class KEY_TYPE, class T>
+void setValue(ROW_TYPE& row, KEY_TYPE key, const T& value);
+/** @endcond */
+
+/** @cond INTERNAL */
 
-class query : public queryBase
+template <class T>
+inline typename std::vector<T>::iterator begin(std::vector<T>& m)
 {
-public:
-	query():queryBase(){}
+    return m.begin();
+}
 
-    query& select(const TCHAR* name, const TCHAR* name1=NULL, const TCHAR* name2=NULL, const TCHAR* name3=NULL
-                ,const TCHAR* name4=NULL, const TCHAR* name5=NULL, const TCHAR* name6=NULL, const TCHAR* name7=NULL
-                ,const TCHAR* name8=NULL, const TCHAR* name9=NULL, const TCHAR* name10=NULL)
-    {
-        if (_tcscmp(name, _T("*"))==0)
-        {
-            clearSelectFields();
-            return *this;
-        }
-        addField(name);
-        if (name1) addField(name1);
-        if (name2) addField(name2);
-        if (name3) addField(name3);
-        if (name4) addField(name4);
-        if (name5) addField(name5);
-        if (name6) addField(name6);
-        if (name7) addField(name7);
-        if (name8) addField(name8);
-        if (name9) addField(name9);
-        if (name10) addField(name10);
-        return *this;
-    }
+template <class T>
+inline typename std::vector<T>::iterator end(std::vector<T>& m)
+{
+    return m.end();
+}
 
-    template <class T>
-	query& where(const _TCHAR* name, const _TCHAR* logic, T value)
-	{
-        addLogic(name, logic, boost::lexical_cast<std::_tstring>(value).c_str());
-		return *this;
-	}
+template <class T> inline void push_back(std::vector<T>& m, T c)
+{
+    return m.push_back(c);
+}
 
-    template <class T>
-	query& and(const _TCHAR* name, const _TCHAR* type, T value)
-	{
-        if (m_wheres.size() == 0)
-            throw bzs::rtl::exception(STATUS_FILTERSTRING_ERROR, _T("Invalid function call."));
+#if (_MSC_VER || (__BCPLUSPLUS__ && !defined(__clang__)))
 
-        addLogic(_T("and"), name, logic, boost::lexical_cast<std::_tstring>(value).c_str());
- 		return *this;
-	}
+/* Container has readBefore(table_ptr, alias) function*/
+template <class Container>
+inline void readBefore(Container& mdls, table_ptr tb,
+                       const aliasMap_type* alias,
+                       typename Container::header_type* dummy = 0)
+{
+    mdls.readBefore(tb, alias);
+}
 
-	template <class T>
-    query& or(const _TCHAR* name, const _TCHAR* type, T value)
-	{
-        if (m_wheres.size() == 0)
-            throw bzs::rtl::exception(STATUS_FILTERSTRING_ERROR, _T("Invalid function call."));
+/* Container has'nt readBefore(table_ptr, alias) function*/
+template <class Container> inline void readBefore(...){};
 
-        addLogic(_T("or"), name, logic, boost::lexical_cast<std::_tstring>(value).c_str());
-		return *this;
-	}
+#else
 
-    template <class T>
-    query& in(const _TCHAR* name, const _TCHAR* type, T value)
-	{
-        if (m_wheres.size() == 0)
-            throw bzs::rtl::exception(STATUS_FILTERSTRING_ERROR, _T("Invalid function call."));
-
-        addLogic(_T("or"), name, logic, boost::lexical_cast<std::_tstring>(value).c_str());
-		return *this;
-	}
-
-    template <class T0, class T1 , class T2, class T3
-                ,class T4, class T5 , class T6 , class T7>
-	query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-                            ,const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
-	{
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv0).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv1).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv2).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv3).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv4).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv5).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv6).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv7).c_str());
-        return *this;
-	}
-    template <class T0, class T1 , class T2, class T3
-                ,class T4, class T5 , class T6>
-	query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-                            ,const T4 kv4, const T5 kv5, const T6 kv6)
-	{
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv0).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv1).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv2).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv3).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv4).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv5).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv6).c_str());
-        return *this;
-	}
-
-    template <class T0, class T1 , class T2, class T3
-                ,class T4, class T5>
-	query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-                            ,const T4 kv4, const T5 kv5)
-	{
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv0).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv1).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv2).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv3).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv4).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv5).c_str());
-        return *this;
-	}
-
-    template <class T0, class T1 , class T2, class T3, class T4>
-	query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3, const T4 kv4)
-	{
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv0).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv1).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv2).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv3).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv4).c_str());
-        return *this;
-	}
-
-    template <class T0, class T1 , class T2, class T3>
-	query& in(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3)
-	{
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv0).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv1).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv2).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv3).c_str());
-        return *this;
-	}
-
-    template <class T0, class T1 , class T2>
-	query& in(const T0 kv0, const T1 kv1, const T2 kv2)
-	{
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv0).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv1).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv2).c_str());
-        return *this;
-	}
+template <class Container>
+void push_back(Container& m, typename Container::item_type c);
 
-    template <class T0, class T1>
-	query& in(const T0 kv0, const T1 kv1)
-	{
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv0).c_str());
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv1).c_str());
-        return *this;
-	}
+template <class T> class has_header
+{
+    typedef char yes;
+    typedef struct
+    {
+        char foo[2];
+    } no;
 
-    template <class T0>
-	query& in(const T0 kv0)
-	{
-        addSeekKeyValue(boost::lexical_cast<std::_tstring>(kv0).c_str());
-        return *this;
-	}
+    template <class C> static yes test(typename C::header_type*);
 
-};
+    template <class C> static no test(...);
 
+public:
+#ifdef SWIG
+    static const bool value;
+#else
+    static const bool value = sizeof(test<T>(0)) == sizeof(char);
+#endif
+};
 
-template <class T>
-inline std::vector<T>::iterator begin(std::vector<T>& m){return m.begin();}
+/* Container has readBefore(table_ptr, alias) function*/
+template <class Container>
+inline void
+readBefore(Container& mdls, table_ptr tb, const aliasMap_type* alias,
+           typename boost::enable_if<has_header<Container> >::type* = 0)
 
-template <class T>
-inline std::vector<T>::iterator end(std::vector<T>& m){return m.end();}
+{
+    mdls.readBefore(tb, alias);
+}
 
-template <class T>
-inline void push_back(std::vector<T>& m, T c){return m.push_back(c);}
+/* Container has'nt readBefore(table_ptr, alias) function*/
+template <class Container>
+inline void
+readBefore(Container& mdls, table_ptr tb, const aliasMap_type* alias,
+           typename boost::disable_if<has_header<Container> >::type* = 0)
+{
+}
+#endif
 
 /* Container operation handlter
 
 */
-template <class MAP
-            , class Container
-            , class T=MAP::mdl_typename
-            , class FDI=MAP::fdi_typename>
+template <class MAP, class Container, class T = typename MAP::mdl_typename,
+          class FDI = typename MAP::fdi_typename>
 class mdlsHandler
 {
-    typedef std::vector<boost::shared_ptr<typename T> > collection_vec_type;
     mdlsHandler();
 
 protected:
@@ -281,29 +148,29 @@ protected:
     MAP* m_map;
 
     template <class mdls_type>
-    void addContainer(T* u, typename mdls_type::item_type* p )
+    void addContainer(T* u, typename mdls_type::item_type* p)
     {
-        mdls_type::item_type ptr(u);
+        typename mdls_type::item_type ptr(u);
         push_back(m_mdls, ptr);
     }
 
-    template <class mdls_type>
-    void addContainer(T* u, ...)
+    template <class mdls_type> void addContainer(T* u, ...)
     {
         push_back(m_mdls, boost::shared_ptr<T>(u));
     }
 
-
 public:
-    mdlsHandler(Container& mdls):m_mdls(mdls){}
+    mdlsHandler(Container& mdls) : m_mdls(mdls) {}
 
     virtual ~mdlsHandler(){};
 
-    void init(int option, FDI* fdi, MAP& map)
+    void init(int option, FDI* fdi, MAP& map, table_ptr tb,
+              const aliasMap_type* alias = NULL)
     {
         m_option = option;
         m_fdi = fdi;
         m_map = &map;
+        readBefore<Container>(m_mdls, tb, alias);
     }
 
     void operator()(const fields& fds)
@@ -312,18 +179,17 @@ public:
         m_map->readMap(*u, fds, m_option);
         addContainer<Container>(u, 0);
     }
-
 };
 
 /* For sort in readEach
 */
-template <class MAP, class T>
-class compFunc
+template <class MAP, class T> class compFunc
 {
     MAP& m_map;
     int m_keynum;
+
 public:
-    compFunc(MAP& map, int keynum):m_map(map),m_keynum(keynum){}
+    compFunc(MAP& map, int keynum) : m_map(map), m_keynum(keynum) {}
     bool operator()(T* l, T* r) const
     {
         return m_map.compKeyValue(*l, *r, m_keynum);
@@ -335,9 +201,8 @@ public:
     }
 };
 
-
 template <class T, class RET>
-bool sortFuncBase(T&l, T& r , RET (T::*func1)() const)
+bool sortFuncBase(const T& l, const T& r, RET (T::*func1)() const)
 {
     RET retl = (l.*func1)();
     RET retr = (r.*func1)();
@@ -345,51 +210,57 @@ bool sortFuncBase(T&l, T& r , RET (T::*func1)() const)
 }
 
 template <class T, class FUNC1, class FUNC2, class FUNC3>
-bool sortFunc(T&l, T& r , FUNC1 func1, FUNC2 func2, FUNC3 func3)
+bool sortFunc(const T& l, const T& r, FUNC1 func1, FUNC2 func2, FUNC3 func3)
 {
     bool v = sortFuncBase(l, r, func1);
     if (func2)
     {
-        if (v) return v;
+        if (v)
+            return v;
         v = sortFuncBase(r, l, func1);
-        if (v) return !v;
+        if (v)
+            return !v;
         v = sortFuncBase(l, r, func2);
         if (func3)
         {
-            if (v) return v;
+            if (v)
+                return v;
             v = sortFuncBase(r, l, func2);
-            if (v) return !v;
+            if (v)
+                return !v;
             v = sortFuncBase(l, r, func3);
         }
     }
     return v;
 }
 
-template <class FUNC1, class FUNC2, class FUNC3>
-class sortFunctor
+template <class FUNC1, class FUNC2, class FUNC3> class sortFunctor
 {
     FUNC1 m_func1;
     FUNC2 m_func2;
     FUNC3 m_func3;
+
 public:
     sortFunctor(FUNC1 func1, FUNC2 func2, FUNC3 func3)
-        :m_func1(func1),m_func2(func2), m_func3(func3){}
-    template <class T>
-    bool operator()(T* l, T* r) const
+        : m_func1(func1), m_func2(func2), m_func3(func3)
+    {
+    }
+    template <class T> bool operator()(const T* l, const T* r) const
     {
         return sortFunc(*l, *r, m_func1, m_func2, m_func2);
     }
 
     template <class T>
-    bool operator()(boost::shared_ptr<T>& l, boost::shared_ptr<T>& r) const
+    bool operator()(const boost::shared_ptr<T>& l,
+                    const boost::shared_ptr<T>& r) const
     {
-        bool v =  sortFunc(*l, *r, m_func1, m_func2, m_func2);
+        bool v = sortFunc(*l, *r, m_func1, m_func2, m_func2);
         return v;
     }
 };
 
 template <class Container, class FUNC1, class FUNC2, class FUNC3>
-void sort(Container& mdls, FUNC1 func1, FUNC2 func2, FUNC3 func3 )
+void sort(Container& mdls, FUNC1 func1, FUNC2 func2, FUNC3 func3)
 {
     sortFunctor<FUNC1, FUNC2, FUNC3> functor(func1, func2, func3);
     std::sort(begin(mdls), end(mdls), functor);
@@ -402,266 +273,311 @@ void sort(Container& mdls, FUNC1 func1, FUNC2 func2)
     std::sort(begin(mdls), end(mdls), functor);
 }
 
-template <class Container, class FUNC1>
-void sort(Container& mdls, FUNC1 func1)
+template <class Container, class FUNC1> void sort(Container& mdls, FUNC1 func1)
 {
     sortFunctor<FUNC1, FUNC1, FUNC1> functor(func1, NULL, NULL);
     std::sort(begin(mdls), end(mdls), functor);
 }
 
 template <class T2, class T, class Container>
-inline boost::shared_ptr<std::vector<T> > listup(Container& mdls, T (T2::*func)()const)
+inline boost::shared_ptr<std::vector<T> > listup(Container& mdls,
+                                                 T (T2::*func)() const)
 {
     typename Container::iterator it = begin(mdls), ite = end(mdls);
 
-	boost::shared_ptr<std::vector<T> > mdlst( new std::vector<T>());
-    while(it != ite)
+    boost::shared_ptr<std::vector<T> > mdlst(new std::vector<T>());
+    while (it != ite)
     {
         T2& mdl = *(*it);
         T ref = (mdl.*func)();
         mdlst->push_back(ref);
         ++it;
     }
-	return mdlst;
+    return mdlst;
 }
 
-template <class MAP, class T=MAP::mdl_typename, class FDI=MAP::fdi_typename>
-class activeTable : boost::noncopyable
+class mraResetter
 {
-    typedef std::vector<boost::shared_ptr<T> > collection_vec_type;
+    table_ptr& m_tb;
+
+public:
+    mraResetter(table_ptr& tb) : m_tb(tb) {}
+
+    ~mraResetter()
+    {
+        if (m_tb->mra())
+            m_tb->mra()->setJoinType(mra_nojoin);
+        m_tb->setMra(NULL);
+    }
+};
+
+/** @endcond */
+
+template <class MAP, class T = typename MAP::mdl_typename,
+          class FDI = typename MAP::fdi_typename>
+class activeObject : boost::noncopyable
+{
+    void init(idatabaseManager* mgr, const _TCHAR* name)
+    {
+        m_tb = mgr->table(name);
+    }
+
+    void init(database_ptr& db, const _TCHAR* name)
+    {
+        m_tb = openTable(db, name);
+    }
+
+    void init(database* db, const _TCHAR* name) { m_tb = openTable(db, name); }
+
+protected:
     table_ptr m_tb;
     FDI* m_fdi;
     MAP m_map;
     int m_option;
-    bool m_useTransactd;
+    fdNmaeAlias m_alias;
 
-    inline size_t size(collection_vec_type& mdls){return mdls.size();}
-    inline T& getItem(collection_vec_type& mdls, unsigned int index){return *(mdls[index]);}
-    void init(databaseManager& mgr, const _TCHAR* name)
-	{
-        m_tb = mgr.table(name);
-	}
+public:
+    typedef std::vector<boost::shared_ptr<T> > collection_vec_type;
 
-    void init(database_ptr& db, const _TCHAR* name)
+    explicit activeObject(idatabaseManager* mgr)
+        : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
     {
-        m_tb = openTable(db, name);
+        init(mgr, m_map.getTableName());
+        if (table() && m_fdi)
+            initFdi(m_fdi, m_tb.get());
     }
 
-    void init(database* db, const _TCHAR* name)
+    explicit activeObject(database_ptr& db)
+        : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
     {
-        m_tb = openTable(db, name);
+        init(db, m_map.getTableName());
+        if (table() && m_fdi)
+            initFdi(m_fdi, m_tb.get());
     }
 
-public:
+    explicit activeObject(idatabaseManager* mgr, const _TCHAR* tableName)
+        : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
+    {
+        init(mgr, tableName);
+        if (table() && m_fdi)
+            initFdi(m_fdi, m_tb.get());
+    }
 
-    activeTable(databaseManager& mgr)
+    /*explicit activeObject(dbmanager_ptr& mgr, const _TCHAR* tableName)
             :m_option(0)
             ,m_fdi(createFdi(m_fdi))
             ,m_map(*m_fdi)
-            ,m_useTransactd(mgr.db()->isUseTransactd())
             {
-                init(mgr, m_map.getTableName());
-                if (table() && m_fdi)
-                    initFdi(m_fdi, m_tb.get());
+                    init(mgr, tableName);
+                    if (table() && m_fdi)
+                            initFdi(m_fdi, m_tb.get());
             }
+     */
 
-    activeTable(database_ptr& db)
-            :m_option(0)
-            ,m_fdi(createFdi(m_fdi))
-            ,m_map(*m_fdi)
-            ,m_useTransactd(db->isUseTransactd())
-            {
-                init(db, m_map.getTableName());
-                if (table() && m_fdi)
-                    initFdi(m_fdi, m_tb.get());
-            }
+    explicit activeObject(database_ptr& db, const _TCHAR* tableName)
+        : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
+    {
+        init(db, tableName);
+        if (table() && m_fdi)
+            initFdi(m_fdi, m_tb.get());
+    }
 
-    ~activeTable(){destroyFdi(m_fdi);}
+    explicit activeObject(database* db, const _TCHAR* tableName)
+        : m_fdi(createFdi((FDI*)0)), m_map(*m_fdi), m_option(0)
+    {
+        init(db, tableName);
+        if (table() && m_fdi)
+            initFdi(m_fdi, m_tb.get());
+    }
 
-    inline void beginBulkInsert(int maxBuflen){m_tb->beginBulkInsert(maxBuflen);}
-    inline void abortBulkInsert(){m_tb->abortBulkInsert();}
-    inline ushort_td commitBulkInsert() {m_tb->commitBulkInsert();}
+    ~activeObject() { destroyFdi(m_fdi); }
 
-    activeTable& index(int v)
+    activeObject& index(int v)
     {
         m_tb->clearBuffer();
         m_tb->setKeyNum(v);
         return *this;
     }
 
-    template <class T0>
-	activeTable& keyValue(const T0 kv0)
-	{
+    /** @cond INTERNAL */
+
+    template <class T0> activeObject& keyValue(const T0 kv0)
+    {
         keyValueSetter<T0>::set(m_tb, m_tb->keyNum(), kv0);
         return *this;
-	}
+    }
 
     template <class T0, class T1>
-	activeTable& keyValue(const T0 kv0, const T1 kv1)
-	{
+    activeObject& keyValue(const T0 kv0, const T1 kv1)
+    {
         keyValueSetter<T0, T1>::set(m_tb, m_tb->keyNum(), kv0, kv1);
         return *this;
-	}
+    }
 
-    template <class T0, class T1 , class T2>
-	activeTable& keyValue(const T0 kv0, const T1 kv1, const T2 kv2)
-	{
+    template <class T0, class T1, class T2>
+    activeObject& keyValue(const T0 kv0, const T1 kv1, const T2 kv2)
+    {
         keyValueSetter<T0, T1, T2>::set(m_tb, m_tb->keyNum(), kv0, kv1, kv2);
         return *this;
-	}
+    }
 
-    template <class T0, class T1 , class T2, class T3>
-	activeTable& keyValue(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3)
-	{
-        keyValueSetter<T0, T1, T2, T3>::set(m_tb, m_tb->keyNum(), kv0, kv1, kv2, kv3);
+    template <class T0, class T1, class T2, class T3>
+    activeObject& keyValue(const T0 kv0, const T1 kv1, const T2 kv2,
+                           const T3 kv3)
+    {
+        keyValueSetter<T0, T1, T2, T3>::set(m_tb, m_tb->keyNum(), kv0, kv1, kv2,
+                                            kv3);
         return *this;
-	}
-
-    template <class T0, class T1 , class T2, class T3, class T4>
-	activeTable& keyValue(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-                            ,const T4 kv4)
-	{
-        keyValueSetter<T0, T1, T2, T3, T4>
-                ::set(m_tb, m_tb->keyNum(), kv0, kv1, kv2, kv3, kv4);
+    }
+
+    template <class T0, class T1, class T2, class T3, class T4>
+    activeObject& keyValue(const T0 kv0, const T1 kv1, const T2 kv2,
+                           const T3 kv3, const T4 kv4)
+    {
+        keyValueSetter<T0, T1, T2, T3, T4>::set(m_tb, m_tb->keyNum(), kv0, kv1,
+                                                kv2, kv3, kv4);
         return *this;
-	}
-
-    template <class T0, class T1 , class T2, class T3, class T4, class T5 >
-	activeTable& keyValue(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-                            ,const T4 kv4, const T5 kv5)
-	{
-        keyValueSetter<T0, T1, T2, T3, T4, T5>
-                ::set(m_tb, m_tb->keyNum(), kv0, kv1, kv2, kv3, kv4, kv5);
+    }
+
+    template <class T0, class T1, class T2, class T3, class T4, class T5>
+    activeObject& keyValue(const T0 kv0, const T1 kv1, const T2 kv2,
+                           const T3 kv3, const T4 kv4, const T5 kv5)
+    {
+        keyValueSetter<T0, T1, T2, T3, T4, T5>::set(m_tb, m_tb->keyNum(), kv0,
+                                                    kv1, kv2, kv3, kv4, kv5);
         return *this;
-	}
-
-    template <class T0, class T1 , class T2, class T3, class T4, class T5 , class T6>
-	activeTable& keyValue(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-                            ,const T4 kv4, const T5 kv5, const T6 kv6)
-	{
-        keyValueSetter<T0, T1, T2, T3, T4, T5, T6>
-                ::set(m_tb, m_tb->keyNum(), kv0, kv1, kv2, kv3, kv4, kv5, kv6);
+    }
+
+    template <class T0, class T1, class T2, class T3, class T4, class T5,
+              class T6>
+    activeObject& keyValue(const T0 kv0, const T1 kv1, const T2 kv2,
+                           const T3 kv3, const T4 kv4, const T5 kv5,
+                           const T6 kv6)
+    {
+        keyValueSetter<T0, T1, T2, T3, T4, T5, T6>::set(
+            m_tb, m_tb->keyNum(), kv0, kv1, kv2, kv3, kv4, kv5, kv6);
         return *this;
-	}
-
-    template <class T0, class T1 , class T2, class T3
-                ,class T4, class T5 , class T6 , class T7>
-	activeTable& keyValue(const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-                            ,const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
-	{
-        keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>
-                ::set(m_tb, m_tb->keyNum(), kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
+    }
+
+    /** @endcond */
+
+    template <class T0, class T1, class T2, class T3, class T4, class T5,
+              class T6, class T7>
+    activeObject& keyValue(const T0 kv0, const T1 kv1, const T2 kv2,
+                           const T3 kv3, const T4 kv4, const T5 kv5,
+                           const T6 kv6, const T7 kv7)
+    {
+        keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>::set(
+            m_tb, m_tb->keyNum(), kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
         return *this;
-	}
+    }
 
-    inline table_ptr table() const {return m_tb;};
+    inline table_ptr table() const { return m_tb; };
 
-    activeTable& option(int v)
+    activeObject& option(int v)
     {
         m_option = v;
         return *this;
     }
 
     template <class Any_Map_type>
-    void readRange(Any_Map_type& map, queryBase& q)
+    activeObject& readMap(Any_Map_type& map, queryBase& q)
     {
-        map.init(m_option, m_fdi, m_map);
+        mraResetter mras(m_tb);
+        m_alias.reverseAliasNamesQuery(q);
         m_tb->setQuery(&q);
         if (m_tb->stat())
             nstable::throwError(_T("Query is inaccurate"), &(*m_tb));
 
+        map.init(m_option, m_fdi, m_map, m_tb, &m_alias);
         m_tb->find(q.getDirection());
         if (q.getDirection() == table::findForword)
         {
             findIterator itsf(*m_tb);
             for_each(itsf, map);
-        }else
+        }
+        else
         {
             findRvIterator itsf(*m_tb);
             for_each(itsf, map);
         }
+        return *this;
     }
 
-
     template <class Any_Map_type>
-    void readRange(Any_Map_type& map, queryBase& q, validationFunc func)
+    activeObject& readMap(Any_Map_type& map, queryBase& q, validationFunc func)
     {
-        map.init(m_option, m_fdi, m_map);
+        mraResetter mras(m_tb);
+        m_alias.reverseAliasNamesQuery(q);
+
         m_tb->setQuery(&q);
         if (m_tb->stat())
             nstable::throwError(_T("Query is inaccurate"), &(*m_tb));
+        map.init(m_option, m_fdi, m_map, m_tb, &m_alias);
         m_tb->find(q.getDirection());
         if (q.getDirection() == table::findForword)
         {
             findIterator itsf(*m_tb);
             filterdFindIterator it(itsf, func);
             for_each(it, map);
-        }else
+        }
+        else
         {
             findRvIterator itsf(*m_tb);
             filterdFindRvIterator it(itsf, func);
             for_each(it, map);
         }
+        return *this;
     }
 
-    void read(collection_vec_type& mdls, queryBase& q, validationFunc func)
+    activeObject& read(collection_vec_type& mdls, queryBase& q,
+                       validationFunc func)
     {
         mdlsHandler<MAP, collection_vec_type> map(mdls);
-        readRange(map, q, func);
+        return readMap(map, q, func);
     }
 
-    void read(collection_vec_type& mdls, queryBase& q)
+    activeObject& read(collection_vec_type& mdls, queryBase& q)
     {
         mdlsHandler<MAP, collection_vec_type> map(mdls);
-        readRange(map, q);
+        return readMap(map, q);
     }
 
-    template <class Container>
-    void read(Container& mdls, queryBase& q)
+    template <class Container> activeObject& read(Container& mdls, queryBase& q)
     {
         typename MAP::collection_orm_typename map(mdls);
-        readRange(map, q);
+        return readMap(map, q);
     }
 
     template <class Container>
-    void read(Container& mdls, queryBase& q, validationFunc func)
+    activeObject& read(Container& mdls, queryBase& q, validationFunc func)
     {
         typename MAP::collection_orm_typename map(mdls);
-        readRange(map, q, func);
+        return readMap(map, q, func);
     }
 
-    void read(T& mdl, bool setKeyValueFromObj=true)
+    template <class T2> void read(T2& mdl, bool setKeyValueFromObj = true)
     {
         fields fds(m_tb);
         if (setKeyValueFromObj)
             m_map.setKeyValues(mdl, fds, m_tb->keyNum());
         indexIterator it = readIndex(m_tb, eSeekEqual);
         if (m_tb->stat() != 0)
-            nstable::throwError(_T("activeTable read"), &(*m_tb));
+            nstable::throwError(_T("activeObject read"), &(*m_tb));
         m_map.readMap(mdl, fds, m_option);
     }
 
-    void update(T& mdl, bool setKeyValueFromObj=true)
+    template <class T2> void update(T2& mdl, bool setKeyValueFromObj = true)
     {
         fields fds(m_tb);
         if (setKeyValueFromObj)
             m_map.setKeyValues(mdl, fds, m_tb->keyNum());
         indexIterator it = readIndex(m_tb, eSeekEqual);
         if (m_tb->stat() != 0)
-            nstable::throwError(_T("activeTable update"), &(*m_tb));
+            nstable::throwError(_T("activeObject update"), &(*m_tb));
 
         m_map.writeMap(mdl, fds, m_option);
         updateRecord(it);
-
-    }
-
-    template <class Container>
-    void update(Container& mdls)
-    {
-        typename Container::iterator it = begin(mdls),ite = end(mdls);
-        while (it != ite)
-            update(*it);
-
     }
 
     // No need object
@@ -669,27 +585,22 @@ public:
     {
         readIndex(m_tb, eSeekEqual);
         if (m_tb->stat() != 0)
-            nstable::throwError(_T("activeTable delete"), &(*m_tb));
+            nstable::throwError(_T("activeObject delete"), &(*m_tb));
         m_tb->del();
+        if (m_tb->stat() != 0)
+            nstable::throwError(_T("activeObject delete"), &(*m_tb));
     }
 
-    //Recieve delete record by mdl
-    void del(T& mdl, bool setKeyValueFromObj=true)
+    // Recieve delete record by mdl
+    template <class T2> void del(T2& mdl, bool setKeyValueFromObj = true)
     {
         read(mdl, setKeyValueFromObj);
         m_tb->del();
+        if (m_tb->stat() != 0)
+            nstable::throwError(_T("activeObject delete"), &(*m_tb));
     }
 
-    template <class Container>
-    void del(Container& mdls)
-    {
-        typename Container::iterator it = begin(mdls),ite = end(mdls);
-        while (it != ite)
-            del(*it);
-
-    }
-
-    void insert(T& mdl)
+    template <class T2> void insert(T2& mdl)
     {
         fields fds(m_tb);
         m_map.writeMap(mdl, fds, m_option);
@@ -697,16 +608,7 @@ public:
         m_map.readAuntoincValue(mdl, fds, m_option);
     }
 
-    template <class Container>
-    void insert(Container& mdls)
-    {
-        typename Container::iterator it = begin(mdls),ite = end(mdls);
-        while (it != ite)
-            insert(*it);
-
-    }
-
-    void save(T& mdl, bool setKeyValueFromObj=true)
+    template <class T2> void save(T2& mdl, bool setKeyValueFromObj = true)
     {
         fields fds(m_tb);
         if (setKeyValueFromObj)
@@ -721,31 +623,56 @@ public:
         }
     }
 
-    /* mdls���L�[�t�B�[���h�ɑΉ����郁���o�ɂ���ă\�[�g�ς̎���
-       sorted��true�ɂ��܂��B�������郌�R�[�h�ƒʐM�ʂ��������܂��B
-    */
+#ifdef USE_CONTAINER_CUD // default not support
+
+    template <class Container> void update(Container& mdls)
+    {
+        typename Container::iterator it = begin(mdls), ite = end(mdls);
+        while (it != ite)
+            update(*it);
+    }
+
+    template <class Container> void del(Container& mdls)
+    {
+        typename Container::iterator it = begin(mdls), ite = end(mdls);
+        while (it != ite)
+            del(*it);
+    }
+
+    template <class Container> void insert(Container& mdls)
+    {
+        typename Container::iterator it = begin(mdls), ite = end(mdls);
+        while (it != ite)
+            insert(*it);
+    }
+
+#endif
+
     template <class Container>
-    void readEach(Container& mdls, queryBase& q, bool sorted=false, bzs::rtl::exception* e=NULL)
+    void readEach(Container& mdls, queryBase& q, bool sorted = false,
+                  bzs::rtl::exception * e = NULL)
     {
-        q.clearSeekKeyValues();
+        mraResetter mras(m_tb);
+        m_alias.reverseAliasNamesQuery(q);
         fields fds(m_tb);
-        typename Container::iterator it = begin(mdls),itb = begin(mdls),ite = end(mdls);
+        typename Container::iterator it = begin(mdls), itb = begin(mdls),
+                                     ite = end(mdls);
         it = itb = begin(mdls);
         T& mdlb = *(*it);
-        if (!m_useTransactd)
-            nstable::throwError(_T("activeTable P.SQL can not use this"), (short_td)0);
-        while(it != ite)
+        if (!m_tb->isUseTransactd())
+            nstable::throwError(_T("activeObject P.SQL can not use this"),
+                                (short_td)0);
+        while (it != ite)
         {
-            //if mdl has same key value, to be once read access to server
+            // if mdl has same key value, to be once read access to server
             T& mdl = *(*it);
-            if ((it == itb)
-                    || !sorted
-                    || (m_map.compKeyValue(mdl, mdlb, m_tb->keyNum())==true)
-                    || (m_map.compKeyValue(mdlb, mdl, m_tb->keyNum())==true))
+            if ((it == itb) || !sorted ||
+                (m_map.compKeyValue(mdl, mdlb, m_tb->keyNum()) == true) ||
+                (m_map.compKeyValue(mdlb, mdl, m_tb->keyNum()) == true))
             {
                 m_map.setKeyValues(mdl, fds, m_tb->keyNum());
                 keydef* kd = &m_tb->tableDef()->keyDefs[m_tb->keyNum()];
-                for (int i=0;i<kd->segmentCount;++i)
+                for (int i = 0; i < kd->segmentCount; ++i)
                     q.addSeekKeyValue(fds[kd->segments[i].fieldNum].c_str());
             }
             mdlb = mdl;
@@ -753,20 +680,20 @@ public:
         }
         m_tb->setQuery(&q);
         if (m_tb->stat() != 0)
-            nstable::throwError(_T("activeTable readEach Query"), &(*m_tb));
+            nstable::throwError(_T("activeObject readEach Query"), &(*m_tb));
         m_tb->find();
-        //���‚���Ȃ����R�[�h������ƁA���̎��_�ŃG���[�ŕԂ�
-        //�s���ƂɃG���[���ǂ����킩���������悢�B
+
         it = itb = begin(mdls);
-        while(it != ite)
+        while (it != ite)
         {
-            if (m_tb->stat() != 0)
-                nstable::throwError(_T("activeTable readEach"), &(*m_tb));
+            if ((m_tb->stat() != STATUS_SUCCESS) &&
+                (m_tb->stat() != STATUS_NOT_FOUND_TI))
+                nstable::throwError(_T("activeObject readEach"), &(*m_tb));
             T& mdl = *(*it);
             if ((it != itb) &&
-                (!sorted
-                    || (m_map.compKeyValue(mdl, mdlb, m_tb->keyNum())==true)
-                    || (m_map.compKeyValue(mdlb, mdl, m_tb->keyNum())==true)))
+                (!sorted ||
+                 (m_map.compKeyValue(mdl, mdlb, m_tb->keyNum()) == true) ||
+                 (m_map.compKeyValue(mdlb, mdl, m_tb->keyNum()) == true)))
             {
                 m_tb->findNext();
                 if (m_tb->stat() != 0)
@@ -774,11 +701,11 @@ public:
                     _TCHAR buf[8192];
                     m_tb->keyValueDescription(buf, 8192);
                     if (e)
-                        *e << bzs::rtl::errnoCode(m_tb->stat()) << bzs::rtl::errMessage(buf);
+                        *e << bzs::rtl::errnoCode(m_tb->stat())
+                           << bzs::rtl::errMessage(buf);
                     else
                         THROW_BZS_ERROR_WITH_CODEMSG(m_tb->stat(), buf);
                 }
-
             }
             if (m_tb->stat() == 0)
                 m_map.readMap(mdl, fds, m_option);
@@ -787,10 +714,8 @@ public:
         }
     }
 
-    /** Join�����̏��������O�\�[�g���č����ɍs���܂��B
-    */
     template <class BaseContainer, class T2>
-    void readEach(BaseContainer& mdls, T* (T2::*func)()const, queryBase& q)
+    void readEach(BaseContainer& mdls, T* (T2::*func)() const, queryBase& q)
     {
         boost::shared_ptr<std::vector<T*> > refList(listup(mdls, func));
         compFunc<MAP, T> comp(m_map, m_tb->keyNum());
@@ -799,7 +724,8 @@ public:
     }
 
     template <class BaseContainer, class T2>
-    void readEach(BaseContainer& mdls, T* (T2::*func)()const, queryBase& q, bzs::rtl::exception& e)
+    void readEach(BaseContainer& mdls, T* (T2::*func)() const, queryBase& q,
+                  bzs::rtl::exception& e)
     {
         boost::shared_ptr<std::vector<T*> > refList(listup(mdls, func));
         compFunc<MAP, T> comp(m_map, m_tb->keyNum());
@@ -809,19 +735,21 @@ public:
 
     /* No use field select */
     template <class Container>
-    void readEach(Container& mdls, bool sorted=false, bzs::rtl::exception* e=NULL)
+    void readEach(Container& mdls, bool sorted = false,
+                  bzs::rtl::exception * e = NULL)
     {
         fields fds(m_tb);
-        typename Container::iterator it = mdls.begin(),itb = mdls.begin(),ite = end(mdls);
+        mraResetter mras(m_tb);
+        typename Container::iterator it = begin(mdls), itb = begin(mdls),
+                                     ite = end(mdls);
         it = itb = begin(mdls);
         T& mdlb = *(*it);
-        while(it != ite)
+        while (it != ite)
         {
             T& mdl = *(*it);
-            if ((it == itb)
-                    || !sorted
-                    || (m_map.compKeyValue(mdl, mdlb, m_tb->keyNum())==true)
-                    || (m_map.compKeyValue(mdlb, mdl, m_tb->keyNum())==true))
+            if ((it == itb) || !sorted ||
+                (m_map.compKeyValue(mdl, mdlb, m_tb->keyNum()) == true) ||
+                (m_map.compKeyValue(mdlb, mdl, m_tb->keyNum()) == true))
             {
                 m_map.setKeyValues(mdl, fds, m_tb->keyNum());
                 readIndex(m_tb, eSeekEqual);
@@ -830,7 +758,8 @@ public:
                     _TCHAR buf[8192];
                     m_tb->keyValueDescription(buf, 8192);
                     if (e)
-                        *e << bzs::rtl::errnoCode(m_tb->stat()) << bzs::rtl::errMessage(buf);
+                        *e << bzs::rtl::errnoCode(m_tb->stat())
+                           << bzs::rtl::errMessage(buf);
                     else
                         THROW_BZS_ERROR_WITH_CODEMSG(m_tb->stat(), buf);
                 }
@@ -844,7 +773,7 @@ public:
 
     /* No use field select */
     template <class BaseContainer, class T2>
-    void readEach(BaseContainer& mdls, T* (T2::*func)()const)
+    void readEach(BaseContainer& mdls, T* (T2::*func)() const)
     {
         boost::shared_ptr<std::vector<T*> > refList(listup(mdls, func));
         compFunc<MAP, T> comp(m_map, m_tb->keyNum());
@@ -853,20 +782,32 @@ public:
     }
 
     template <class BaseContainer, class T2>
-    void readEach(BaseContainer& mdls, T* (T2::*func)()const , bzs::rtl::exception& e)
+    void readEach(BaseContainer& mdls, T* (T2::*func)() const,
+                  bzs::rtl::exception& e)
     {
         boost::shared_ptr<std::vector<T*> > refList(listup(mdls, func));
         compFunc<MAP, T> comp(m_map, m_tb->keyNum());
         std::sort(refList->begin(), refList->end(), comp);
         readEach(*refList, true, &e);
     }
-};
 
+    inline activeObject& alias(const _TCHAR* src, const _TCHAR* dst)
+    {
+        m_alias.set(src, dst);
+        return *this;
+    }
+
+    inline activeObject& resetAlias()
+    {
+        m_alias.clear();
+        return *this;
+    }
+};
 
-}// namespace client
-}// namespace tdap
-}// namespace protocol
-}// namespace db
-}// namespace bzs
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
 
-#endif//trdormapiH
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_TRDORMAPI_H