transactd 1.2.0 → 2.0.0

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

@@ -1,5 +1,5 @@
-#ifndef trdboostapiH
-#define trdboostapiH
+#ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_TRDBOOSTAPI_H
+#define BZS_DB_PROTOCOL_TDAP_CLIENT_TRDBOOSTAPI_H
 /*=================================================================
    Copyright (C) 2013 BizStation Corp All rights reserved.
 
@@ -14,22 +14,23 @@
    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/trdboostapiInternal.h>
+#include "trdboostapiInternal.h"
 #include <boost/shared_ptr.hpp>
 #include <boost/noncopyable.hpp>
+#include <iterator>
 
 #include <stdio.h>
 
-#if defined(__GNUC__) 
-	#if !__GNUC_PREREQ(4, 3)
-		#error "GCC Version is too small. 4.3 or above GCC versions are required."
-	#endif
+#if defined(__GNUC__)
+#if (!defined(__clang__) &&                                                    \
+     ((__GNUC__ < 4) || (__GNUC__ == 4 && __GNUC_MINOR__ < 3)))
+#error "Your GCC version is too old. 4.3 or later versions are required."
+#endif
 #endif
-
 
 namespace bzs
 {
@@ -42,228 +43,212 @@ namespace tdap
 namespace client
 {
 
-enum eIndexOpType {
-    eSeekEqual, eSeekFirst, eSeekLast, eSeekGreaterOrEqual, eSeekGreater, eSeekLessThanOrEqual,
-    eSeekLessThan};
-
-enum eStepOpType {
-    eStepFirst, eStepLast};
-
-enum eFindCurrntType{
-    ePosNeedNext = 1, ePosNeedNone = 0, ePosNeedPrev = -1};
-
-typedef boost::shared_ptr<database>database_ptr;
-typedef boost::shared_ptr<table>table_ptr;
-
+enum eIndexOpType
+{
+    eSeekEqual,
+    eSeekFirst,
+    eSeekLast,
+    eSeekGreaterOrEqual,
+    eSeekGreater,
+    eSeekLessThanOrEqual,
+    eSeekLessThan
+};
 
+enum eStepOpType
+{
+    eStepFirst,
+    eStepLast
+};
 
+enum eFindCurrntType
+{
+    ePosNeedNext = 1,
+    ePosNeedNone = 0,
+    ePosNeedPrev = -1
+};
 
-class field
+class connectParams
 {
-    short m_index;
-    table& m_tb;
+    _TCHAR m_buf[MAX_PATH];
+    short m_type;
+    char_td m_mode;
 
 public:
-    inline field(table& tb, short index) : m_tb(tb), m_index(index) {};
-
-    inline const _TCHAR* c_str() const {return m_tb.getFVstr(m_index);}
-
-    inline const char* a_str() const {return m_tb.getFVAstr(m_index);}
-
-    inline int i() const {return m_tb.getFVint(m_index);}
-
-    inline short i16() const {return m_tb.getFVsht(m_index);}
-
-    inline __int64 i64() const {return m_tb.getFV64(m_index);}
-
-    inline float f() const {return m_tb.getFVflt(m_index);}
-
-    inline double d() const {return m_tb.getFVdbl(m_index);}
-
-    inline field& operator = (const _TCHAR* p)
+    inline connectParams(const _TCHAR* protocol, const _TCHAR* hostOrIp,
+                         const _TCHAR* dbname, const _TCHAR* schemaTable)
+        : m_type(TYPE_SCHEMA_BDF), m_mode(TD_OPEN_READONLY)
     {
-        m_tb.setFV(m_index, p);
-        return *this;
+        _stprintf_s(m_buf, MAX_PATH, _T("%s://%s/%s?dbfile=%s.bdf"), protocol,
+                    hostOrIp, dbname, schemaTable);
     }
-
-    inline field& operator = (const std::_tstring& p)
+    inline explicit connectParams(const _TCHAR* uri)
+        : m_type(TYPE_SCHEMA_BDF), m_mode(TD_OPEN_READONLY)
     {
-        m_tb.setFV(m_index, p.c_str());
-        return *this;
+        _tcscpy_s(m_buf, MAX_PATH, uri);
     }
+    inline void setMode(char_td v) { m_mode = v; }
 
-#ifdef _UNICODE
-    inline field& operator = (const char* p)
+    inline void setType(short v)
     {
-        m_tb.setFVA(m_index, p);
-        return *this;
+        if (m_type != v)
+        {
+            m_buf[_tcslen(m_buf) - 3] = 0x00;
+            if (v == TYPE_SCHEMA_BDF)
+                _tcscat_s(m_buf, MAX_PATH, _T("bdf"));
+            else
+                _tcscat_s(m_buf, MAX_PATH, _T("ddf"));
+        }
+        m_type = v;
     }
 
-    inline field& operator = (const std::string& p)
-    {
-        m_tb.setFVA(m_index, p.c_str());
-        return *this;
-    }
+    inline const _TCHAR* uri() const { return m_buf; }
 
-#endif
+    inline char_td mode() const { return m_mode; };
 
-    inline field& operator = (int v)
-    {
-        m_tb.setFV(m_index, v);
-        return *this;
-    }
+    inline short type() const { return m_type; };
+};
 
-    inline field& operator = (__int64 v)
+inline const _TCHAR* host(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    buf[0] = 0x00;
+    const _TCHAR* st = _tcsstr(uri, _T("://"));
+    if (st)
     {
-        m_tb.setFV(m_index, v);
-        return *this;
+        const _TCHAR* en = _tcsstr(st + 3, _T("/"));
+        if (en)
+        {
+            _tcsncpy_s(buf, size, st + 3, en - (st + 3));
+            buf[en - (st + 3)] = 0x00;
+        }
     }
+    return buf;
+}
 
-    inline field& operator = (float v)
+inline const _TCHAR* dbname(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    buf[0] = 0x00;
+    const _TCHAR* st = _tcsstr(uri, _T("://"));
+    if (st)
     {
-        m_tb.setFV(m_index, v);
-        return *this;
+        st = _tcsstr(st + 3, _T("/"));
+        if (st)
+        {
+            const _TCHAR* en = _tcsstr(st + 1, _T("?"));
+            if (en)
+            {
+                _tcsncpy_s(buf, size, st + 1, en - (st + 1));
+                buf[en - (st + 1)] = 0x00;
+            }
+        }
     }
+    return buf;
+}
 
-    inline field& operator = (double v)
+inline const _TCHAR* schemaTable(const _TCHAR* uri, _TCHAR* buf, size_t size)
+{
+    buf[0] = 0x00;
+    const _TCHAR* st = _tcsrchr(uri, _T('='));
+    if (st)
     {
-        m_tb.setFV(m_index, v);
-        return *this;
+        const _TCHAR* en = _tcsrchr(uri, _T('.'));
+        if (en)
+        {
+            _tcsncpy_s(buf, size, st + 1, en - (st + 1));
+            buf[en - (st + 1)] = 0x00;
+        }
     }
+    return buf;
+}
 
-    inline bool operator != (const _TCHAR* p) {return (_tcscmp(p, c_str()) != 0);};
-    inline bool operator == (const _TCHAR* p) {return (_tcscmp(p, c_str())==0);};
-
-    inline bool operator != (int v) {return (v != i());};
-    inline bool operator == (int v) {return (v == i());};
-
-    inline bool operator != (short v) {return (v != i16());};
-    inline bool operator == (short v) {return (v == i16());};
-
-    inline bool operator != (__int64 v) {return (v != i64());};
-    inline bool operator == (__int64 v) {return (v == i64());};
-
-    inline bool operator != (float v) {return (v != f());};
-    inline bool operator == (float v) {return (v == f());};
-
-    inline bool operator != (double v) {return (v != d());};
-    inline bool operator == (double v) {return (v == d());};
+/* databaseManager interface
+   If use some databases, implemnt a this interface and set the activeTable
+   constructor
+   Create table by name and option from suitable database.
 
-    inline void setBin(const void* data, uint_td size){ m_tb.setFV(m_index, data, size);}
-    inline void* getBin(uint_td& size){return m_tb.getFVbin(m_index, size);};
-};
-
-class fields
+*/
+class idatabaseManager
 {
-    table& m_tb;
-
-public:
-    inline explicit fields(table& tb) : m_tb(tb) {};
-    inline explicit fields(table_ptr tb) : m_tb(*tb) {};
-    inline void clearValues(){m_tb.clearBuffer();};
-    inline field operator[](size_t index) const {return field(m_tb, (short)index);}
-
-    inline field operator()(const _TCHAR* name) const {
-        return field(m_tb, m_tb.fieldNumByName(name));}
-    inline table& tb() const {return m_tb;}
-
-    inline size_t size() {return m_tb.tableDef()->fieldCount;}
-
-    inline field fd(size_t index) const {return field(m_tb, (short)index);}
 
-    inline field fd(const _TCHAR* name) const {return field(m_tb, m_tb.fieldNumByName(name));}
-};
-
-class filterParams
-{
-	std::_tstring m_str;
-	int m_rejectCount;
-	int m_maxRecords; 
 public:
-	inline filterParams(const _TCHAR* filter, int rejectCount, int maxRecords)
-		:m_str(filter),m_rejectCount(rejectCount),m_maxRecords(maxRecords)
-	{
-
-	}
-	inline const _TCHAR* filter() const {return m_str.c_str();}
-	inline int rejectCount() const {return m_rejectCount;}
-	inline int maxRecords() const {return m_maxRecords;}
-
-
+    virtual ~idatabaseManager(){};
+    virtual void reset(int) = 0;
+    virtual table_ptr table(const _TCHAR* name) = 0;
+    virtual database* db() const = 0;
+    virtual void use(const connectParams* param = NULL) = 0;
+    virtual void unUse() = 0;
+    virtual void setOption(__int64 v) = 0;
+    virtual __int64 option() = 0;
+    virtual void beginTrn(short bias) = 0;
+    virtual void endTrn() = 0;
+    virtual void abortTrn() = 0;
+    virtual int enableTrn() = 0;
+    virtual void beginSnapshot() = 0;
+    virtual void endSnapshot() = 0;
+    virtual const _TCHAR* uri() const = 0;
+    virtual char_td mode() const = 0;
+    virtual bool isOpened() const = 0;
+    virtual short_td stat() const = 0;
+    virtual uchar_td* clientID() const = 0;
 };
 
 template <class T>
 class tableIterator
+    : public std::iterator<std::bidirectional_iterator_tag, fields, void>
 {
 
     table& m_tb;
     fields m_fds;
 
-    inline tableIterator() : m_tb(*((table*)0)), m_fds(*((table*)0)) {};
-
 public:
-    static const tableIterator eos;
-
     inline tableIterator(table& tb) : m_tb(tb), m_fds(tb)
     {
-        if ((tb.stat() != 0) && (tb.stat() != STATUS_EOF) && (tb.stat() != STATUS_NOT_FOUND_TI))
-            nstable::throwError(std::_tstring(_T("tableIterator")).c_str(), &tb);
-
+        readStatusCheck(tb, _T("tableIterator"));
     }
 
-    table& tb() const {return m_tb;};
+    table& tb() const { return m_tb; };
 
-    inline fields& operator*() {return m_fds;}
+    inline fields& operator*() { return m_fds; }
 
-    inline fields* operator->() {return &m_fds;}
+    inline fields* operator->() { return &m_fds; }
 
-    inline tableIterator& operator++() {
+    inline tableIterator& operator++()
+    {
         T::increment(m_tb);
         return *this;
     }
 
-    inline tableIterator& operator--() {
+    inline tableIterator& operator--()
+    {
         T::decrement(m_tb);
         return *this;
     }
 
-    inline bool operator == (const tableIterator& v) {return m_tb.stat() != 0;}
+    inline bool operator==(const tableIterator& v) { return m_tb.stat() != 0; }
 
-    inline bool operator != (const tableIterator& v) {return m_tb.stat() == 0;}
+    inline bool operator!=(const tableIterator& v) { return m_tb.stat() == 0; }
 
+    inline bool isEnd() { return m_tb.stat() != 0; }
 };
+
 typedef tableIterator<indexNavi> indexIterator;
 typedef tableIterator<indexFindNavi> findIterator;
 typedef tableIterator<stepNavi> stepIterator;
 
-
-template <> const indexIterator indexIterator::eos;
-template <> const findIterator findIterator::eos;
-template <> const stepIterator stepIterator::eos;
-
-
-
 typedef tableIterator<indexRvNavi> indexRvIterator;
 typedef tableIterator<indexRvFindNavi> findRvIterator;
 typedef tableIterator<stepRvNavi> stepRvIterator;
 
-
-template <> const indexRvIterator indexRvIterator::eos;
-template <> const findRvIterator findRvIterator::eos;
-template <> const stepRvIterator stepRvIterator::eos;
-
-
-
 static const int filter_validate_value = 0;
 static const int filter_validate_block = 1;
 static const int filter_invalidate_value = 2;
 
-typedef boost::function < int(const fields&) > validationFunc;
+typedef boost::function<int(const fields&)> validationFunc;
 
-#define VALIDATION_FUNC(FUNC_PTR, PTR)  boost::bind(FUNC_PTR, PTR, fields_type)
+#define VALIDATION_FUNC(FUNC_PTR, PTR) boost::bind(FUNC_PTR, PTR, fields_type)
 
-template<class T>
+template <class T>
 class filterdIterator
+    : public std::iterator<std::input_iterator_tag, fields, void>
 {
     T& m_it;
     validationFunc m_func;
@@ -273,14 +258,9 @@ class filterdIterator
         if (v == filter_invalidate_value)
             m_it.tb().setStat(STATUS_EOF);
         return v;
-
     }
 
 public:
-    static const filterdIterator<T> eos;
-
-    filterdIterator() : m_it(*((T*)0)), m_func(NULL) {}
-
     filterdIterator(T& it, validationFunc func) : m_it(it), m_func(func)
     {
         int v = callFunc();
@@ -288,27 +268,32 @@ public:
             operator++();
     }
 
+    inline fields operator*() { return m_it.operator*(); }
 
-    inline fields operator*() {return m_it.operator*();}
-
-    inline fields* operator->() {return m_it.operator->();}
+    inline fields* operator->() { return m_it.operator->(); }
 
     T& operator++()
     {
         int v;
-        do {
+        do
+        {
             ++m_it;
             v = callFunc();
-        }
-        while (v == filter_validate_block);
+        } while (v == filter_validate_block);
         return m_it;
     }
 
+    inline bool operator==(const filterdIterator& v)
+    {
+        return m_it.operator==(v.m_it);
+    }
 
-    inline bool operator == (const filterdIterator& v) {return m_it.operator == (v.m_it);}
-
-    inline bool operator != (const filterdIterator& v) {return m_it.operator != (v.m_it);}
+    inline bool operator!=(const filterdIterator& v)
+    {
+        return m_it.operator!=(v.m_it);
+    }
 
+    inline bool isEnd() { return m_it.isEnd(); }
 };
 
 typedef filterdIterator<indexIterator> filterdIndexIterator;
@@ -319,69 +304,57 @@ typedef filterdIterator<indexRvIterator> filterdIndexRvIterator;
 typedef filterdIterator<stepRvIterator> filterdStepRvIterator;
 typedef filterdIterator<findRvIterator> filterdFindRvIterator;
 
-
-
-template<>
-const filterdIndexIterator filterdIndexIterator::eos;
-
-template<>
-const filterdStepIterator filterdStepIterator::eos;
-
-template<>
-const filterdFindIterator filterdFindIterator::eos;
-
-template<>
-const filterdIndexRvIterator filterdIndexRvIterator::eos;
-
-template<>
-const filterdStepRvIterator filterdStepRvIterator::eos;
-
-template<>
-const filterdFindRvIterator filterdFindRvIterator::eos;
-
-
-indexIterator readIndex(table_ptr tb, eIndexOpType op)
+inline indexIterator readIndex(table_ptr tb, eIndexOpType op)
 {
 
     switch (op)
     {
-    case eSeekEqual: tb->seek();
+    case eSeekEqual:
+        tb->seek();
         break;
-    case eSeekFirst: tb->seekFirst();
+    case eSeekFirst:
+        tb->seekFirst();
         break;
-    case eSeekGreaterOrEqual: tb->seekGreater(true);
+    case eSeekGreaterOrEqual:
+        tb->seekGreater(true);
         break;
-    case eSeekGreater: tb->seekGreater(false);
+    case eSeekGreater:
+        tb->seekGreater(false);
         break;
     default:
         assert(0);
-    readStatusCheck(*tb, _T("readIndex"));
+        readStatusCheck(*tb, _T("readIndex"));
     }
     return indexIterator(*tb);
 }
 
-indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op)
+inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op)
 {
 
     switch (op)
     {
-    case eSeekEqual: tb->seek();
+    case eSeekEqual:
+        tb->seek();
         break;
-    case eSeekLast: tb->seekLast();
+    case eSeekLast:
+        tb->seekLast();
         break;
-    case eSeekLessThanOrEqual: tb->seekLessThan(true);
+    case eSeekLessThanOrEqual:
+        tb->seekLessThan(true);
         break;
-    case eSeekLessThan: tb->seekLessThan(false);
+    case eSeekLessThan:
+        tb->seekLessThan(false);
         break;
     default:
         assert(0);
-    readStatusCheck(*tb, _T("readIndexRv"));
+        readStatusCheck(*tb, _T("readIndexRv"));
     }
     return indexRvIterator(*tb);
 }
 
-template<class T>
-inline indexIterator readIndex(table_ptr tb, eIndexOpType op, char_td keynum, T func)
+template <class T>
+inline indexIterator readIndex(table_ptr tb, eIndexOpType op, char_td keynum,
+                               T func)
 {
     tb->setKeyNum(keynum);
     if (&func)
@@ -390,11 +363,11 @@ inline indexIterator readIndex(table_ptr tb, eIndexOpType op, char_td keynum, T
         func(fds);
     }
     return readIndex(tb, op);
-
 }
 
-template<class T>
-inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op, char_td keynum, T func)
+template <class T>
+inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op,
+                                   char_td keynum, T func)
 {
     tb->setKeyNum(keynum);
     if (&func)
@@ -403,154 +376,171 @@ inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op, char_td keynum
         func(fds);
     }
     return readIndexRv(tb, op);
-
 }
 
-template <class T0, class T1, class T2, class T3
-        , class T4, class T5, class T6, class T7>
-inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-    ,const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7>
+inline indexIterator
+readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>::set(
+        tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
     return readIndex(tb, op);
 }
 
-template <class T0, class T1, class T2, class T3
-        , class T4, class T5, class T6>
-inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-    ,const T4 kv4, const T5 kv5, const T6 kv6)
+/** @cond INTERNAL */
+
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op,
+                                 const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2,
+                                                    kv3, kv4, kv5, kv6);
     return readIndex(tb, op);
 }
 
-template <class T0, class T1, class T2, class T3
-        , class T4, class T5>
-inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-    ,const T4 kv4, const T5 kv5)
+template <class T0, class T1, class T2, class T3, class T4, class T5>
+inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op,
+                                 const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5);
+    keyValueSetter<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                                kv4, kv5);
     return readIndex(tb, op);
 }
 
 template <class T0, class T1, class T2, class T3, class T4>
-inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3, const T4 kv4)
+inline indexIterator
+readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum, const T0 kv0,
+            const T1 kv1, const T2 kv2, const T3 kv3, const T4 kv4)
 {
-    keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4);
+    keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                            kv4);
     return readIndex(tb, op);
 }
 
 template <class T0, class T1, class T2, class T3>
-inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1 ,const T2 kv2, const T3 kv3)
+inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op,
+                                 const char_td keynum, const T0 kv0,
+                                 const T1 kv1, const T2 kv2, const T3 kv3)
 {
     keyValueSetter<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
     return readIndex(tb, op);
 }
 
 template <class T0, class T1, class T2>
-inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1 ,const T2 kv2)
+inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op,
+                                 const char_td keynum, const T0 kv0,
+                                 const T1 kv1, const T2 kv2)
 {
     keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
     return readIndex(tb, op);
 }
 
 template <class T0, class T1>
-inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1)
+inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op,
+                                 const char_td keynum, const T0 kv0,
+                                 const T1 kv1)
 {
     keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
     return readIndex(tb, op);
 }
 
 template <class T0>
-inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0)
+inline indexIterator readIndex_v(table_ptr tb, eIndexOpType op,
+                                 const char_td keynum, const T0 kv0)
 {
     keyValueSetter<T0>::set(tb, keynum, kv0);
     return readIndex(tb, op);
 }
+/** @endcond */
 
-
-template <class T0, class T1, class T2, class T3
-        , class T4, class T5, class T6, class T7>
-inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-    ,const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7>
+inline indexRvIterator
+readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>::set(
+        tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
     return readIndexRv(tb, op);
 }
 
-template <class T0, class T1, class T2, class T3
-        , class T4, class T5, class T6>
-inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-    ,const T4 kv4, const T5 kv5, const T6 kv6)
+/** @cond INTERNAL */
+
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op,
+                                     const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2,
+                                                    kv3, kv4, kv5, kv6);
     return readIndexRv(tb, op);
 }
 
-template <class T0, class T1, class T2, class T3
-        , class T4, class T5>
-inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3
-    ,const T4 kv4, const T5 kv5)
+template <class T0, class T1, class T2, class T3, class T4, class T5>
+inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op,
+                                     const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5);
+    keyValueSetter<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                                kv4, kv5);
     return readIndexRv(tb, op);
 }
 
 template <class T0, class T1, class T2, class T3, class T4>
-inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3, const T4 kv4)
+inline indexRvIterator
+readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum, const T0 kv0,
+              const T1 kv1, const T2 kv2, const T3 kv3, const T4 kv4)
 {
-    keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4);
+    keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                            kv4);
     return readIndexRv(tb, op);
 }
 
 template <class T0, class T1, class T2, class T3>
-inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1 ,const T2 kv2, const T3 kv3)
+inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op,
+                                     const char_td keynum, const T0 kv0,
+                                     const T1 kv1, const T2 kv2, const T3 kv3)
 {
     keyValueSetter<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
     return readIndexRv(tb, op);
 }
 
 template <class T0, class T1, class T2>
-inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1 ,const T2 kv2)
+inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op,
+                                     const char_td keynum, const T0 kv0,
+                                     const T1 kv1, const T2 kv2)
 {
     keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
     return readIndexRv(tb, op);
 }
 
 template <class T0, class T1>
-inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0, const T1 kv1)
+inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op,
+                                     const char_td keynum, const T0 kv0,
+                                     const T1 kv1)
 {
     keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
     return readIndexRv(tb, op);
 }
 
 template <class T0>
-inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
-    ,const T0 kv0)
+inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op,
+                                     const char_td keynum, const T0 kv0)
 {
     keyValueSetter<T0>::set(tb, keynum, kv0);
     return readIndexRv(tb, op);
 }
-
+/** @endcond */
 
 inline stepIterator readStep(table_ptr tb)
 {
@@ -564,259 +554,282 @@ inline stepRvIterator readStepRv(table_ptr tb)
     return stepRvIterator(*tb);
 }
 
-
-template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7>
+inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+                         const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
+                         const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>::
-            set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>::set(
+        tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
     tb->find(table::findForword);
-	return findIterator(*tb);
+    return findIterator(*tb);
 }
 
+/** @cond INTERNAL */
+
 template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5, const T6 kv6)
+inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+                         const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
+                         const T4 kv4, const T5 kv5, const T6 kv6)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2,
+                                                    kv3, kv4, kv5, kv6);
     tb->find(table::findForword);
-	return findIterator(*tb);
+    return findIterator(*tb);
 }
 
 template <class T0, class T1, class T2, class T3, class T4, class T5>
-findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5)
+inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+                         const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
+                         const T4 kv4, const T5 kv5)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                                kv4, kv5);
     tb->find(table::findForword);
-	return findIterator(*tb);
+    return findIterator(*tb);
 }
 
 template <class T0, class T1, class T2, class T3, class T4>
-findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4)
+inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+                         const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
+                         const T4 kv4)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                            kv4);
     tb->find(table::findForword);
-	return findIterator(*tb);
+    return findIterator(*tb);
 }
 
 template <class T0, class T1, class T2, class T3>
-findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3)
+inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+                         const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
     tb->find(table::findForword);
-	return findIterator(*tb);
+    return findIterator(*tb);
 }
 
 template <class T0, class T1, class T2>
-findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2)
+inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+                         const T0 kv0, const T1 kv1, const T2 kv2)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
     tb->find(table::findForword);
-	return findIterator(*tb);
+    return findIterator(*tb);
 }
 
 template <class T0, class T1>
-findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1)
+inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+                         const T0 kv0, const T1 kv1)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
     tb->find(table::findForword);
-	return findIterator(*tb);
+    return findIterator(*tb);
 }
 
 template <class T0>
-findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0)
+inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+                         const T0 kv0)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0>::set(tb, keynum, kv0);
+    tb->setQuery(&q);
+    keyValueSetter<T0>::set(tb, keynum, kv0);
     tb->find(table::findForword);
-	return findIterator(*tb);
+    return findIterator(*tb);
 }
+/** @endcond */
 
-template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7>
+inline findRvIterator findRv(table_ptr tb, const char_td keynum,
+                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const T2 kv2, const T3 kv3, const T4 kv4,
+                             const T5 kv5, const T6 kv6, const T7 kv7)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>::
-            set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>::set(
+        tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
     tb->find(table::findBackForword);
-	return findRvIterator(*tb);
+    return findRvIterator(*tb);
 }
 
+/** @cond INTERNAL */
+
 template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5, const T6 kv6)
-{
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6);
+inline findRvIterator findRv(table_ptr tb, const char_td keynum,
+                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const T2 kv2, const T3 kv3, const T4 kv4,
+                             const T5 kv5, const T6 kv6)
+{
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2,
+                                                    kv3, kv4, kv5, kv6);
     tb->find(table::findBackForword);
-	return findRvIterator(*tb);
+    return findRvIterator(*tb);
 }
 
 template <class T0, class T1, class T2, class T3, class T4, class T5>
-findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5)
+inline findRvIterator
+findRv(table_ptr tb, const char_td keynum, const queryBase& q, const T0 kv0,
+       const T1 kv1, const T2 kv2, const T3 kv3, const T4 kv4, const T5 kv5)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                                kv4, kv5);
     tb->find(table::findBackForword);
-	return findRvIterator(*tb);
+    return findRvIterator(*tb);
 }
 
 template <class T0, class T1, class T2, class T3, class T4>
-findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4)
+inline findRvIterator findRv(table_ptr tb, const char_td keynum,
+                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const T2 kv2, const T3 kv3, const T4 kv4)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                            kv4);
     tb->find(table::findBackForword);
-	return findRvIterator(*tb);
+    return findRvIterator(*tb);
 }
 
 template <class T0, class T1, class T2, class T3>
-findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3)
+inline findRvIterator findRv(table_ptr tb, const char_td keynum,
+                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const T2 kv2, const T3 kv3)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
     tb->find(table::findBackForword);
-	return findRvIterator(*tb);
+    return findRvIterator(*tb);
 }
 
 template <class T0, class T1, class T2>
-findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1, const T2 kv2)
+inline findRvIterator findRv(table_ptr tb, const char_td keynum,
+                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const T2 kv2)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
     tb->find(table::findBackForword);
-	return findRvIterator(*tb);
+    return findRvIterator(*tb);
 }
 
 template <class T0, class T1>
-findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0, const T1 kv1)
+inline findRvIterator findRv(table_ptr tb, const char_td keynum,
+                             const queryBase& q, const T0 kv0, const T1 kv1)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
+    tb->setQuery(&q);
+    keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
     tb->find(table::findBackForword);
-	return findRvIterator(*tb);
+    return findRvIterator(*tb);
 }
 
 template <class T0>
-findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
-    ,const T0 kv0)
+inline findRvIterator findRv(table_ptr tb, const char_td keynum,
+                             const queryBase& q, const T0 kv0)
 {
-    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-	keyValueSetter<T0>::set(tb, keynum, kv0);
+    tb->setQuery(&q);
+    keyValueSetter<T0>::set(tb, keynum, kv0);
     tb->find(table::findBackForword);
-	return findRvIterator(*tb);
+    return findRvIterator(*tb);
 }
 
-findIterator getFindIterator(indexIterator it, const filterParams& fp
-                    ,bool isCurrentValid)
+/** @endcond */
+
+inline findIterator getFindIterator(indexIterator it, const queryBase& q,
+                                    bool isCurrentValid)
 
 {
-    if (it != indexIterator::eos)
-	{
-        it.tb().setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
-		if (!isCurrentValid)
-			it.tb().findNext(false);
-	}
+    if (!it.isEnd())
+    {
+        it.tb().setQuery(&q);
+        if (!isCurrentValid)
+            it.tb().findNext(false);
+    }
     return findIterator(it.tb());
 }
 
-findRvIterator getFindIterator(indexRvIterator it, const filterParams& fp
-                    ,bool isCurrentValid)
+inline findRvIterator getFindIterator(indexRvIterator it, const queryBase& q,
+                                      bool isCurrentValid)
 {
-    if (it != indexRvIterator::eos)
-        it.tb().setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+    if (!it.isEnd())
+        it.tb().setQuery(&q);
     if (!isCurrentValid)
         it.tb().findPrev(false);
     return findRvIterator(it.tb());
 }
 
-
-class connectParams
+template <class Database_Ptr>
+bool isSameUri(const connectParams* param, const Database_Ptr& db)
 {
-    _TCHAR m_buf[MAX_PATH];
-    short m_mode;
-    short m_type;
+    return db && db->isOpened() && (_tcsicmp(param->uri(), db->uri()) == 0) &&
+           (param->mode() == db->mode());
+}
 
-public:
-    inline connectParams(const _TCHAR* protocol, const _TCHAR* hostOrIp, const _TCHAR* dbname,
-        const _TCHAR* schemaTable) : m_mode(TD_OPEN_READONLY), m_type(TYPE_SCHEMA_BDF)
-    {
-        _stprintf_s(m_buf, MAX_PATH, _T("%s://%s/%s?dbfile=%s.bdf")
-                    , protocol, hostOrIp, dbname, schemaTable);
+inline void releaseDatabase(database* db)
+{
+    database::destroy(db);
+}
 
-    }
-    inline explicit connectParams(const _TCHAR* uri) : m_mode(TD_OPEN_READONLY), m_type(TYPE_SCHEMA_BDF)
+inline void releaseTable(table* p)
+{
+    if (p)
     {
-        _tcscpy_s(m_buf, MAX_PATH, uri);
-
+        if (nsdatabase::testTablePtr(p))
+            p->release();
     }
-    inline void setMode(short v){m_mode = v;}
-
-    inline void setType(short v){m_type = v;}
-
-    inline const _TCHAR* uri() const {return m_buf;}
-
-    inline short mode() const {return m_mode;};
-
-    inline short type() const {return m_type;};
-
-};
-
-inline void releaseDatabase(database* db) {database::destroy(db);}
-
-inline void releaseTable(table* p) {if (p) p->release();}
+}
 
-inline database_ptr createDatadaseObject()
+inline database_ptr createDatabaseObject()
 {
     database_ptr p(database::create(), releaseDatabase);
     return p;
 }
 
 template <class Database_Ptr, class ConnectParam_type>
-inline void connect(Database_Ptr db, const ConnectParam_type& connPrams, bool newConnection)
+inline void connect(Database_Ptr db, const ConnectParam_type& connPrams,
+                    bool newConnection)
 {
     db->connect(connPrams.uri(), newConnection);
     if (db->stat())
-        nstable::throwError((std::_tstring(_T("Connect database ")) + connPrams.uri()).c_str(), db->stat());
-
+        nstable::throwError(
+            (std::_tstring(_T("Connect database ")) + connPrams.uri()).c_str(),
+            db->stat());
 }
 
+/*template <>
+inline void connect(idatabaseManager* db,  const connectParams& connPrams, bool
+newConnection)
+{
+        db->connect(connPrams, newConnection);
+        if (db->stat())
+                nstable::throwError((std::_tstring(_T("Connect database ")) +
+connPrams.uri()).c_str(), db->stat());
+
+}*/
+
 template <class Database_Ptr>
 inline void disconnect(Database_Ptr db, const connectParams& connPrams)
 {
     db->disconnect(connPrams.uri());
     if (db->stat())
-        nstable::throwError((std::_tstring(_T("Disconnect database ")) + connPrams.uri()).c_str(), db->stat());
-
+        nstable::throwError((std::_tstring(_T("Disconnect database ")) +
+                             connPrams.uri()).c_str(),
+                            db->stat());
 }
 
-template <class Database_Ptr>
-inline void disconnect(Database_Ptr db)
+template <class Database_Ptr> inline void disconnect(Database_Ptr db)
 {
     db->disconnect();
     if (db->stat())
         nstable::throwError(_T("Disconnect database "), db->stat());
-
 }
 
 template <class Database_Ptr>
@@ -824,7 +837,9 @@ inline void createDatabase(Database_Ptr db, const connectParams& connPrams)
 {
     db->create(connPrams.uri());
     if (db->stat())
-        nstable::throwError((std::_tstring(_T("Create database ")) + connPrams.uri()).c_str(), db->stat());
+        nstable::throwError(
+            (std::_tstring(_T("Create database ")) + connPrams.uri()).c_str(),
+            db->stat());
 }
 
 template <class Database_Ptr>
@@ -832,36 +847,48 @@ inline void createDatabase(Database_Ptr db, const _TCHAR* uri)
 {
     db->create(uri);
     if (db->stat())
-        nstable::throwError((std::_tstring(_T("Create database "))+ uri).c_str() , db->stat());
+        nstable::throwError(
+            (std::_tstring(_T("Create database ")) + uri).c_str(), db->stat());
 }
 
-
 template <class Database_Ptr, class ConnectParam_type>
 inline void openDatabase(Database_Ptr db, const ConnectParam_type& connPrams)
 {
     db->open(connPrams.uri(), connPrams.type(), connPrams.mode());
     if (db->stat())
-        nstable::throwError((std::_tstring(_T("Open database ")) + connPrams.uri()).c_str(), db->stat());
-
+        nstable::throwError(
+            (std::_tstring(_T("Open database ")) + connPrams.uri()).c_str(),
+            db->stat());
 }
 
 template <class Database_Ptr>
-inline void openDatabase(Database_Ptr db, const _TCHAR* uri, short schemaType = 0, short mode = -2, const _TCHAR* dir = NULL,
-        const _TCHAR* ownername = NULL)
+inline void openDatabase(Database_Ptr db, const _TCHAR* uri,
+                         short schemaType = 0, short mode = -2,
+                         const _TCHAR* dir = NULL,
+                         const _TCHAR* ownername = NULL)
 {
     db->open(uri, schemaType, mode, dir, ownername);
     if (db->stat())
-        nstable::throwError((std::_tstring(_T("Open database ")) + std::_tstring(uri)).c_str(), db->stat());
-
+        nstable::throwError(
+            (std::_tstring(_T("Open database ")) + std::_tstring(uri)).c_str(),
+            db->stat());
 }
 
 template <class Database_Ptr>
-inline void dropDatabase(Database_Ptr db)
+inline void connectOpen(Database_Ptr db, const connectParams& connPrams,
+                        bool newConnection)
+{
+    if (newConnection)
+        connect(db, connPrams, newConnection);
+    openDatabase(db, connPrams);
+}
+
+template <class Database_Ptr> inline void dropDatabase(Database_Ptr db)
 {
     db->drop();
     if (db->stat())
-        nstable::throwError(std::_tstring(_T("Drop database ")).c_str(), db->stat());
-
+        nstable::throwError(std::_tstring(_T("Drop database ")).c_str(),
+                            db->stat());
 }
 
 template <class Database_Ptr>
@@ -869,13 +896,22 @@ inline table_ptr openTable(Database_Ptr db, const _TCHAR* name)
 {
     table_ptr p(db->openTable(name), releaseTable);
     if (db->stat())
-        nstable::throwError((std::_tstring(_T("Open table ")) + name).c_str(), db->stat());
+        nstable::throwError((std::_tstring(_T("Open table ")) + name).c_str(),
+                            db->stat());
     return p;
+}
 
+template <class Database_Ptr>
+inline void dropTable(Database_Ptr db, const _TCHAR* name)
+{
+    db->dropTable(name);
+    if (db->stat())
+        nstable::throwError((std::_tstring(_T("Drop table ")) + name).c_str(),
+                            db->stat());
 }
 
 template <class Database_Ptr>
-inline void convertTable(Database_Ptr db, short tableid, copyDataFn func=NULL)
+inline void convertTable(Database_Ptr db, short tableid, copyDataFn func = NULL)
 {
 
     if (db->existsTableFile(tableid, NULL))
@@ -887,38 +923,45 @@ inline void convertTable(Database_Ptr db, short tableid, copyDataFn func=NULL)
         {
             assert(db->dbDef());
             db->dbDef()->popBackup(tableid);
-            nstable::throwError(std::_tstring(_T("Convert table ")).c_str(), db->stat());
+            nstable::throwError(std::_tstring(_T("Convert table ")).c_str(),
+                                db->stat());
         }
     }
 }
 
 template <class Database_Ptr>
-inline void convertTable(Database_Ptr db, const _TCHAR* name, copyDataFn func=NULL)
+inline void convertTable(Database_Ptr db, const _TCHAR* name,
+                         copyDataFn func = NULL)
 {
     assert(db->dbDef());
     short tablenum = db->dbDef()->tableNumByName(name);
     convertTable(db, tablenum, func);
 }
 
-inline void insertTable(dbdef* def, short id, const _TCHAR* name, unsigned short charsetIndex)
+inline void insertTable(dbdef* def, short id, const _TCHAR* name,
+                        unsigned short charsetIndex)
 {
     tabledef td;
     td.setTableName(name);
     td.setFileName(name);
-    td.id =id;
+    td.id = id;
     td.charsetIndex = (uchar_td)charsetIndex;
     def->insertTable(&td);
     if (def->stat() != 0)
-        nstable::throwError((std::_tstring(_T("Insert tabledef ")) + name).c_str(), def->stat());
+        nstable::throwError(
+            (std::_tstring(_T("Insert tabledef ")) + name).c_str(),
+            def->stat());
 }
 
-inline fielddef* insertField(dbdef* def, short tableid, short fieldNum
-    , const _TCHAR* name, uchar_td type, ushort_td len )
+inline fielddef* insertField(dbdef* def, short tableid, short fieldNum,
+                             const _TCHAR* name, uchar_td type, ushort_td len)
 {
 
-    fielddef* fd =  def->insertField(tableid, fieldNum);
+    fielddef* fd = def->insertField(tableid, fieldNum);
     if (def->stat() != 0)
-        nstable::throwError((std::_tstring(_T("Insert fielddef ")) + name).c_str(), def->stat());
+        nstable::throwError(
+            (std::_tstring(_T("Insert fielddef ")) + name).c_str(),
+            def->stat());
 
     fd->setName(name);
     fd->type = type;
@@ -928,9 +971,10 @@ inline fielddef* insertField(dbdef* def, short tableid, short fieldNum
 
 inline keydef* insertKey(dbdef* def, short tableid, short insertIndex)
 {
-    keydef* kd =  def->insertKey(tableid, insertIndex);
+    keydef* kd = def->insertKey(tableid, insertIndex);
     if (def->stat() != 0)
-        nstable::throwError(std::_tstring(_T("Insert keydef ")).c_str(), def->stat());
+        nstable::throwError(std::_tstring(_T("Insert keydef ")).c_str(),
+                            def->stat());
     return kd;
 }
 
@@ -942,176 +986,240 @@ inline void updateTableDef(dbdef* def, short tableid)
         std::_tstring s;
         if (def->tableDefs(tableid))
             s = def->tableDefs(tableid)->tableName();
-        nstable::throwError((std::_tstring(_T("Update tabledef ")) + s).c_str(), def->stat());
+        nstable::throwError((std::_tstring(_T("Update tabledef ")) + s).c_str(),
+                            def->stat());
     }
 }
 
-template <class T>
-inline void insertRecord(const T& it, bool ncc = true)
+/** @cond INTERNAL */
+
+template <class T> inline table* getTable(T& it)
 {
-    it.tb().insert(ncc);
-    if (it.tb().stat() != 0)
-        nstable::throwError(std::_tstring(_T("Insert record")).c_str(), &(it.tb()));
+    return &(it.tb());
+}
 
+template <> inline table* getTable(table_ptr& tb)
+{
+    return tb.get();
 }
 
-template <class T>
-inline void updateRecord(const T& it, bool ncc = true)
+template <> inline table* getTable(table*& tb)
 {
-    it.tb().update((nstable::eUpdateType)ncc);
-    if (it.tb().stat() != 0)
-        nstable::throwError(std::_tstring(_T("Update record")).c_str(), &(it.tb()));
+    return tb;
+}
 
+/** @endcond */
+
+template <class T> inline void insertRecord(T& some, bool ncc = true)
+{
+    table* tb = getTable(some);
+    tb->insert(ncc);
+    if (tb->stat() != 0)
+        nstable::throwError(std::_tstring(_T("Insert record")).c_str(), tb);
 }
 
-inline void updateRecord(fields& fd, char_td keynum)
+inline void updateRecord(fields& fd, const char_td keynum)
 {
     fd.tb().setKeyNum(keynum);
-	fd.tb().update(nstable::changeInKey);
+    fd.tb().update(nstable::changeInKey);
     if (fd.tb().stat() != 0)
-        nstable::throwError(std::_tstring(_T("Update record")).c_str(), &(fd.tb()));
+        nstable::throwError(std::_tstring(_T("Update record")).c_str(),
+                            &(fd.tb()));
 }
 
-inline void deleteRecord(fields& fd, const char_td keynum)
+template <class T> inline void updateRecord(T& some, bool ncc = true)
 {
-    fd.tb().setKeyNum(keynum);
-	fd.tb().del(true/*inKey*/);
-    if (fd.tb().stat() != 0)
-		nstable::throwError(std::_tstring(_T("Update record")).c_str(), &(fd.tb()));
+    table* tb = getTable(some);
+    tb->update((nstable::eUpdateType)ncc);
+    if (tb->stat() != 0)
+        nstable::throwError(std::_tstring(_T("Update record")).c_str(), tb);
+}
+
+template <class T> inline void deleteRecord(T& some)
+{
+    table* tb = getTable(some);
+    tb->del(false /*inKey*/);
+    if (tb->stat() != 0)
+        nstable::throwError(std::_tstring(_T("Delete record")).c_str(), tb);
+}
+
+template <class T> inline void deleteRecord(T& some, const char_td keynum)
+{
+    table* tb = getTable(some);
+
+    tb->setKeyNum(keynum);
+    tb->del(true /*inKey*/);
+    if (tb->stat() != 0)
+        nstable::throwError(std::_tstring(_T("Delete record")).c_str(), tb);
 }
 
-template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-void deleteRecord(table_ptr tb, const char_td keynum
-    ,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5, const T6 kv6, const T7 kv7)
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+          class T7>
+inline void deleteRecord(table_ptr tb, const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
-	fields fd(tb);
-	deleteRecord(fd, keynum);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6, T7>::set(
+        tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6, kv7);
+    fields fd(tb);
+    deleteRecord(fd, keynum);
 }
+/** @cond INTERNAL */
 
 template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-void deleteRecord(table_ptr tb, const char_td keynum
-	,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5, const T6 kv6)
+inline void deleteRecord(table_ptr tb, const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6);
-	fields fd(tb);
-	deleteRecord(fd, keynum);
+    keyValueSetter<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2,
+                                                    kv3, kv4, kv5, kv6);
+    fields fd(tb);
+    deleteRecord(fd, keynum);
 }
 
 template <class T0, class T1, class T2, class T3, class T4, class T5>
-void deleteRecord(table_ptr tb, const char_td keynum
-	,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4, const T5 kv5)
+inline void deleteRecord(table_ptr tb, const char_td keynum, 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(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5);
-	fields fd(tb);
-	deleteRecord(fd, keynum);
+    keyValueSetter<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                                kv4, kv5);
+    fields fd(tb);
+    deleteRecord(fd, keynum);
 }
 
 template <class T0, class T1, class T2, class T3, class T4>
-void deleteRecord(table_ptr tb, const char_td keynum
-	,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,const T4 kv4)
+inline void deleteRecord(table_ptr tb, const char_td keynum, const T0 kv0,
+                         const T1 kv1, const T2 kv2, const T3 kv3, const T4 kv4)
 {
-	keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4);
-	fields fd(tb);
-	deleteRecord(fd, keynum);
+    keyValueSetter<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3,
+                                            kv4);
+    fields fd(tb);
+    deleteRecord(fd, keynum);
 }
 
 template <class T0, class T1, class T2, class T3>
-void deleteRecord(table_ptr tb, const char_td keynum
-	,const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3)
+inline void deleteRecord(table_ptr tb, const char_td keynum, const T0 kv0,
+                         const T1 kv1, const T2 kv2, const T3 kv3)
 {
-	keyValueSetter<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
-	fields fd(tb);
-	deleteRecord(fd, keynum);
+    keyValueSetter<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
+    fields fd(tb);
+    deleteRecord(fd, keynum);
 }
 
 template <class T0, class T1, class T2>
-void deleteRecord(table_ptr tb, const char_td keynum
-	,const T0 kv0, const T1 kv1, const T2 kv2)
+inline void deleteRecord(table_ptr tb, const char_td keynum, const T0 kv0,
+                         const T1 kv1, const T2 kv2)
 {
-	keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
-	fields fd(tb);
-	deleteRecord(fd, keynum);
+    keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
+    fields fd(tb);
+    deleteRecord(fd, keynum);
 }
 
 template <class T0, class T1>
-void deleteRecord(table_ptr tb, const char_td keynum
-	,const T0 kv0, const T1 kv1)
+inline void deleteRecord(table_ptr tb, const char_td keynum, const T0 kv0,
+                         const T1 kv1)
 {
-	keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
-	fields fd(tb);
-	deleteRecord(fd, keynum);
+    keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
+    fields fd(tb);
+    deleteRecord(fd, keynum);
 }
 
 template <class T0>
-void deleteRecord(table_ptr tb, const char_td keynum
-	,const T0 kv0)
+inline void deleteRecord(table_ptr tb, const char_td keynum, const T0 kv0)
 {
-	keyValueSetter<T0>::set(tb, keynum, kv0);
-	fields fd(tb);
-	deleteRecord(fd, keynum);
+    keyValueSetter<T0>::set(tb, keynum, kv0);
+    fields fd(tb);
+    deleteRecord(fd, keynum);
 }
+/** @endcond */
 
-template <class T>
-inline void deleteRecord(const T& it)
+template <class T, class F> void for_each(T iterator, F func)
 {
-	it.tb().del(false/*inKey*/);
-	if (it.tb().stat() != 0)
-		nstable::throwError(std::_tstring(_T("Delete record")).c_str(), &(it.tb()));
+    std::for_each(iterator, iterator, func);
 }
 
+/** Shared pointer of idatabaseManager.  */
+typedef boost::shared_ptr<idatabaseManager> dbmanager_ptr;
+
+template <class T> inline T createDatabaseForConnectionPool(T& p);
 
-template<class T, class F>
-void for_each(T iterator, F func) {std::for_each(iterator, T::eos, func);}
+/** @cond INTERNAL */
+template <> inline database_ptr createDatabaseForConnectionPool(database_ptr& p)
+{
+    return createDatabaseObject();
+}
+/** @endcond */
 
-class transaction
+/* Exception safe trnasction
+        It can use for database  and idatabaseManager.
+*/
+template <class DB> class transaction
 {
-    database_ptr m_db;
+    DB m_db;
     short m_bias;
-public:
-    transaction(database_ptr db, short bias=LOCK_SINGLE_NOWAIT + PARALLEL_TRN + NOWAIT_WRITE)
-        :m_db(db),m_bias(bias){};
-    ~transaction(){if (m_db->enableTrn()) m_db->abortTrn();};
-    void begin(){m_db->beginTrn(m_bias);}
-    void end(){m_db->endTrn();}
-    void abort(){m_db->abortTrn();}
 
+public:
+    inline transaction(DB db, short bias = LOCK_SINGLE_NOWAIT + PARALLEL_TRN +
+                                           NOWAIT_WRITE)
+        : m_db(db), m_bias(bias){};
+    inline ~transaction()
+    {
+        if (m_db->enableTrn())
+            m_db->abortTrn();
+    };
+    inline void begin() { m_db->beginTrn(m_bias); }
+    inline void end() { m_db->endTrn(); }
+    inline void abort() { m_db->abortTrn(); }
 };
 
-class autoSnapshot
+/** transaction for database */
+typedef transaction<database_ptr> dbTransaction;
+
+/** transaction for idatabaseManager */
+typedef transaction<dbmanager_ptr> dbmTransaction;
+
+template <class DB> class snapshot
 {
-    database_ptr m_db;
+    DB m_db;
+
 public:
-    autoSnapshot(database_ptr db):m_db(db)
-    {
-        m_db->beginSnapshot();
-    }
+    snapshot(DB db) : m_db(db) { m_db->beginSnapshot(); }
 
-    ~autoSnapshot()
-    {
-        m_db->endSnapshot();
-    }
+    ~snapshot() { m_db->endSnapshot(); }
 };
 
+/** snapshot for database */
+typedef snapshot<database_ptr> dbSnapshot;
+
+/** snapshot for idatabaseManager */
+typedef snapshot<idatabaseManager*> dbmSnapshot;
 
 class autoBulkinsert
 {
     table_ptr m_tb;
+
 public:
-    autoBulkinsert(table_ptr tb, int bufsize = BULKBUFSIZE):m_tb(tb)
+    autoBulkinsert(table_ptr tb, int bufsize = BULKBUFSIZE) : m_tb(tb)
     {
         m_tb->beginBulkInsert(bufsize);
     }
-    ~autoBulkinsert(){m_tb->commitBulkInsert();}
 
-};
-
-}// namespace client
-}// namespace tdap
-}// namespace protocol
-}// namespace db
-}// namespace bzs
+    /* For activeObject */
+    template <class T>
+    autoBulkinsert(T& tba, int bufsize = BULKBUFSIZE)
+        : m_tb(tba.table())
+    {
+        m_tb->beginBulkInsert(bufsize);
+    }
 
+    ~autoBulkinsert() { m_tb->commitBulkInsert(); }
+};
 
+} // namespace client
+} // namespace tdap
+} // namespace protocol
+} // namespace db
+} // namespace bzs
 
-#endif
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_TRDBOOSTAPI_H