transactd 1.0.1

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

@@ -0,0 +1,1096 @@
+#ifndef trdboostapiH
+#define trdboostapiH
+/*=================================================================
+   Copyright (C) 2013 BizStation Corp All rights reserved.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; either version 2
+   of the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   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  
+   02111-1307, USA.
+=================================================================*/
+#include <bzs/db/protocol/tdap/client/trdboostapiInternal.h>
+#include <boost/shared_ptr.hpp>
+#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
+#endif
+
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+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;
+
+
+
+
+class field
+{
+    short m_index;
+    table& m_tb;
+
+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) {
+        m_tb.setFV(m_index, p);
+        return *this;
+    } inline field& operator = (int v) {
+        m_tb.setFV(m_index, v);
+        return *this;
+    } inline field& operator = (__int64 v) {
+        m_tb.setFV(m_index, v);
+        return *this;
+    } inline field& operator = (float v) {
+        m_tb.setFV(m_index, v);
+        return *this;
+    } inline field& operator = (double v) {
+        m_tb.setFV(m_index, v);
+        return *this;
+    }
+    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());};
+
+    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
+{
+    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;}
+
+
+};
+
+template <class T>
+class tableIterator
+{
+
+    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) {};
+
+    table& tb() const {return m_tb;};
+
+    inline fields& operator*() {return m_fds;}
+
+    inline fields* operator->() {return &m_fds;}
+
+    inline tableIterator& operator++() {
+        T::increment(m_tb);
+        return *this;
+    }
+
+    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;}
+
+};
+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;
+
+#define VALIDATION_FUNC(FUNC_PTR, PTR)  boost::bind(FUNC_PTR, PTR, fields_type)
+
+template<class T>
+class filterdIterator
+{
+    T& m_it;
+    validationFunc m_func;
+    inline int callFunc()
+    {
+        int v = m_func(*m_it);
+        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();
+        if (v == filter_validate_block)
+            operator++();
+    }
+
+
+    inline fields operator*() {return m_it.operator*();}
+
+    inline fields* operator->() {return m_it.operator->();}
+
+    T& operator++()
+    {
+        int v;
+        do {
+            ++m_it;
+            v = callFunc();
+        }
+        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);}
+
+};
+
+typedef filterdIterator<indexIterator> filterdIndexIterator;
+typedef filterdIterator<stepIterator> filterdStepIterator;
+typedef filterdIterator<findIterator> filterdFindIterator;
+
+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;
+
+
+
+inline indexIterator readIndex(table_ptr tb, eIndexOpType op)
+{
+
+    switch (op)
+    {
+    case eSeekEqual: tb->seek();
+        break;
+    case eSeekFirst: tb->seekFirst();
+        break;
+    case eSeekGreaterOrEqual: tb->seekGreater(true);
+        break;
+    case eSeekGreater: tb->seekGreater(false);
+        break;
+    default:
+        assert(0);
+    readStatusCheck(*tb, _T("readIndex"));
+    }
+    return indexIterator(*tb);
+}
+
+inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op)
+{
+
+    switch (op)
+    {
+    case eSeekEqual: tb->seek();
+        break;
+    case eSeekLast: tb->seekLast();
+        break;
+    case eSeekLessThanOrEqual: tb->seekLessThan(true);
+        break;
+    case eSeekLessThan: tb->seekLessThan(false);
+        break;
+    default:
+        assert(0);
+    readStatusCheck(*tb, _T("readIndexRv"));
+    }
+    return indexRvIterator(*tb);
+}
+
+template<class T>
+inline indexIterator readIndex(table_ptr tb, eIndexOpType op, char_td keynum, T func)
+{
+    tb->setKeyNum(keynum);
+    if (&func)
+    {
+        fields fds(*tb);
+        func(fds);
+    }
+    return readIndex(tb, op);
+
+}
+
+template<class T>
+inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op, char_td keynum, T func)
+{
+    tb->setKeyNum(keynum);
+    if (&func)
+    {
+        fields fds(*tb);
+        func(fds);
+    }
+    return readIndexRv(tb, op);
+
+}
+
+
+template <class T0 = _TCHAR*, class T1 = _TCHAR*, class T2 = _TCHAR*, class T3 = _TCHAR*
+        , class T4 = _TCHAR*, class T5 = _TCHAR*, class T6 = _TCHAR*, class T7 = _TCHAR*>
+class keyValue
+{
+
+public:
+    inline static void set(table_ptr tb, const char_td keynum
+        ,const T0 kv0, const T1 kv1=NULL
+        ,const T2 kv2=NULL, const T3 kv3=NULL
+        ,const T4 kv4=NULL, const T5 kv5=NULL
+        ,const T6 kv6=NULL, const T7 kv7=NULL)
+    {
+        const tabledef& td = *tb->tableDef();
+        if (keynum < td.keyCount)
+        {
+            const keydef kd = td.keyDefs[keynum];
+            if (kd.segmentCount > 0)
+                tb->setFV(kd.segments[0].fieldNum, kv0);
+            if (kd.segmentCount > 1)
+                tb->setFV(kd.segments[1].fieldNum, kv1);
+            if (kd.segmentCount > 2)
+                tb->setFV(kd.segments[2].fieldNum, kv2);
+            if (kd.segmentCount > 3)
+                tb->setFV(kd.segments[3].fieldNum, kv3);
+            if (kd.segmentCount > 4)
+                tb->setFV(kd.segments[4].fieldNum, kv4);
+            if (kd.segmentCount > 5)
+                tb->setFV(kd.segments[5].fieldNum, kv5);
+            if (kd.segmentCount > 6)
+                tb->setFV(kd.segments[6].fieldNum, kv6);
+            if (kd.segmentCount > 7)
+                tb->setFV(kd.segments[7].fieldNum, kv7);
+        }
+        tb->setKeyNum(keynum);
+
+    }
+};
+
+template <class T0, class T1, class T2, class T3
+        , class T4, class T5, class T6, class T7>
+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)
+{
+    keyValue<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>
+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)
+{
+    keyValue<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>
+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)
+{
+    keyValue<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>
+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)
+{
+    keyValue<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>
+indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
+    ,const T0 kv0, const T1 kv1 ,const T2 kv2, const T3 kv3)
+{
+    keyValue<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
+    return readIndex(tb, op);
+}
+
+template <class T0, class T1, class T2>
+indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
+    ,const T0 kv0, const T1 kv1 ,const T2 kv2)
+{
+    keyValue<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
+    return readIndex(tb, op);
+}
+
+template <class T0, class T1>
+indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
+    ,const T0 kv0, const T1 kv1)
+{
+    keyValue<T0, T1>::set(tb, keynum, kv0, kv1);
+    return readIndex(tb, op);
+}
+
+template <class T0>
+indexIterator readIndex_v(table_ptr tb, eIndexOpType op, const char_td keynum
+    ,const T0 kv0)
+{
+    keyValue<T0>::set(tb, keynum, kv0);
+    return readIndex(tb, op);
+}
+
+
+template <class T0, class T1, class T2, class T3
+        , class T4, class T5, class T6, class T7>
+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)
+{
+    keyValue<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>
+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)
+{
+    keyValue<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>
+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)
+{
+    keyValue<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>
+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)
+{
+    keyValue<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>
+indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
+    ,const T0 kv0, const T1 kv1 ,const T2 kv2, const T3 kv3)
+{
+    keyValue<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
+    return readIndexRv(tb, op);
+}
+
+template <class T0, class T1, class T2>
+indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
+    ,const T0 kv0, const T1 kv1 ,const T2 kv2)
+{
+    keyValue<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
+    return readIndexRv(tb, op);
+}
+
+template <class T0, class T1>
+indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
+    ,const T0 kv0, const T1 kv1)
+{
+    keyValue<T0, T1>::set(tb, keynum, kv0, kv1);
+    return readIndexRv(tb, op);
+}
+
+template <class T0>
+indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op, const char_td keynum
+    ,const T0 kv0)
+{
+    keyValue<T0>::set(tb, keynum, kv0);
+    return readIndexRv(tb, op);
+}
+
+
+
+inline stepIterator readStep(table_ptr tb)
+{
+    tb->stepFirst();
+    return stepIterator(*tb);
+}
+
+inline stepRvIterator readStepRv(table_ptr tb)
+{
+    tb->stepLast();
+    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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<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);
+}
+
+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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6);
+    tb->find(table::findForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5);
+    tb->find(table::findForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4);
+    tb->find(table::findForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
+    tb->find(table::findForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
+    tb->find(table::findForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1>::set(tb, keynum, kv0, kv1);
+    tb->find(table::findForword);
+	return findIterator(*tb);
+}
+
+template <class T0>
+findIterator find(table_ptr tb, const char_td keynum, const filterParams& fp
+    ,const T0 kv0)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0>::set(tb, keynum, kv0);
+    tb->find(table::findForword);
+	return findIterator(*tb);
+}
+
+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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<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);
+}
+
+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());
+	keyValue<T0, T1, T2, T3, T4, T5, T6>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5, kv6);
+    tb->find(table::findBackForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2, T3, T4, T5>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4, kv5);
+    tb->find(table::findBackForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2, T3, T4>::set(tb, keynum, kv0, kv1, kv2, kv3, kv4);
+    tb->find(table::findBackForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2, T3>::set(tb, keynum, kv0, kv1, kv2, kv3);
+    tb->find(table::findBackForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
+    tb->find(table::findBackForword);
+	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)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0, T1>::set(tb, keynum, kv0, kv1);
+    tb->find(table::findBackForword);
+	return findRvIterator(*tb);
+}
+
+template <class T0>
+findRvIterator findRv(table_ptr tb, const char_td keynum, const filterParams& fp
+    ,const T0 kv0)
+{
+    tb->setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+	keyValue<T0>::set(tb, keynum, kv0);
+    tb->find(table::findBackForword);
+	return findRvIterator(*tb);
+}
+
+
+
+inline findIterator getFindIterator(indexIterator it, const filterParams& fp
+                    ,bool isCurrentValid)
+
+{
+    if (it != indexIterator::eos)
+	{
+        it.tb().setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+		if (!isCurrentValid)
+			it.tb().findNext(false);
+	}
+    return findIterator(it.tb());
+}
+
+inline findRvIterator getFindIterator(indexRvIterator it, const filterParams& fp
+                    ,bool isCurrentValid)
+{
+    if (it != indexRvIterator::eos)
+        it.tb().setFilter(fp.filter(), fp.rejectCount(), fp.maxRecords());
+    if (!isCurrentValid)
+        it.tb().findPrev(false);
+    return findRvIterator(it.tb());
+}
+
+
+class connectParams
+{
+    _TCHAR m_buf[MAX_PATH];
+    short m_mode;
+    short m_type;
+
+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 explicit connectParams(const _TCHAR* uri) : m_mode(TD_OPEN_READONLY), m_type(TYPE_SCHEMA_BDF)
+    {
+        _tcscpy_s(m_buf, MAX_PATH, uri);
+
+    }
+    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()
+{
+    database_ptr p(database::create(), releaseDatabase);
+    return p;
+}
+
+inline void connect(database_ptr db, const connectParams& connPrams, bool newConnection)
+{
+    db->connect(connPrams.uri(), newConnection);
+    if (db->stat())
+        nstable::throwError((std::_tstring(_T("Connect database ")) + connPrams.uri()).c_str(), db->stat());
+
+}
+
+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());
+
+}
+
+inline void disconnect(database_ptr db)
+{
+    db->disconnect();
+    if (db->stat())
+        nstable::throwError(_T("Disconnect database "), db->stat());
+
+}
+
+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());
+}
+
+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());
+}
+
+
+inline void openDatabase(database_ptr db, const connectParams& 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());
+
+}
+
+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());
+
+}
+
+inline void dropDatabase(database_ptr db)
+{
+    db->drop();
+    if (db->stat())
+        nstable::throwError(std::_tstring(_T("Drop database ")).c_str(), db->stat());
+
+}
+
+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());
+    return p;
+
+}
+inline void convertTable(database_ptr db, short tableid, copyDataFn func=NULL)
+{
+
+    if (db->existsTableFile(tableid, NULL))
+    {
+        db->setOnCopyData(func);
+        db->convertTable(tableid, false, NULL);
+        db->setOnCopyData(NULL);
+        if (db->stat())
+        {
+            assert(db->dbDef());
+            db->dbDef()->popBackup(tableid);
+            nstable::throwError(std::_tstring(_T("Convert table ")).c_str(), db->stat());
+        }
+    }
+}
+
+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)
+{
+    tabledef td;
+    td.setTableName(name);
+    td.setFileName(name);
+    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());
+}
+
+inline fielddef* insertField(dbdef* def, short tableid, short fieldNum
+    , const _TCHAR* name, uchar_td type, ushort_td len )
+{
+
+    fielddef* fd =  def->insertField(tableid, fieldNum);
+    if (def->stat() != 0)
+        nstable::throwError((std::_tstring(_T("Insert fielddef ")) + name).c_str(), def->stat());
+
+    fd->setName(name);
+    fd->type = type;
+    fd->len = len;
+    return fd;
+}
+
+inline keydef* insertKey(dbdef* def, short tableid, short insertIndex)
+{
+    keydef* kd =  def->insertKey(tableid, insertIndex);
+    if (def->stat() != 0)
+        nstable::throwError(std::_tstring(_T("Insert keydef ")).c_str(), def->stat());
+    return kd;
+}
+
+inline void updateTableDef(dbdef* def, short tableid)
+{
+    def->updateTableDef(tableid);
+    if (def->stat() != 0)
+    {
+        std::_tstring s;
+        if (def->tableDefs(tableid))
+            s = def->tableDefs(tableid)->tableName();
+        nstable::throwError((std::_tstring(_T("Update tabledef ")) + s).c_str(), def->stat());
+    }
+}
+
+template <class T>
+inline void insertRecord(const T& it, bool ncc = true)
+{
+    it.tb().insert(ncc);
+    if (it.tb().stat() != 0)
+        nstable::throwError(std::_tstring(_T("Insert record")).c_str(), it.tb().stat());
+
+}
+
+template <class T>
+inline void updateRecord(const T& it, bool ncc = true)
+{
+    it.tb().update((nstable::eUpdateType)ncc);
+    if (it.tb().stat() != 0)
+        nstable::throwError(std::_tstring(_T("Update record")).c_str(), it.tb().stat());
+
+}
+
+inline void updateRecord(fields& fd, char_td keynum)
+{
+    fd.tb().setKeyNum(keynum);
+	fd.tb().update(nstable::changeInKey);
+    if (fd.tb().stat() != 0)
+        nstable::throwError(std::_tstring(_T("Update record")).c_str(), fd.tb().stat());
+}
+
+inline void deleteRecord(fields& fd, const char_td keynum)
+{
+    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().stat());
+}
+
+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)
+{
+	keyValue<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);
+}
+
+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)
+{
+	keyValue<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)
+{
+	keyValue<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)
+{
+	keyValue<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)
+{
+	keyValue<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)
+{
+	keyValue<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)
+{
+	keyValue<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)
+{
+	keyValue<T0>::set(tb, keynum, kv0);
+	fields fd(tb);
+	deleteRecord(fd, keynum);
+}
+
+template <class T>
+inline void deleteRecord(const T& it)
+{
+	it.tb().del(false/*inKey*/);
+	if (it.tb().stat() != 0)
+		nstable::throwError(std::_tstring(_T("Delete record")).c_str(), it.tb().stat());
+}
+
+
+template<class T, class F>
+void for_each(T iterator, F func) {std::for_each(iterator, T::eos, func);}
+
+class transaction
+{
+    database_ptr 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();}
+
+};
+
+class autoSnapshot
+{
+    database_ptr m_db;
+public:
+    autoSnapshot(database_ptr db):m_db(db)
+    {
+        m_db->beginSnapshot();
+    }
+
+    ~autoSnapshot()
+    {
+        m_db->endSnapshot();
+    }
+};
+
+
+class autoBulkinsert
+{
+    table_ptr m_tb;
+public:
+    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
+
+
+
+#endif