transactd 2.0.1 → 2.1.0

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

@@ -103,15 +103,16 @@ struct joinInfo
 
 #define JOIN_KEYVALUE_TYPE_PTR 0
 #define JOIN_KEYVALUE_TYPE_STR 1
-
+#define MAX_JOIN_KEY_SIZE 8
 class activeTableImple : public activeObject<map_orm>
 {
 
     typedef recordsetImple Container;
-    typedef boost::shared_ptr<writableRecord> record;
+    typedef writableRecord* record;
     typedef activeObject<map_orm> baseClass_type;
     typedef std::vector<std::vector<int> > joinmap_type;
     record m_record;
+    int m_tmpIndex;
 
     // return can memcpy
     uchar_td convertFieldType(uchar_td v)
@@ -130,23 +131,24 @@ class activeTableImple : public activeObject<map_orm>
     }
 
     template <class Container>
-    inline void
-    makeJoinFieldInfo(Container& mdls, const fielddefs* fds,
-                      const fieldNames& fns,
+    inline bool makeJoinFieldInfo(Container& mdls, const fielddefs* fds,
+                      const _TCHAR*  fns[], int fnsCount,
                       std::vector<typename Container::key_type>& fieldIndexes,
                       std::vector<joinInfo>& joinFields)
     {
-        joinFields.resize(fns.count());
-        fieldIndexes.resize(fns.count());
+        joinFields.resize(fnsCount);
+        fieldIndexes.resize(fnsCount);
         const tabledef* td = table()->tableDef();
         const keydef* kd = &td->keyDefs[table()->keyNum()];
-        if (kd->segmentCount < fns.count())
+        if (kd->segmentCount < fnsCount)
             THROW_BZS_ERROR_WITH_MSG(_T("Join key fields are too many.\n ")
                                      _T("Check index number and field count."));
 
-        for (int i = 0; i < fns.count(); ++i)
+        bool hasMany = ((kd->segmentCount > fnsCount) || kd->segments[0].flags.bit0);/* duplicate key*/
+
+        for (int i = 0; i < fnsCount; ++i)
         {
-            std::_tstring s = fns.getValue(i);
+            std::_tstring s = fns[i];
             if (s[0] == '[')
             {
                 fieldIndexes[i] = -1;
@@ -174,29 +176,7 @@ class activeTableImple : public activeObject<map_orm>
                 }
             }
         }
-    }
-
-    template <class Container>
-    inline void
-    addSeekValues(row& mdl, queryBase& q,
-                  std::vector<typename Container::key_type>& fieldIndexes,
-                  std::vector<joinInfo>& joinFields)
-    {
-        for (int i = 0; i < (int)fieldIndexes.size(); ++i)
-        {
-            if (fieldIndexes[i] == -1)
-                q.addSeekKeyValuePtr(joinFields[i].fixedValue.c_str(),
-                                     joinFields[i].len, KEYVALUE_STR);
-            else if (joinFields[i].type == JOIN_KEYVALUE_TYPE_PTR)
-                q.addSeekKeyValuePtr(mdl[fieldIndexes[i]].ptr(),
-                                     joinFields[i].len, KEYVALUE_PTR);
-            else
-            {
-                const _TCHAR* p = mdl[fieldIndexes[i]].c_str();
-                q.addSeekKeyValuePtr(p, (ushort_td)_tcslen(p),
-                                     KEYVALUE_STR_NEED_COPY);
-            }
-        }
+        return hasMany;
     }
 
     template <class Container>
@@ -220,64 +200,106 @@ class activeTableImple : public activeObject<map_orm>
         }
     }
 
+
     template <class Container>
-    void doJoin(bool innner, Container& mdls, queryBase& q, const _TCHAR* name1,
+    inline void addSeekValues(row& mdl, pq_handle& q,
+                  std::vector<typename Container::key_type>& fieldIndexes,
+                  std::vector<joinInfo>& joinFields)
+    {
+        const uchar_td* ptr[8];
+        int len[8];
+        for (int i = 0; i < (int)fieldIndexes.size(); ++i)
+        {
+            if (fieldIndexes[i] == -1)
+            {
+                ptr[i] = (const uchar_td*)joinFields[i].fixedValue.c_str();
+                len[i] = joinFields[i].len;
+            }
+            else if (joinFields[i].type == JOIN_KEYVALUE_TYPE_PTR)
+            {    
+                ptr[i] = (const uchar_td*)mdl[fieldIndexes[i]].ptr();
+                len[i] = joinFields[i].len;
+            }
+            else
+            {
+                const _TCHAR* p = mdl[fieldIndexes[i]].c_str();
+                ptr[i] = (const uchar_td*)p;
+                len[i] = (int)_tcslen(p);
+            }
+        }
+    
+        if (!q->supplySeekValue(ptr, len, (int)fieldIndexes.size(), m_tmpIndex))
+            THROW_BZS_ERROR_WITH_MSG(_T("Join key value(s) are invalid at supply values to prepared statement or query.\n ")
+                                     _T("Check prepared statement or query."));
+    }
+
+    int makeJoinKeys(const _TCHAR* fns[MAX_JOIN_KEY_SIZE], int &fnsCount, const _TCHAR* name1,
                 const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
                 const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
                 const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
                 const _TCHAR* name8 = NULL)
     {
-        if (mdls.size() == 0)
-            return;
-        m_alias.reverseAliasNamesQuery(q);
-        q.clearSeekKeyValues();
+        int count = 0;
+        fns[0] = name1; fns[1] = name2; fns[2] = name3; fns[3] = name4;
+        fns[4] = name5; fns[5] = name6; fns[6] = name7; fns[7] = name8;
+        
+        for (count = 0; count < MAX_JOIN_KEY_SIZE; ++count)
+            if ((fns[count] == NULL) || (fns[count][0] == 0x00))
+                break;
+        return count;
+    }
 
+    inline void reserveSeekSize(pq_handle& q,  size_t size, int keySize)
+    {
+        q->beginSupplySeekValues(size, keySize);
+        m_tmpIndex = 0;
+    }
+
+    template <class Container>
+    void doJoin(bool innner, Container& mdls, pq_handle& stmt, const _TCHAR* fns[8], int fnsCount)
+    {
+        stmt->clearSeeks();
         mraResetter mras(m_tb);
         typename Container::iterator it = mdls.begin(), ite = mdls.end();
 
-        bool optimize = !(q.getOptimize() & queryBase::joinHasOneOrHasMany);
         joinmap_type joinRowMap;
 
-        fieldNames fns;
-        fns.keyField(name1, name2, name3, name4, name5, name6, name7, name8);
-
         std::vector<typename Container::key_type> fieldIndexes;
         std::vector<joinInfo> joinFields;
 
         const fielddefs* fds = mdls.fieldDefs();
-        makeJoinFieldInfo<Container>(mdls, fds, fns, fieldIndexes, joinFields);
+        bool hasMany = makeJoinFieldInfo<Container>(mdls, fds, fns, fnsCount, fieldIndexes, joinFields);
+        if (!hasMany)
+            hasMany = (stmt->cachedOptimaize() & queryBase::joinHasOneOrHasMany);
 
         // optimizing join
         // if base recordsetImple is made by unique key and join by uniqe field,
         // that can not opitimize.
         //
-        q.joinKeySize(fns.count());
-        if (optimize)
+        if (!hasMany)
         {
             makeJoinMap(mdls, joinRowMap, fieldIndexes);
-            q.reserveSeekKeyValuePtrSize(joinRowMap.size() *
-                                         fieldIndexes.size());
+            reserveSeekSize(stmt, joinRowMap.size() * fieldIndexes.size(), fnsCount);
             std::vector<std::vector<int> >::iterator it1 = joinRowMap.begin(),
                                                      ite1 = joinRowMap.end();
             while (it1 != ite1)
             {
                 row& mdl = *(mdls.getRow((*it1)[0]));
-                addSeekValues<Container>(mdl, q, fieldIndexes, joinFields);
+                addSeekValues<Container>(mdl, stmt, fieldIndexes, joinFields);
                 ++it1;
             }
         }
         else
         {
-            q.reserveSeekKeyValuePtrSize(mdls.size() * fieldIndexes.size());
+            reserveSeekSize(stmt, mdls.size() * fieldIndexes.size(), fnsCount);
             while (it != ite)
             {
                 row& mdl = *(*it);
-                addSeekValues<Container>(mdl, q, fieldIndexes, joinFields);
+                addSeekValues<Container>(mdl, stmt, fieldIndexes, joinFields);
                 ++it;
             }
         }
 
-        m_tb->setQuery(&q);
         if (m_tb->stat() != 0)
             nstable::throwError(_T("activeObject Join Query"), &(*m_tb));
 
@@ -289,7 +311,7 @@ class activeTableImple : public activeObject<map_orm>
         if (m_tb->mra())
         {
             m_tb->mra()->setJoinType(innner ? mra_innerjoin : mra_outerjoin);
-            if (optimize)
+            if (!hasMany)
                 m_tb->mra()->setJoinRowMap(&joinRowMap);
         }
         m_tb->find();
@@ -320,21 +342,36 @@ class activeTableImple : public activeObject<map_orm>
         }
     }
 
+    inline void checkPreparedQuery(pq_handle& q)
+    {
+        if (!q)
+            THROW_BZS_ERROR_WITH_MSG(_T("Invalid query or prepqredQuery.\n "));
+    }
+
 public:
     explicit activeTableImple(idatabaseManager* mgr, const _TCHAR* tableName)
-        : baseClass_type(mgr, tableName){};
+        : baseClass_type(mgr, tableName), m_record(NULL){};
 
     explicit activeTableImple(database_ptr& db, const _TCHAR* tableName)
-        : baseClass_type(db, tableName){};
+        : baseClass_type(db, tableName), m_record(NULL){};
 
     explicit activeTableImple(database* db, const _TCHAR* tableName)
-        : baseClass_type(db, tableName){};
+        : baseClass_type(db, tableName), m_record(NULL){};
+
+    ~activeTableImple()
+    {
+        if (m_record)
+            m_record->release();
+    }
 
     inline writableRecord& getWritableRecord()
     {
-        m_record.reset(writableRecord::create(m_tb.get(), &m_alias),
-                       &writableRecord::release);
-        return *m_record.get();
+        if (m_record == NULL)
+        {
+            m_record = writableRecord::create(m_tb.get(), &m_alias);
+            m_record->addref();
+        }
+        return *m_record;
     }
 
     inline void join(Container& mdls, queryBase& q, const _TCHAR* name1,
@@ -343,8 +380,14 @@ public:
                      const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
                      const _TCHAR* name8 = NULL)
     {
-        doJoin(true, mdls, q, name1, name2, name3, name4, name5, name6, name7,
-               name8);
+        const _TCHAR* fns[MAX_JOIN_KEY_SIZE];
+        m_alias.reverseAliasNamesQuery(q);
+        int fnsCount = makeJoinKeys(fns, fnsCount, name1, name2, name3, name4,
+                                        name5, name6, name7, name8);
+        q.joinKeySize(fnsCount);
+        pq_handle pq = setQuery(m_tb, q);
+        checkPreparedQuery(pq);
+        doJoin(true, mdls, pq, fns, fnsCount);
     }
 
     inline void
@@ -354,8 +397,44 @@ public:
               const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
               const _TCHAR* name8 = NULL)
     {
-        doJoin(false, mdls, q, name1, name2, name3, name4, name5, name6, name7,
-               name8);
+        const _TCHAR* fns[MAX_JOIN_KEY_SIZE];
+        m_alias.reverseAliasNamesQuery(q);
+        int fnsCount = makeJoinKeys(fns, fnsCount, name1, name2, name3, name4,
+                                        name5, name6, name7, name8);
+        q.joinKeySize(fnsCount);
+        pq_handle pq = setQuery(m_tb, q);
+        checkPreparedQuery(pq);
+        doJoin(false, mdls, pq, fns, fnsCount);
+
+    }
+
+    inline void join(Container& mdls, pq_handle& q, const _TCHAR* name1,
+                     const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
+                     const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
+                     const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
+                     const _TCHAR* name8 = NULL)
+    {
+        const _TCHAR* fns[MAX_JOIN_KEY_SIZE];
+        int fnsCount = makeJoinKeys(fns, fnsCount, name1, name2, name3, name4,
+                                        name5, name6, name7, name8);
+        pq_handle pq = setQuery(m_tb, q);
+        checkPreparedQuery(pq);
+        doJoin(true, mdls, pq, fns, fnsCount);    
+    }
+
+    inline void
+    outerJoin(Container& mdls, pq_handle& q, const _TCHAR* name1,
+              const _TCHAR* name2 = NULL, const _TCHAR* name3 = NULL,
+              const _TCHAR* name4 = NULL, const _TCHAR* name5 = NULL,
+              const _TCHAR* name6 = NULL, const _TCHAR* name7 = NULL,
+              const _TCHAR* name8 = NULL)
+    {
+        const _TCHAR* fns[MAX_JOIN_KEY_SIZE];
+        int fnsCount = makeJoinKeys(fns, fnsCount, name1, name2, name3, name4,
+                                        name5, name6, name7, name8);
+        pq_handle pq = setQuery(m_tb, q);
+        checkPreparedQuery(pq);
+        doJoin(false, mdls, pq, fns, fnsCount);
     }
 
     void releaseTable() { m_tb.reset(); }

data/source/bzs/db/protocol/tdap/client/client.cpp

@@ -43,44 +43,47 @@ __THREAD client* __THREAD_BCB g_client = NULL;
 
 bool checkVersion(trdVersiton& ver)
 {
-    if ((ver.srvMajor < 1) || ((ver.srvMajor == 1) && (ver.srvMinor < 3)))
+    if ((ver.srvMajor < 2) || ((ver.srvMajor == 2) && (ver.srvMinor < 1)))
         return false;
     return true;
 }
 
-bool client::readServerCharsetIndex()
+int client::getServerCharsetIndex()
 {
-    if (m_charsetIndexServer == -1)
+    bzs::netsvc::client::connection* c = con();
+    if (!c)
+        return -1;
+    int v = c->charsetServer();
+    if (v != -1)
+        return v;
+        
+    request req = m_req;
+    req.paramMask = P_MASK_POSBLK | P_MASK_DATA | P_MASK_DATALEN;
+    trdVersiton ver;
+    memset(&ver, 0, sizeof(trdVersiton));
+    ver.cherserServer[0] = 0x00;
+    ver.clMajor = (ushort_td)atoi(C_INTERFACE_VER_MAJOR);
+    ver.clMinor = (ushort_td)atoi(C_INTERFACE_VER_MINOR);
+    ver.clRelease = (ushort_td)atoi(C_INTERFACE_VER_RELEASE);
+
+    uint_td len = sizeof(trdVersiton);
+    req.op = TD_GETSERVER_CHARSET;
+    req.data = &ver;
+    req.datalen = &len;
+
+    mutex::scoped_lock lck(m_mutex);
+    char* p = con()->sendBuffer(m_req.sendLenEstimate());
+    unsigned int size = req.serialize(p);
+    p = con()->asyncWriteRead(size);
+    req.parse(p, false);
+    if (req.result == 0)
     {
-        request req = m_req;
-        req.paramMask = P_MASK_POSBLK | P_MASK_DATA | P_MASK_DATALEN;
-        trdVersiton ver;
-        memset(&ver, 0, sizeof(trdVersiton));
-        ver.cherserServer[0] = 0x00;
-        ver.clMajor = (ushort_td)atoi(C_INTERFACE_VER_MAJOR);
-        ver.clMinor = (ushort_td)atoi(C_INTERFACE_VER_MINOR);
-        ver.clRelease = (ushort_td)atoi(C_INTERFACE_VER_RELEASE);
-
-        uint_td len = sizeof(trdVersiton);
-        req.op = TD_GETSERVER_CHARSET;
-        req.data = &ver;
-        req.datalen = &len;
-
-        mutex::scoped_lock lck(m_mutex);
-        char* p = con()->sendBuffer(m_req.sendLenEstimate());
-        unsigned int size = req.serialize(p);
-        p = con()->asyncWriteRead(size);
-        req.parse(p, 0, 0);
-        if (req.result == 0)
-        {
-            if (!checkVersion(ver))
-                return false;
-            m_charsetIndexServer = mysql::charsetIndex(ver.cherserServer);
-            return true;
-        }
-        return false;
+        if (!checkVersion(ver))
+            return false;
+        c->setCharsetServer(mysql::charsetIndex(ver.cherserServer));
+        return  c->charsetServer();
     }
-    return true;
+    return -1;
 }
 
 void client::addSecondCharsetData(unsigned int destCodePage, std::string& src)
@@ -97,12 +100,13 @@ void client::addSecondCharsetData(unsigned int destCodePage, std::string& src)
 
 bool client::buildDualChasetKeybuf()
 {
-    if (!readServerCharsetIndex())
+    int charsetIndexServer = getServerCharsetIndex();
+    if (charsetIndexServer == -1)
         return false;
-    // m_serverCharData = std::string((char*)m_req.keybuf, m_req.keylen);
+
     m_serverCharData = (char*)m_req.keybuf;
-    if (CHARSET_UTF8 != m_charsetIndexServer)
-        addSecondCharsetData(mysql::codePage(m_charsetIndexServer),
+    if (CHARSET_UTF8 != charsetIndexServer)
+        addSecondCharsetData(mysql::codePage(charsetIndexServer),
                              m_serverCharData);
     else
         m_serverCharData += std::string("\t") + (char*)m_req.keybuf;

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

@@ -52,24 +52,24 @@ namespace client
 class client;
 void setClientThread(client* v);
 
+/* client class 
+This instance is created for each thread.
+*/
 class client
 {
-
     mutex m_mutex;
     request m_req;
     posblk m_tmpPbk;
     ushort_td m_op;
     ushort_td m_preResult;
-    int m_charsetIndexServer;
-
     std::string m_sql;
     std::string m_serverCharData;
     std::string m_serverCharData2;
-
+    blobBuffer m_blobBuffer;
     uint_td m_tmplen;
     bool m_logout;
-    blobBuffer m_blobBuffer;
     bool m_disconnected;
+    bool m_connecting;
 
     std::vector<char> m_sendbuf;
 
@@ -78,16 +78,17 @@ class client
     inline void setCon(bzs::netsvc::client::connection* con)
     {
         m_req.cid->con = con;
-    };
+    }
 
     inline void disconnect()
     {
         if (!con())
             m_req.result = 1;
         else
+        {
             m_disconnected = m_cons->disconnect(con());
-        if (m_req.result == 0)
             setCon(NULL);
+        }
     }
 
     std::string getHostName(const char* uri)
@@ -123,15 +124,26 @@ class client
                                      std::string& src);
 
 public:
-    client() : m_charsetIndexServer(-1), m_disconnected(true) {}
+    client() : m_disconnected(true), m_connecting(false) {}
 
     void cleanup()
     {
+        m_connecting = false;
+/* When in win32, delete this object auto maticaly by dllmain function 
+   at reason = DLL_THREAD_DETACH.
+   But in LINUX does not have that mechanism.
+   Each dissconnect delete this object.
+
+*/
+
+#ifndef _WIN32
+        // delete this. Do not change member variables after this line.
         if (m_disconnected)
             setClientThread(NULL);
+#endif
     }
 
-    request& req() { return m_req; }
+    inline request& req() { return m_req; }
 
     inline void setParam(ushort_td op, posblk* pbk, void_td* data,
                          uint_td* datalen, void_td* keybuf, keylen_td keylen,
@@ -170,12 +182,16 @@ public:
     {
         if (!m_req.cid->con)
         {
+           
             std::string host = getHostName((const char*)m_req.keybuf);
             if (host == "")
                 m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
             bzs::netsvc::client::connection* c = m_cons->connect(host);
             if (c)
+            {
                 setCon(c);
+                m_connecting = true;
+            }
             else
                 m_preResult = ERROR_TD_HOSTNAME_NOT_FOUND;
         }
@@ -192,15 +208,16 @@ public:
         {
             m_req.paramMask &= ~P_MASK_POSBLK;
             std::string name = getTableName((const char*)m_req.keybuf);
+            int charsetIndexServer =  getServerCharsetIndex();
             if ((m_req.keyNum == 1) || (m_req.keyNum == 2)) // make by tabledef
             {
                 m_sql = sqlCreateTable(name.c_str(), (tabledef*)m_req.data,
-                                       m_charsetIndexServer);
+                                       charsetIndexServer);
                 m_req.keyNum -= 2; // 1= exists check 2 = no exists check
             }
             else
                 m_sql = sqlCreateTable(name.c_str(), (fileSpec*)m_req.data,
-                                       m_charsetIndexServer);
+                                       charsetIndexServer);
             m_req.data = (ushort_td*)m_sql.c_str();
             m_tmplen = (uint_td)(m_sql.size() + 1);
             m_req.datalen = &m_tmplen;
@@ -208,9 +225,9 @@ public:
         else if ((m_req.keyNum == CR_SUBOP_SWAPNAME) ||
                  (m_req.keyNum == CR_SUBOP_RENAME))
         {
-            readServerCharsetIndex();
+            int charsetIndexServer =  getServerCharsetIndex();
             m_sql = (char*)m_req.data;
-            addSecondCharsetData(mysql::codePage(m_charsetIndexServer), m_sql);
+            addSecondCharsetData(mysql::codePage(charsetIndexServer), m_sql);
             m_req.data = (ushort_td*)m_sql.c_str();
             m_tmplen = (uint_td)(m_sql.size() + 1);
             m_req.datalen = &m_tmplen;
@@ -234,7 +251,7 @@ public:
                 if (c)
                 {
                     setCon(c); // if error throw exception
-                    if (readServerCharsetIndex() == false)
+                    if (getServerCharsetIndex() == -1)
                         m_preResult = SERVER_CLIENT_NOT_COMPATIBLE;
                     else
                         buildDualChasetKeybuf();
@@ -257,27 +274,38 @@ public:
     {
         if (result() == 0)
         {
-            if (!con())
+            bzs::netsvc::client::connection* c = con();
+            if (!c)
                 m_preResult = ERROR_TD_NOT_CONNECTED;
             else
             {
-                char* p = con()->sendBuffer(m_req.sendLenEstimate());
+                char* p = c->sendBuffer(m_req.sendLenEstimate());
                 unsigned int size = m_req.serialize(p);
                 short stat = 0;
                 if ((m_req.paramMask & P_MASK_BLOBBODY) && m_blobBuffer.blobs())
                     size = m_req.serializeBlobBody(
-                        &m_blobBuffer, p, size, con()->sendBufferSize(),
-                        con()->optionalBuffers(), stat);
+                        &m_blobBuffer, p, size, c->sendBufferSize(),
+                        c->optionalBuffers(), stat);
                 if (stat == 0)
                 {
-                    if (m_req.paramMask & P_MASK_DATALEN)
-                        con()->setReadBufferSizeIf(*m_req.datalen);
-                    p = con()->asyncWriteRead(size);
-                    m_req.parse(p, con()->datalen(), con()->rows());
+                    bool ex =  (m_req.paramMask & P_MASK_EX_SENDLEN) != 0;
+                    if (c->queryFunction(CONNECTION_FUNCTION_DIRECT_READ) && ex)
+                    {
+                        c->setDirectReadHandler(&m_req);
+                        p = c->asyncWriteRead(size);
+                        c->setDirectReadHandler(NULL);
+                    }else
+                    {
+                        if (m_req.paramMask & P_MASK_DATALEN)
+                            c->setReadBufferSizeIf(*m_req.datalen);
+                        p = c->asyncWriteRead(size);
+                        m_req.parse(p, ex);
+                    }
+                      
                 }
                 else
                     m_req.result = stat;
-                if (m_logout)
+                if (m_logout || (m_connecting && m_req.result))
                     disconnect();
                 m_preResult = m_req.result;
             }
@@ -289,7 +317,6 @@ public:
     {
         *data = m_req.blobHeader;
         return *data ? 0 : 1;
-        ;
     }
 
     inline ushort_td addBlob(const blob* data, bool endRow)
@@ -306,7 +333,7 @@ public:
             m_blobBuffer.addBlob(*data);
         return 0;
     }
-    bool readServerCharsetIndex();
+    int getServerCharsetIndex();
 
     bool buildDualChasetKeybuf();
 };