transactd 2.0.1 → 2.1.0

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

@@ -21,6 +21,8 @@
 #include "nsTable.h"
 #include <vector>
 #include <stdio.h>
+#include <boost/shared_ptr.hpp>
+
 namespace bzs
 {
 
@@ -57,6 +59,7 @@ public:
     virtual ~multiRecordAlocator() {}
     virtual void init(size_t recordCount, size_t recordLen, int addType,
                       const class table* tb) = 0;
+    virtual unsigned char* allocBlobBlock(size_t size) = 0;
     virtual unsigned char* ptr(size_t row, int stat) = 0;
     virtual void setJoinType(int v) = 0;
     virtual void setInvalidRecord(size_t row, bool v) = 0;
@@ -67,21 +70,26 @@ public:
     virtual void removeLastMemBlock(int row) = 0;
 };
 
+class filter;
+typedef boost::shared_ptr<filter> pq_handle; 
+
 /** @endcond */
 
 class DLLLIB table : public nstable
 {
+    static void* __STDCALL DDBA(client::table* tb, uint_td size);
+
     friend class recordCache;
     friend class database;
     friend class filter;
     friend class fields;
+    friend struct logic;
 
     struct tbimpl* m_impl;
     class fielddefs* m_fddefs;
     tabledef* m_tableDef;
 
     uchar_td charset() const;
-    bool checkFindDirection(ushort_td op);
     bool checkIndex(short index) const;
     void getKeySpec(keySpec* ks, bool SpecifyKeyNum = false);
     const bzs::db::blobHeader* getBlobHeader();
@@ -102,12 +110,14 @@ class DLLLIB table : public nstable
     bool setSeekValueField(int row);
     void btrvSeekMulti();
     bool doSeekMultiAfter(int row);
-
+    void* doDdba(uint_td size);
+    bool recordsLoop(ushort_td& op);
 protected:
     explicit table(nsdatabase* pbe); // Inheritance is impossible
     virtual ~table();
     void* dataBak() const;
-    void setDataBak(void* v);
+    void* reallocDataBuffer(uint_td v);
+    int dataBufferLen() const;
     void setBookMarks(int StartId, void* Data, ushort_td Count);
     uint_td unPack(char* ptr, size_t size);
     uint_td pack(char* ptr, size_t size);
@@ -131,6 +141,7 @@ protected:
     void init(tabledef* def, short filenum, bool regularDir);
     void* attachBuffer(void* newPtr, bool unpack = false, size_t size = 0);
     void dettachBuffer();
+    bool doPrepare();
 
     virtual void doInit(tabledef* def, short filenum, bool regularDir);
 
@@ -178,7 +189,13 @@ public:
     void findNext(bool notIncCurrent = true);
     void findPrev(bool notIncCurrent = true);
     bookmark_td bookmarkFindCurrent() const;
-    void setQuery(const queryBase* query);
+    pq_handle setQuery(const queryBase* query, bool serverPrepare=false);
+    pq_handle prepare(const queryBase* query, bool serverPrepare=false)
+    {
+        return setQuery(query, serverPrepare);
+    }
+    void setPrepare(const pq_handle stmt);
+
     void setFilter(const _TCHAR* str, ushort_td rejectCount,
                    ushort_td cacheCount, bool autoEscape = true);
     short fieldNumByName(const _TCHAR* name);
@@ -389,7 +406,9 @@ inline std::_tstring lexical_cast(float v)
 
 inline std::_tstring lexical_cast(const _TCHAR* v)
 {
-    return std::_tstring(v);
+    if (v)
+        return std::_tstring(v);
+    return std::_tstring(_T(""));
 }
 
 class qlogic
@@ -578,6 +597,30 @@ public:
     static query* create(); // implemet int activeTable.cpp
 };
 
+/** @cond INTERNAL */
+int DLLLIB makeSupplyValues(/*in out*/const _TCHAR* values[], int size,
+                         const _TCHAR* value, const _TCHAR* value1 = NULL,
+                         const _TCHAR* value2 = NULL, const _TCHAR* value3 = NULL,
+                         const _TCHAR* value4 = NULL, const _TCHAR* value5 = NULL,
+                         const _TCHAR* value6 = NULL, const _TCHAR* value7 = NULL,
+                         const _TCHAR* value8 = NULL, const _TCHAR* value9 = NULL,
+                         const _TCHAR* value10 = NULL);
+/** @endcond */
+
+bool DLLLIB supplyValues(pq_handle& filter, const _TCHAR* values[], int size);
+bool DLLLIB supplyValue(pq_handle& filter, int index, const _TCHAR* v);
+bool DLLLIB supplyValue(pq_handle& filter, int index, short v);
+bool DLLLIB supplyValue(pq_handle& filter, int index, int v);
+bool DLLLIB supplyValue(pq_handle& filter, int index, __int64 v);
+bool DLLLIB supplyValue(pq_handle& filter, int index, float v);
+bool DLLLIB supplyValue(pq_handle& filter, int index, double v);
+
+//bool DLLLIB supplyInValues(pq_handle& filter, const _TCHAR* values[], size_t size, int segments);
+
+
+
+
+
 #pragma warning(default : 4251)
 
 } // namespace client

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

@@ -1,7 +1,7 @@
 #ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_TRDBOOSTAPI_H
 #define BZS_DB_PROTOCOL_TDAP_CLIENT_TRDBOOSTAPI_H
 /*=================================================================
-   Copyright (C) 2013 BizStation Corp All rights reserved.
+   Copyright (C) 2013 2014 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
@@ -22,7 +22,6 @@
 #include <boost/shared_ptr.hpp>
 #include <boost/noncopyable.hpp>
 #include <iterator>
-
 #include <stdio.h>
 
 #if defined(__GNUC__)
@@ -78,8 +77,11 @@ public:
                          const _TCHAR* dbname, const _TCHAR* schemaTable)
         : m_type(TYPE_SCHEMA_BDF), m_mode(TD_OPEN_READONLY)
     {
-        _stprintf_s(m_buf, MAX_PATH, _T("%s://%s/%s?dbfile=%s.bdf"), protocol,
-                    hostOrIp, dbname, schemaTable);
+        const _TCHAR* ext = _T(".bdf");
+        if (_tcscmp(schemaTable, TRANSACTD_SCHEMANAME)==0)
+            ext = _T("");
+        _stprintf_s(m_buf, MAX_PATH, _T("%s://%s/%s?dbfile=%s%s"), protocol,
+                    hostOrIp, dbname, schemaTable, ext);
     }
     inline explicit connectParams(const _TCHAR* uri)
         : m_type(TYPE_SCHEMA_BDF), m_mode(TD_OPEN_READONLY)
@@ -92,11 +94,14 @@ public:
     {
         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"));
+            if ((_tcslen(m_buf) > 3) && m_buf[_tcslen(m_buf) - 3] == _T('.'))
+            {
+                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;
     }
@@ -182,7 +187,7 @@ public:
     virtual void endTrn() = 0;
     virtual void abortTrn() = 0;
     virtual int enableTrn() = 0;
-    virtual void beginSnapshot() = 0;
+    virtual void beginSnapshot(short bias = CONSISTENT_READ) = 0;
     virtual void endSnapshot() = 0;
     virtual const _TCHAR* uri() const = 0;
     virtual char_td mode() const = 0;
@@ -198,28 +203,31 @@ class tableIterator
 
     table& m_tb;
     fields m_fds;
+    ushort_td m_lockBias;
 
 public:
-    inline tableIterator(table& tb) : m_tb(tb), m_fds(tb)
+    inline tableIterator(table& tb, ushort_td lockBias = 0) : m_tb(tb), m_fds(tb),m_lockBias(lockBias)
     {
         readStatusCheck(tb, _T("tableIterator"));
     }
 
     table& tb() const { return m_tb; };
 
+    void setLockBias(ushort_td v) { m_lockBias = v; }
+
     inline fields& operator*() { return m_fds; }
 
     inline fields* operator->() { return &m_fds; }
 
     inline tableIterator& operator++()
     {
-        T::increment(m_tb);
+        T::increment(m_tb, m_lockBias);
         return *this;
     }
 
     inline tableIterator& operator--()
     {
-        T::decrement(m_tb);
+        T::decrement(m_tb, m_lockBias);
         return *this;
     }
 
@@ -304,57 +312,57 @@ typedef filterdIterator<indexRvIterator> filterdIndexRvIterator;
 typedef filterdIterator<stepRvIterator> filterdStepRvIterator;
 typedef filterdIterator<findRvIterator> filterdFindRvIterator;
 
-inline indexIterator readIndex(table_ptr tb, eIndexOpType op)
+inline indexIterator readIndex(table_ptr tb, eIndexOpType op, ushort_td lockBias = 0)
 {
 
     switch (op)
     {
     case eSeekEqual:
-        tb->seek();
+        tb->seek(lockBias);
         break;
     case eSeekFirst:
-        tb->seekFirst();
+        tb->seekFirst(lockBias);
         break;
     case eSeekGreaterOrEqual:
-        tb->seekGreater(true);
+        tb->seekGreater(true, lockBias);
         break;
     case eSeekGreater:
-        tb->seekGreater(false);
+        tb->seekGreater(false, lockBias);
         break;
     default:
         assert(0);
         readStatusCheck(*tb, _T("readIndex"));
     }
-    return indexIterator(*tb);
+    return indexIterator(*tb, lockBias);
 }
 
-inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op)
+inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op, ushort_td lockBias = 0)
 {
 
     switch (op)
     {
     case eSeekEqual:
-        tb->seek();
+        tb->seek(lockBias);
         break;
     case eSeekLast:
-        tb->seekLast();
+        tb->seekLast(lockBias);
         break;
     case eSeekLessThanOrEqual:
-        tb->seekLessThan(true);
+        tb->seekLessThan(true, lockBias);
         break;
     case eSeekLessThan:
-        tb->seekLessThan(false);
+        tb->seekLessThan(false, lockBias);
         break;
     default:
         assert(0);
         readStatusCheck(*tb, _T("readIndexRv"));
     }
-    return indexRvIterator(*tb);
+    return indexRvIterator(*tb, lockBias);
 }
 
 template <class T>
 inline indexIterator readIndex(table_ptr tb, eIndexOpType op, char_td keynum,
-                               T func)
+                               T func, ushort_td lockBias = 0)
 {
     tb->setKeyNum(keynum);
     if (&func)
@@ -362,12 +370,12 @@ inline indexIterator readIndex(table_ptr tb, eIndexOpType op, char_td keynum,
         fields fds(*tb);
         func(fds);
     }
-    return readIndex(tb, op);
+    return readIndex(tb, op, lockBias);
 }
 
 template <class T>
 inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op,
-                                   char_td keynum, T func)
+                                   char_td keynum, T func, ushort_td lockBias = 0)
 {
     tb->setKeyNum(keynum);
     if (&func)
@@ -375,7 +383,7 @@ inline indexRvIterator readIndexRv(table_ptr tb, eIndexOpType op,
         fields fds(*tb);
         func(fds);
     }
-    return readIndexRv(tb, op);
+    return readIndexRv(tb, op, lockBias);
 }
 
 template <class T0, class T1, class T2, class T3, class T4, class T5, class T6,
@@ -542,118 +550,143 @@ inline indexRvIterator readIndexRv_v(table_ptr tb, eIndexOpType op,
 }
 /** @endcond */
 
-inline stepIterator readStep(table_ptr tb)
+inline stepIterator readStep(table_ptr tb, ushort_td lockBias = 0)
 {
-    tb->stepFirst();
-    return stepIterator(*tb);
+    tb->stepFirst(lockBias);
+    return stepIterator(*tb, lockBias);
 }
 
-inline stepRvIterator readStepRv(table_ptr tb)
+inline stepRvIterator readStepRv(table_ptr tb, ushort_td lockBias = 0)
 {
-    tb->stepLast();
-    return stepRvIterator(*tb);
+    tb->stepLast(lockBias);
+    return stepRvIterator(*tb, lockBias);
 }
 
-template <class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+
+inline pq_handle setQuery(table_ptr& tb, const queryBase& q, 
+                          bool serverPrepare = false) 
+{ 
+    pq_handle stmt =  tb->setQuery(&q, serverPrepare);
+    readStatusCheck(*tb, _T("setQuery"));
+    return stmt;
+}
+
+/** @cond INTERNAL */
+inline pq_handle setQuery(table_ptr& tb, const pq_handle& q) 
+{ 
+    tb->setPrepare(q); 
+    return q;
+}
+/** @endcond */
+
+inline pq_handle prepare(table_ptr& tb, const queryBase& q, bool serverPrepare=false)
+{
+    pq_handle stmt = tb->prepare(&q, serverPrepare);
+    readStatusCheck(*tb, _T("prepare"));
+    return stmt;
+}
+
+template <class Q, 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,
+inline findIterator find(table_ptr tb, const char_td keynum, const Q& 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->setQuery(&q);
+    setQuery(tb, 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);
 }
 
+
 /** @cond INTERNAL */
 
-template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
-inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+template <class Q, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+inline findIterator find(table_ptr tb, const char_td keynum, const Q& 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);
+    setQuery(tb, 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);
 }
 
-template <class T0, class T1, class T2, class T3, class T4, class T5>
-inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+template <class Q, class T0, class T1, class T2, class T3, class T4, class T5>
+inline findIterator find(table_ptr tb, const char_td keynum, const Q& q,
                          const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
                          const T4 kv4, const T5 kv5)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<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>
-inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+template <class Q, class T0, class T1, class T2, class T3, class T4>
+inline findIterator find(table_ptr tb, const char_td keynum, const Q& q,
                          const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3,
                          const T4 kv4)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<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>
-inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+template <class Q, class T0, class T1, class T2, class T3>
+inline findIterator find(table_ptr tb, const char_td keynum, const Q& q,
                          const T0 kv0, const T1 kv1, const T2 kv2, const T3 kv3)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<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>
-inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+template <class Q, class T0, class T1, class T2>
+inline findIterator find(table_ptr tb, const char_td keynum, const Q& q,
                          const T0 kv0, const T1 kv1, const T2 kv2)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
     tb->find(table::findForword);
     return findIterator(*tb);
 }
 
-template <class T0, class T1>
-inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+template <class Q, class T0, class T1>
+inline findIterator find(table_ptr tb, const char_td keynum, const Q& q,
                          const T0 kv0, const T1 kv1)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
     tb->find(table::findForword);
     return findIterator(*tb);
 }
 
-template <class T0>
-inline findIterator find(table_ptr tb, const char_td keynum, const queryBase& q,
+template <class Q, class T0>
+inline findIterator find(table_ptr tb, const char_td keynum, const Q& q,
                          const T0 kv0)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<T0>::set(tb, keynum, kv0);
     tb->find(table::findForword);
     return findIterator(*tb);
 }
 /** @endcond */
 
-template <class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+template <class Q, 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 Q& 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->setQuery(&q);
+    setQuery(tb, 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);
@@ -662,80 +695,80 @@ inline findRvIterator findRv(table_ptr tb, const char_td keynum,
 
 /** @cond INTERNAL */
 
-template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+template <class Q, class T0, class T1, class T2, class T3, class T4, class T5, class T6>
 inline findRvIterator findRv(table_ptr tb, const char_td keynum,
-                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const Q& 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);
+    setQuery(tb, 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);
 }
 
-template <class T0, class T1, class T2, class T3, class T4, class T5>
+template <class Q, class T0, class T1, class T2, class T3, class T4, class T5>
 inline findRvIterator
-findRv(table_ptr tb, const char_td keynum, const queryBase& q, const T0 kv0,
+findRv(table_ptr tb, const char_td keynum, const Q& q, const T0 kv0,
        const T1 kv1, const T2 kv2, const T3 kv3, const T4 kv4, const T5 kv5)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<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>
+template <class Q, class T0, class T1, class T2, class T3, class T4>
 inline findRvIterator findRv(table_ptr tb, const char_td keynum,
-                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const Q& q, const T0 kv0, const T1 kv1,
                              const T2 kv2, const T3 kv3, const T4 kv4)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<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>
+template <class Q, class T0, class T1, class T2, class T3>
 inline findRvIterator findRv(table_ptr tb, const char_td keynum,
-                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const Q& q, const T0 kv0, const T1 kv1,
                              const T2 kv2, const T3 kv3)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<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>
+template <class Q, class T0, class T1, class T2>
 inline findRvIterator findRv(table_ptr tb, const char_td keynum,
-                             const queryBase& q, const T0 kv0, const T1 kv1,
+                             const Q& q, const T0 kv0, const T1 kv1,
                              const T2 kv2)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<T0, T1, T2>::set(tb, keynum, kv0, kv1, kv2);
     tb->find(table::findBackForword);
     return findRvIterator(*tb);
 }
 
-template <class T0, class T1>
+template <class Q, class T0, class T1>
 inline findRvIterator findRv(table_ptr tb, const char_td keynum,
-                             const queryBase& q, const T0 kv0, const T1 kv1)
+                             const Q& q, const T0 kv0, const T1 kv1)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<T0, T1>::set(tb, keynum, kv0, kv1);
     tb->find(table::findBackForword);
     return findRvIterator(*tb);
 }
 
-template <class T0>
+template <class Q, class T0>
 inline findRvIterator findRv(table_ptr tb, const char_td keynum,
-                             const queryBase& q, const T0 kv0)
+                             const Q& q, const T0 kv0)
 {
-    tb->setQuery(&q);
+    setQuery(tb, q); 
     keyValueSetter<T0>::set(tb, keynum, kv0);
     tb->find(table::findBackForword);
     return findRvIterator(*tb);
@@ -892,15 +925,28 @@ template <class Database_Ptr> inline void dropDatabase(Database_Ptr db)
 }
 
 template <class Database_Ptr>
-inline table_ptr openTable(Database_Ptr db, const _TCHAR* name)
+inline table_ptr openTable(Database_Ptr db, const _TCHAR* name, short mode = TD_OPEN_NORMAL)
 {
-    table_ptr p(db->openTable(name), releaseTable);
+    table_ptr p(db->openTable(name, mode), releaseTable);
     if (db->stat())
         nstable::throwError((std::_tstring(_T("Open table ")) + name).c_str(),
                             db->stat());
     return p;
 }
 
+template <class Database_Ptr>
+inline table_ptr openTable(Database_Ptr db, short tableid, short mode = TD_OPEN_NORMAL)
+{
+    table_ptr p(db->openTable(tableid, mode), releaseTable);
+    if (db->stat())
+    {
+        _TCHAR buf[50];
+        _stprintf_s(buf, 50, _T("Open table id = %d"), tableid);
+        nstable::throwError(buf, db->stat());
+    }
+    return p;
+}
+
 template <class Database_Ptr>
 inline void dropTable(Database_Ptr db, const _TCHAR* name)
 {
@@ -1160,7 +1206,7 @@ template <class DB> class transaction
     short m_bias;
 
 public:
-    inline transaction(DB db, short bias = LOCK_SINGLE_NOWAIT + PARALLEL_TRN +
+    inline transaction(DB db, short bias = SINGLELOCK_READ_COMMITED +
                                            NOWAIT_WRITE)
         : m_db(db), m_bias(bias){};
     inline ~transaction()
@@ -1184,7 +1230,7 @@ template <class DB> class snapshot
     DB m_db;
 
 public:
-    snapshot(DB db) : m_db(db) { m_db->beginSnapshot(); }
+    snapshot(DB db, short bias = CONSISTENT_READ) : m_db(db) { m_db->beginSnapshot(bias); }
 
     ~snapshot() { m_db->endSnapshot(); }
 };