transactd 1.0.1

data/source/bzs/db/protocol/tdap/mysql/tdapCommandExecuter.h

@@ -0,0 +1,141 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_MYSQL_TDAPCOMMANDEXECUTER_H
+#define BZS_DB_PROTOCOL_TDAP_MYSQL_TDAPCOMMANDEXECUTER_H
+/*=================================================================
+   Copyright (C) 2012 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/engine/mysql/dbManager.h>
+#include <bzs/db/protocol/ICommandExecuter.h>
+#include "request.h"
+#include <bzs/env/crosscompile.h>
+
+extern int g_tableNmaeLower;
+
+namespace bzs
+{	
+namespace db
+{
+	class blobBuffer;
+namespace protocol
+{
+namespace tdap
+{
+namespace mysql
+{
+
+class ReadRecordsHandler;
+
+#define  FOR_SQL true
+
+std::string getDatabaseName(const request& req, bool forSql=false);
+std::string getTableName(const request& req, bool forSql=false);
+short_td errorCode(int ha_error);
+bool isMetaDb(const request& req);
+
+class dbExecuter : public engine::mysql::dbManager
+{
+	ReadRecordsHandler* m_readHandler;
+	blobBuffer*  m_blobBuffer;
+
+	void connect(request& req);
+	void releaseDatabase(request& req, int op);
+	std::string makeSQLcreateTable(const request& req);
+	inline void doCreateTable(request& req);
+	inline void doOpenTable(request& req);
+	inline void doSeekKey(request& req, int op);
+	inline void doMoveFirst(request& req);
+	inline void doMoveKey(request& req, int op);
+	inline int  doReadMultiWithSeek(request& req, int op, char* resultBuffer, size_t& size, netsvc::server::buffers* optionalData);
+	inline int  doReadMulti(request& req, int op, char* resultBuffer, size_t& size, netsvc::server::buffers* optionalData);
+	inline void doStepRead(request& req, int op);
+
+
+	inline void doInsert(request& req);
+	inline void doUpdate(request& req);
+	inline void doUpdateKey(request& req);
+	inline void doDelete(request& req);
+	inline void doDeleteKey(request& req);
+	inline void doInsertBulk(request& req);
+	inline void doStat(request& req);
+
+public:
+	dbExecuter();
+	~dbExecuter();
+	int commandExec(request& req, char* result, size_t& size, netsvc::server::buffers* optionalData);
+	int errorCode(int ha_error);
+	short_td errorCodeSht(int ha_error){return (short_td)errorCode(ha_error);};
+	
+};
+
+/** Command dispatcher for connectionManager
+ */
+class connMgrExecuter
+{
+	request& m_req;
+	__int64 m_modHandle;
+public:
+	connMgrExecuter(request& req, unsigned __int64 parent);
+	int read(char* buf, size_t& size);
+	int disconnectOne(char* buf, size_t& size);
+	int disconnectAll(char* buf, size_t& size);
+	int commandExec(char* buf, size_t& size);
+};
+
+class commandExecuter :  public ICommandExecuter, public engine::mysql::igetDatabases
+{
+	mutable request m_req;
+	boost::shared_ptr<dbExecuter> m_dbExec;
+
+	int readStatistics(char* buf, size_t& size);
+	int cmdStatistics(char* buf, size_t& size);
+	unsigned __int64 m_modHandle;
+public:
+	commandExecuter(__int64 parent);
+	~commandExecuter();
+	size_t perseRequestEnd(const char* p, size_t size, bool& comp)const;
+
+	size_t getAcceptMessage(char* message, size_t size)
+	{
+		strcpy_s(message, size, "200 OK\n");
+		return strlen(message);
+	}
+
+	bool parse(const char* p, size_t size);
+
+	int execute(char* resultBuffer, size_t& size, netsvc::server::buffers* optionalData)
+	{
+		if (m_req.op == TD_STASTISTICS)
+			return connMgrExecuter(m_req, m_modHandle).commandExec(resultBuffer, size);
+		return m_dbExec->commandExec(m_req, resultBuffer, size, optionalData);
+	}
+	
+	bool isShutDown(){return m_dbExec->isShutDown();}
+	
+	void cleanup(){};
+	
+	const engine::mysql::databases& dbs() const{return m_dbExec->dbs();};
+};
+
+}//namespace mysql
+}//namespace tdap
+}//namespace protocol
+}//namespace db
+}//namespace bzs
+
+#endif //BZS_DB_PROTOCOL_TDAP_MYSQL_TDAPCOMMANDEXECUTER_H
+

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

@@ -0,0 +1,190 @@
+#ifndef BZS_DB_PROTOCOL_TDAP_TDAPREQUSET_H
+#define BZS_DB_PROTOCOL_TDAP_TDAPREQUSET_H
+/*=================================================================
+   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/tdapcapi.h>
+#include <bzs/db/blobBuffer.h>
+#include <iostream>
+#include <vector>
+#include <string.h>
+#include <boost/asio/buffer.hpp>
+#include <bzs/env/compiler.h>
+
+
+namespace bzs
+{
+	namespace netsvc{namespace client{class connection;}}
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+
+#define P_MASK_OP			0
+#define P_MASK_POSBLK		1
+#define P_MASK_DATA			2
+#define P_MASK_DATALEN		4
+#define P_MASK_KEYBUF		8
+#define P_MASK_KEYNUM		16
+#define P_MASK_EX_SENDLEN	32  //< The data length which transmits to a client is described at 2 bytes of the data buffer head.
+#define P_MASK_BLOBBODY		64
+
+#define P_MASK_ALL			P_MASK_POSBLK|P_MASK_DATA|P_MASK_DATALEN|P_MASK_KEYBUF|P_MASK_KEYNUM
+#define P_MASK_KEYONLY 		P_MASK_KEYBUF|P_MASK_KEYNUM
+#define P_MASK_NOKEYBUF		P_MASK_POSBLK|P_MASK_DATA|P_MASK_DATALEN|P_MASK_KEYNUM
+#define P_MASK_POS_LEN_KEY	P_MASK_POSBLK|P_MASK_DATALEN|P_MASK_KEYNUM
+#define P_MASK_KEYNAVI		P_MASK_POSBLK|P_MASK_DATALEN|P_MASK_KEYBUF|P_MASK_KEYNUM
+#define P_MASK_NODATA		P_MASK_POSBLK|P_MASK_DATALEN|P_MASK_KEYBUF
+
+//server side
+#define P_MASK_READRESULT	P_MASK_POSBLK|P_MASK_DATA|P_MASK_DATALEN
+#define P_MASK_STAT			P_MASK_DATA|P_MASK_DATALEN
+#define P_MASK_READ_EXT		P_MASK_STAT|P_MASK_KEYBUF
+#define P_MASK_MOVPOS		P_MASK_POSBLK|P_MASK_DATA|P_MASK_DATALEN|P_MASK_KEYBUF
+#define P_MASK_INS_AUTOINC	P_MASK_MOVPOS
+
+struct req1
+{
+	ushort_td	op;
+	void_td*	keybuf;
+	uchar_td	keylen;
+	short_td	keyNum;
+	void write(std::ostream& ost);
+};
+
+#pragma option -a-
+pragma_pack1
+
+
+#define POSBLK_SIZE 4
+#define CLIENTID_SIZE 2
+
+/** tdap version info struct
+ */
+struct version
+{
+    ushort_td majorVersion;
+    ushort_td minorVersion;
+    uchar_td Type;           
+};
+
+struct posblk
+{
+	posblk()
+	{
+		memset(this, 0, sizeof(posblk));
+	}
+	int handle;
+
+};
+struct clientID
+{
+
+#ifdef __x86_64__
+	bzs::netsvc::client::connection* con;
+	char_td reserved[4];	
+#else
+	bzs::netsvc::client::connection* con;
+	char_td reserved[8];
+#endif
+	char_td		aid[2];
+	ushort_td 	id;
+};
+
+
+#pragma option -a
+pragma_pop
+
+
+class request
+{
+private:
+	ushort_td		varLenBytesPos;	/*Ooffset of last var field*/
+	ushort_td		varLenBytes;	/*Bytes of last var field length */
+
+public:
+	uchar_td		paramMask;
+	union
+	{
+		short_td    result;
+		short_td	op;
+	};
+
+	posblk*			pbk;
+	uint_td*		datalen;
+	void_td*		data;
+	keylen_td 		keylen;
+	void_td*		keybuf;
+	char_td			keyNum;
+	uint_td			resultLen;		
+	
+	request()
+	{
+    	memset(this, 0, sizeof(request));
+	}
+
+	void reset()
+	{
+		paramMask = 0;
+		result = 0;
+		varLenBytesPos = 0;
+		varLenBytes = 0;
+		resultLen = 0;
+	}
+
+	const struct bzs::db::blobHeader* blobHeader;
+
+	inline unsigned int serializeBlobBody(blobBuffer* blob, char* buf, unsigned int max_size
+				, std::vector<boost::asio::const_buffer>* mbuffer)
+	{
+		unsigned int totallen = *((unsigned int*)(buf));
+		unsigned int size = totallen;
+		char* blobbuf = buf + totallen;
+		//write blob body
+		int stat=0;
+		if (mbuffer)
+			totallen += blob->makeMultiBuffer(*mbuffer);
+		else
+			totallen += blob->writeBuffer((unsigned char*)blobbuf, max_size - totallen - 200, stat);
+		//write total
+		memcpy(buf, &totallen, sizeof(unsigned int));
+
+		//write result
+		if (stat)
+		{
+			short_td* retPtr = (short_td*)(buf + 4 + 1);
+			*retPtr = stat;
+		}
+		//return this buffer size;
+		if (mbuffer)
+			return size;
+		return totallen;
+	}
+};
+
+
+}//namespace tdap
+}//namespace protocol
+}//namespace db
+}//namespace bzs
+
+
+#endif //BZS_DB_PROTOCOL_TDAP_TDAPREQUSET_H

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

@@ -0,0 +1,295 @@
+/*=================================================================
+   Copyright (C) 2000-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 <tchar.h>
+#pragma hdrstop
+
+#include <bzs/db/protocol/tdap/tdapSchema.h>
+#include <bzs/db/protocol/tdap/mysql/characterset.h>
+#include <stdio.h>
+#ifdef _WIN32
+	#include <windows.h>
+#endif
+
+#pragma package(smart_init)
+
+
+#if (defined(_WIN32) && _MSC_VER)
+	extern DWORD g_tlsiID_SC1;
+#else
+	wchar_t __THREAD  g_nameBuf[266]={NULL};
+#endif
+
+
+
+namespace bzs
+{
+namespace db
+{
+namespace protocol
+{
+namespace tdap
+{
+
+
+#ifdef _UNICODE
+
+inline wchar_t* namebuf()
+{
+	#if (defined(_WIN32) && _MSC_VER)
+		return (wchar_t*)TlsGetValue(g_tlsiID_SC1);
+	#else
+		return g_nameBuf;
+	#endif
+}
+const wchar_t* fielddef::name()const
+{
+	return name(namebuf());
+}
+
+const wchar_t* fielddef::name(wchar_t* buf)const
+{
+	MultiByteToWideChar(m_schemaCodePage, (m_schemaCodePage==CP_UTF8)?0:MB_PRECOMPOSED, m_name, -1, buf, MYSQL_FDNAME_SIZE);
+	return buf;
+}
+
+const wchar_t*  fielddef::chainChar()const
+{
+	wchar_t* p = namebuf();
+	MultiByteToWideChar(m_schemaCodePage, (m_schemaCodePage==CP_UTF8)?0:MB_PRECOMPOSED, m_chainChar, -1, p, 2);
+    return p;
+}
+
+void fielddef::setName(const wchar_t* s)
+{
+	WideCharToMultiByte(m_schemaCodePage, (m_schemaCodePage == CP_UTF8) ? 0:WC_COMPOSITECHECK, s, -1, m_name, MYSQL_FDNAME_SIZE, NULL, NULL);
+
+}
+
+void fielddef::setChainChar(const wchar_t* s)
+{
+	WideCharToMultiByte(m_schemaCodePage, (m_schemaCodePage == CP_UTF8) ? 0:WC_COMPOSITECHECK, s, -1, m_chainChar, 2, NULL, NULL);
+}
+
+const wchar_t* tabledef::fileName()const
+{
+	wchar_t* p = namebuf();
+	MultiByteToWideChar(schemaCodePage, (schemaCodePage==CP_UTF8)?0:MB_PRECOMPOSED, m_fileName, -1, p, FILE_NAME_SIZE);
+	return p;
+}
+
+const wchar_t* tabledef::tableName()const
+{
+	wchar_t* p = namebuf();
+	MultiByteToWideChar(schemaCodePage, (schemaCodePage==CP_UTF8)?0:MB_PRECOMPOSED, m_tableName, -1, p, TABLE_NAME_SIZE);
+	return p;
+
+}
+
+const char* tabledef::toChar(char* buf, const wchar_t* s, int size)
+{
+	WideCharToMultiByte(schemaCodePage, (schemaCodePage == CP_UTF8) ? 0:WC_COMPOSITECHECK, s, -1, buf, size, NULL, NULL);
+	return buf;
+
+}
+
+void tabledef::setFileName(const wchar_t* s)
+{
+	WideCharToMultiByte(schemaCodePage, (schemaCodePage == CP_UTF8) ? 0:WC_COMPOSITECHECK, s, -1, m_fileName, FILE_NAME_SIZE, NULL, NULL);
+}
+
+void tabledef::setTableName(const wchar_t* s)
+{
+	WideCharToMultiByte(schemaCodePage, (schemaCodePage == CP_UTF8) ? 0:WC_COMPOSITECHECK, s, -1, m_tableName, TABLE_NAME_SIZE, NULL, NULL);
+}
+#endif //_UNICODE
+
+bool fielddef::isStringType()const
+{
+		return ((type == ft_string)|| (type == ft_zstring)
+			||(type == ft_wstring)|| (type == ft_wzstring)
+			||(type == ft_myvarchar)|| (type == ft_myvarbinary)
+			||(type == ft_mywvarchar)|| (type == ft_mywvarbinary)
+			||(type == ft_myblob)|| (type == ft_mytext)
+			||(type == ft_mychar)|| (type == ft_mywchar)
+			||(type == ft_lstring)|| (type == ft_note));
+}
+
+unsigned int fielddef::charNum(/*int index*/)const
+{
+	if (type==ft_mychar)
+		return (unsigned int)len/mysql::charsize(m_charsetIndex);
+	else if (type==ft_mywchar)
+		return (unsigned int)len/mysql::charsize(CHARSET_UTF16LE);
+	else if (type==ft_myvarchar)
+		return (unsigned int)(len - varLenBytes())/mysql::charsize(m_charsetIndex);
+	else if (type==ft_mywvarchar)
+		return (unsigned int)(len - varLenBytes())/mysql::charsize(CHARSET_UTF16LE);
+	return len;
+}
+
+
+
+ushort_td lenByCharnum(uchar_td type, uchar_td charsetIndex, ushort_td charnum)
+{
+    ushort_td len;
+    if (charsetIndex && ((type == ft_mychar)|| (type == ft_mywchar)
+            || (type == ft_myvarchar) || (type == ft_mywvarchar)))
+    {
+        len = (ushort_td)(mysql::charsize(charsetIndex) * charnum);
+        if ((type == ft_myvarchar) || (type == ft_mywvarchar))
+            len += ((len >= 256)? 2 : 1);
+        else
+            len = std::min<ushort_td>(len, 255);
+    }else
+        len = charnum;
+    return len;
+}
+
+const _TCHAR* getTypeName(short type)
+{
+    switch (type)
+    {
+    case ft_string: return _T("String");
+    case ft_integer: return _T("Integer");
+    case ft_float: return _T("Float");
+    case ft_date: return _T("Date");
+    case ft_time: return _T("Time");
+    case ft_decimal: return _T("Decimal");
+    case ft_money: return _T("Money");
+    case ft_logical: return _T("Logical");
+    case ft_numeric: return _T("Numeric");
+    case ft_bfloat: return _T("BFloat");
+    case ft_lstring: return _T("LString");
+    case ft_zstring: return _T("ZString");
+    case ft_note: return _T("Note");
+    case ft_lvar: return _T("Lvar");
+    case ft_uinteger: return _T("Unsigned Binary");
+    case ft_autoinc: return _T("AutoIncrement");
+    case ft_bit: return _T("Bit");
+    case ft_numericsts: return _T("Numericsts");
+    case ft_numericsa: return _T("Numericsa");
+    case ft_currency: return _T("Currency");
+    case ft_timestamp: return _T("TimeStamp");
+    case ft_blob: return _T("Blob");
+    case ft_wstring: return _T("WString");
+    case ft_wzstring: return _T("WZstring");
+    case ft_datatime: return _T("DateTime");
+    case ft_guid: return _T("Guid");
+    case ft_myvarchar: return _T("myVarChar");
+    case ft_myvarbinary: return _T("myVarBinary");
+    case ft_mywvarchar: return _T("myWVarChar");
+    case ft_mywvarbinary: return _T("myWVarBinary");
+    case ft_mychar: return _T("myChar");
+    case ft_mywchar: return _T("myWChar");
+    case ft_mydate: return _T("myDate");
+    case ft_mytime: return _T("myTime");
+    case ft_mydatetime: return _T("myDateTime");
+    case ft_mytimestamp: return _T("myTimeStamp");
+    case ft_mytext: return _T("myText");
+    case ft_myblob: return _T("myBlob");
+    case ft_nullindicator: return _T("Nullindicator");
+    default: return _T("Unknown");
+    }
+
+}
+
+int getTypeAlign(short type)
+{
+    switch (type)
+    {
+    case ft_string:
+    case ft_date:
+    case ft_time:
+    case ft_lstring:
+    case ft_zstring:
+    case ft_note:
+    case ft_timestamp:
+    case ft_wstring:
+    case ft_wzstring:
+    case ft_myvarchar:
+    case ft_myvarbinary:
+    case ft_mychar:
+    case ft_mywchar:
+    case ft_mywvarchar:
+    case ft_mywvarbinary:
+    case ft_mydate:
+    case ft_mytime:
+    case ft_mydatetime:
+    case ft_mytimestamp:
+    case ft_myblob:
+    case ft_mytext: return BT_AL_LEFT;
+
+    }
+
+    return BT_AL_RIGHT;
+}
+
+
+const _TCHAR* btrVersion::moduleTypeString()
+{
+    switch (type)
+    {
+    case 'N': return _T("Requester");
+    case 'D': return _T("DOS Workstation MicroKernel");
+    case 'W': return _T("Windows Workstation MicroKernel");
+    case 'O': return _T("OS/2 WorkStation MicroKernel");
+    case '3':
+    case '9': return _T("Windows 32Bit Workstation MicroKernel");
+    case 'S': return _T("Netware Server MicroKernel");
+    case 'T': return _T("Windows Server MicroKernel");
+    case 'L': return _T("Linux Server MicroKernel");
+    case 'F': return _T("FileSharing WorkStation MicroKernel");
+    }
+    return _T("Unknown Type");
+}
+
+const _TCHAR* btrVersion::moduleVersionShortString(_TCHAR* buf)
+{
+#pragma warning(disable:4996)
+    switch (type)
+    {
+    case 'N': _stprintf(buf, _T("Reqster %d.%d"), majorVersion, minorVersion);
+        break;
+    case 'D': _stprintf(buf, _T("DosLocal %d.%d"), majorVersion, minorVersion);
+        break;
+    case 'W': _stprintf(buf, _T("W1Local %d.%d"), majorVersion, minorVersion);
+        break;
+    case 'O': _stprintf(buf, _T("OS/2Local %d.%d"), majorVersion, minorVersion);
+        break;
+    case '3':
+    case '9': _stprintf(buf, _T("W3Local %d.%d"), majorVersion, minorVersion);
+        break;
+    case 'S': _stprintf(buf, _T("NServer %d.%d"), majorVersion, minorVersion);
+        break;
+    case 'T': _stprintf(buf, _T("Server %d.%d"), majorVersion, minorVersion);
+        break;
+    case 'L': _stprintf(buf, _T("Lerver %d.%d"), majorVersion, minorVersion);
+        break;
+    default: return _T("Unknown Type");
+    }
+#pragma warning(default:4996)
+    return buf;
+}
+
+}//namespace tdap
+}//namespace protocol
+}//namespace db
+}//namespace bzs
+