transactd 1.2.0 → 2.0.0

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

@@ -1,37 +1,50 @@
 #ifndef BZS_DB_PROTOCOL_TDAP_CLIENT_REQUSET_H
 #define BZS_DB_PROTOCOL_TDAP_CLIENT_REQUSET_H
-/*=================================================================
-   Copyright (C) 2013 BizStation Corp All rights reserved.
+/* =================================================================
+ 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 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.
+ 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.
-=================================================================*/
+ 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/tdapRequest.h>
 
-
+#ifdef USE_DATA_COMPRESS
+#include <bzs/rtl/lzss.h>
+#endif
 
 namespace bzs
 {
-	namespace netsvc{namespace client{class connection;}}
-
+namespace netsvc
+{
+namespace client
+{
+class connection;
+}
+}
 
 namespace db
 {
-	namespace engine{namespace mysql{class table;}}
-	
+namespace engine
+{
+namespace mysql
+{
+class table;
+}
+}
+
 namespace protocol
 {
 namespace tdap
@@ -42,157 +55,201 @@ namespace client
 class request : public bzs::db::protocol::tdap::request
 {
 public:
-	clientID*	cid;
-
-	request():bzs::db::protocol::tdap::request()
-			,cid(NULL){};
-
-	inline void parse(const char* p)
-	{
-		p += sizeof(unsigned int);
-		paramMask = *((uchar_td*)p);
-		p += sizeof(uchar_td);
-		op = *((ushort_td*)p);
-		p += sizeof(ushort_td);
-	
-		if (P_MASK_POSBLK & paramMask)
-		{
-			memcpy(pbk, p, POSBLK_SIZE);
-			p += POSBLK_SIZE;
-		}
-		if (P_MASK_DATALEN & paramMask)
-		{
-			uint_td tmp = *((uint_td*)p);
-			memset(data, 0, *datalen);
-			if (*datalen < tmp)
-				result = STATUS_BUFFERTOOSMALL;
-			else
-				*datalen = tmp;
-			p += sizeof(uint_td);
-		}
-		if (P_MASK_EX_SENDLEN & paramMask)
-		{
-			memcpy(data, p, (*(ushort_td*)p));
-			p += (*(ushort_td*)p);
-	
-		}
-		else if (P_MASK_DATA & paramMask)
-		{
-			memcpy(data, p, *datalen);
-			p += *datalen;
-		}
-		if (P_MASK_KEYBUF & paramMask)
-		{
-			if (keylen < *((keylen_td*)p))
-			{
-				result = STATUS_KEYBUFFERTOOSMALL;
-				return ;
-			}
-			memset(keybuf, 0, keylen);
-			keylen = *((keylen_td*)p);
-			p += sizeof(keylen_td);
-			memcpy(keybuf, p, keylen);
+    clientID* cid;
+
+    request() : bzs::db::protocol::tdap::request(), cid(NULL){};
+
+    inline void parse(const char* p, unsigned int segmentDataLen,
+                      unsigned short rows)
+    {
+        p += sizeof(unsigned int);
+        paramMask = *((ushort_td*)p);
+        p += sizeof(ushort_td);
+
+        result = *((ushort_td*)p);
+        p += sizeof(ushort_td);
+
+        if (P_MASK_POSBLK & paramMask)
+        {
+            memcpy(pbk, p, POSBLK_SIZE);
+            p += POSBLK_SIZE;
+        }
+
+        if (P_MASK_DATALEN & paramMask)
+        {
+            uint_td tmp = *((uint_td*)p);
+            if (*datalen < tmp)
+                result = STATUS_BUFFERTOOSMALL;
+            else
+                *datalen = tmp;
+            p += sizeof(uint_td);
+        }
+
+        if (P_MASK_FINALDATALEN & paramMask)
+        {
+            memset(data, 0, *datalen);
+            if (*datalen < segmentDataLen)
+                result = STATUS_BUFFERTOOSMALL;
+            else
+                *datalen = segmentDataLen;
+        }
+#ifdef USE_DATA_COMPRESS
+        if (P_MASK_USELZSS & paramMask)
+        {
+            unsigned int compSize;
+            memcpy(&compSize, p, sizeof(unsigned int));
+            p += sizeof(unsigned int);
+            unsigned int decompSize = bzs::rtl::lzssDecode(p, data);
+            p += compSize;
+        }
+        else
+#endif
+            if (P_MASK_DATA & paramMask)
+        {
+            memcpy(data, p, *datalen);
+            p += *datalen;
+            if (P_MASK_FINALDATALEN & paramMask)
+            {
+                memcpy(data, &rows, 2);
+                p += sizeof(unsigned int);
+            }
+        }
+        if (P_MASK_KEYBUF & paramMask)
+        {
+            if (keylen < *((keylen_td*)p))
+            {
+                result = STATUS_KEYBUFFERTOOSMALL;
+                return;
+            }
+            memset(keybuf, 0, keylen);
+            keylen = *((keylen_td*)p);
+            p += sizeof(keylen_td);
+            memcpy(keybuf, p, keylen);
             p += keylen;
-		}
-		if (P_MASK_KEYNUM & paramMask)
-		{
-			keyNum =  *((char_td*)p);
-			p += sizeof(char_td);
-		}
-		if (paramMask & P_MASK_BLOBBODY)
-		{
-			blobHeader = (const bzs::db::blobHeader*)p;
-			if (blobHeader->rows)
-				blobHeader->resetCur();
-		}
-		else
-			blobHeader = NULL;
-	
-	}
-	inline unsigned int serialize(char* buf)
-	{
-		char* p = buf;
-		unsigned int totallen = sizeof(unsigned int) + sizeof(uchar_td)
-				+  sizeof(ushort_td) +  CLIENTID_SIZE;
-		if (P_MASK_POSBLK & paramMask)
-			totallen += POSBLK_SIZE;
-	
-		if (P_MASK_EX_SENDLEN & paramMask)
-			totallen += *((ushort_td*)data);
-		else if (P_MASK_DATA & paramMask)
-			totallen += *datalen;
-	
-		if (P_MASK_DATALEN & paramMask)
-			totallen += sizeof(uint_td);
-		if (P_MASK_KEYBUF & paramMask)
-			totallen += keylen+sizeof(keylen_td) + 1;//+1 is null terminate byte
-		if (P_MASK_KEYNUM & paramMask)
-			totallen += sizeof(char_td);
-		memcpy(p, &totallen, sizeof(unsigned int));
-		p += sizeof(unsigned int);
-	
-		memcpy(p, &paramMask,  sizeof(uchar_td));
-		p += sizeof(uchar_td);
-	
-		memcpy(p, &op,  sizeof(ushort_td));
-		p += sizeof(ushort_td);
-	
-		if (P_MASK_POSBLK & paramMask)
-		{
-			memcpy(p, pbk,  POSBLK_SIZE);
-			p += POSBLK_SIZE;
-		}
-	
-		if (P_MASK_DATALEN & paramMask)
-		{
-			memcpy(p, datalen,  sizeof(uint_td));
-			p += sizeof(uint_td);
-		}
-	
-		if (P_MASK_EX_SENDLEN & paramMask)
-		{
-			memcpy(p, data,  *((ushort_td*)data));
-			p += *((ushort_td*)data);
-		}
-		else if (P_MASK_DATA & paramMask)
-		{
-			memcpy(p, data, *datalen);
-			p += *datalen;
-		}
-	
-		if (P_MASK_KEYBUF & paramMask)
-		{
-			memcpy(p, &keylen, sizeof(keylen_td));
-			p += sizeof(keylen_td);
-	
-			memcpy(p, keybuf, keylen);
-			p += keylen;
-			*p = 0x00;
-			++p;
-		}
-		if (P_MASK_KEYNUM & paramMask)
-		{
-			memcpy(p, &keyNum, sizeof(char_td));
-			p += sizeof(char_td);
-		}
-	
-		memcpy(p, &cid->id, CLIENTID_SIZE);
-		p += CLIENTID_SIZE;
-
-		return (unsigned int)(p - buf);
-	}
-
-
-
-
-
+        }
+        if (P_MASK_KEYNUM & paramMask)
+        {
+            keyNum = *((char_td*)p);
+            p += sizeof(char_td);
+        }
+
+        if (P_MASK_FINALRET & paramMask)
+        {
+            result = *((ushort_td*)p);
+            p += sizeof(ushort_td);
+        }
+
+        if (paramMask & P_MASK_BLOBBODY)
+        {
+            blobHeader = (const bzs::db::blobHeader*)p;
+            if (blobHeader->rows)
+                blobHeader->resetCur();
+        }
+        else
+            blobHeader = NULL;
+    }
+
+    inline unsigned int sendLenEstimate()
+    {
+        if (P_MASK_EX_SENDLEN & paramMask)
+        {
+            unsigned int v = *((unsigned int*)data);
+            v &= 0xFFFFFFF; // 28bit
+            return v + 2048;
+        }
+        else if (P_MASK_DATA & paramMask)
+            return *datalen + 2048;
+        return 2048;
+    }
+
+    inline unsigned int serialize(char* buf)
+    {
+        char* p = buf;
+        unsigned int dataSize = 0;
+
+        if (P_MASK_EX_SENDLEN & paramMask)
+        {
+            dataSize = *((unsigned int*)data);
+            dataSize &= 0xFFFFFFF;
+        }
+        else if (P_MASK_DATA & paramMask)
+            dataSize = *datalen;
+// add lzss infomation
+#ifdef USE_DATA_COMPRESS
+        if (dataSize > 1500)
+            paramMask |= P_MASK_USELZSS;
+#endif
+        p += sizeof(unsigned int);
+
+        memcpy(p, &paramMask, sizeof(ushort_td));
+        p += sizeof(ushort_td);
+
+        memcpy(p, &op, sizeof(ushort_td));
+        p += sizeof(ushort_td);
+
+        if (P_MASK_POSBLK & paramMask)
+        {
+            memcpy(p, pbk, POSBLK_SIZE);
+            p += POSBLK_SIZE;
+        }
+
+        if (P_MASK_DATALEN & paramMask)
+        {
+            memcpy(p, datalen, sizeof(uint_td));
+            p += sizeof(uint_td);
+        }
+#ifdef USE_DATA_COMPRESS
+        if (P_MASK_USELZSS & paramMask)
+        {
+            uint_td compSize =
+                bzs::rtl::lzssEncode(data, dataSize, p + sizeof(uint_td));
+            memcpy(p, &compSize, sizeof(uint_td));
+            p += compSize + sizeof(uint_td);
+        }
+        else
+#endif
+            if (P_MASK_EX_SENDLEN & paramMask)
+        {
+            unsigned int v = *((unsigned int*)data);
+            v &= 0xFFFFFFF; // 28bit
+            memcpy(p, data, v);
+            p += v;
+        }
+        else if (P_MASK_DATA & paramMask)
+        {
+            memcpy(p, data, *datalen);
+            p += *datalen;
+        }
+
+        if (P_MASK_KEYBUF & paramMask)
+        {
+            memcpy(p, &keylen, sizeof(keylen_td));
+            p += sizeof(keylen_td);
+
+            memcpy(p, keybuf, keylen);
+            p += keylen;
+            *p = 0x00;
+            ++p;
+        }
+        if (P_MASK_KEYNUM & paramMask)
+        {
+            memcpy(p, &keyNum, sizeof(char_td));
+            p += sizeof(char_td);
+        }
+
+        memcpy(p, &cid->id, CLIENTID_SIZE);
+        p += CLIENTID_SIZE;
+
+        unsigned int totallen = (unsigned int)(p - buf);
+        memcpy(buf, &totallen, sizeof(unsigned int));
+        return totallen;
+    }
 };
 
-}//namespace client
-}//namespace protocol
-}//namespace tdap
-}//namespace db
-}//namespace bzs
-
+} // namespace client
+} // namespace protocol
+} // namespace tdap
+} // namespace db
+} // namespace bzs
 
-#endif //BZS_DB_PROTOCOL_TDAP_CLIENT_REQUSET_H
+#endif // BZS_DB_PROTOCOL_TDAP_CLIENT_REQUSET_H