#include "StdAfx.h"
#include "UIISQLiteServer.h"
#include "sqlite3.h"
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <functional>
extern HINSTANCE _hdllInstance;

static std::string g_strErr = "";
namespace
{
	CString MiddleString(LPCTSTR psz1, LPCTSTR psz2, LPCTSTR pszSource)	// 取出pszSource串中，在 psz1与psz2间的串
	{
		CString strRel(_T(""));
		if (!psz1 || !psz2 || !pszSource) return strRel;
		CString sSource(pszSource);
		int idx1(-1), idx2(-1);
		idx1 = sSource.Find(psz1);
		idx2 = sSource.Find(psz2, idx1);
		if (idx1 == -1 || idx2 == -1) return strRel;
		if (idx1 >= idx2) return strRel;
		return sSource.Mid(idx1 + 1, idx2 - idx1 - 1);
	}

	// 将ansi字符串转换成UNICODE  
	std::wstring UTF8ToUnicode(LPSTR szText)
	{
		if (!szText)
			return std::wstring(_T(""));

		int nLength, nLen;
		wchar_t *pBuffer;

		nLen = (int)strlen(szText);
		nLength = MultiByteToWideChar(CP_UTF8, 0, szText, nLen, NULL, 0);
		pBuffer = new wchar_t[nLength + 1];
		memset(pBuffer, 0, (nLength+1)*sizeof(wchar_t));
		MultiByteToWideChar(CP_UTF8, 0, szText, nLen, (LPWSTR)pBuffer, nLength);
		std::wstring wstr(pBuffer);
		delete[] pBuffer;
		return wstr;
	}

	// 将UNICODE字符串转换成UTF8  
	std::string UnicodeToUTF8(LPCTSTR szText)
	{
		char *pBuffer;
		int nLength;
		int nLen;
		nLen = (int)wcslen(szText);
		// 获取转换后的字符串长度  
		nLength = WideCharToMultiByte(CP_UTF8, 0, szText, nLen, NULL, 0, 0, 0);
		int rc = GetLastError();
		pBuffer = new char[nLength + 1];
		memset(pBuffer, 0, (nLength+1)*sizeof(char));
		// 进行字符转换  
		WideCharToMultiByte(CP_UTF8, 0, szText, nLen, pBuffer, nLength, 0, 0);
		std::string str(pBuffer);
		delete[] pBuffer;
		return str;
	}

	int SplitString(const LPCTSTR pszOri, const LPCTSTR pszSplit, std::vector<CString> &vec)
	{
		do
		{
			if (!pszOri) break;
			vec.clear();

			if (!pszSplit)
			{
				vec.push_back(pszOri);
				return 1;
			}

			CString sOri(pszOri), sSplit(pszSplit), sRel(_T(""));
			int nSplitLen(sSplit.GetLength()), nFindPos(0), nRel(0);
			while ((nFindPos = sOri.Find(sSplit, 0)) != -1)
			{
				sRel = sOri.Mid(0, nFindPos);
				vec.push_back(sRel);
				sOri = sOri.Right(sOri.GetLength() - nFindPos - nSplitLen);
				++nRel;
			}

			if (!sOri.IsEmpty())
			{
				vec.push_back(sOri);
				++nRel;
			}

			return nRel;
		} while (false);

		return 0;
	}

	CString getMidString(TCHAR chFirst, TCHAR chSecond, LPCTSTR psz)
	{
		CString str(psz), sRel(_T(""));
		int idx = str.Find(chFirst);
		if (idx == -1) return _T("");
		for (int i = idx+1; i < str.GetLength(); ++i)
		{
			if (str[i] == chSecond) break;
			sRel += str[i];
		}
		return sRel;
	}
}

namespace DBTools
{
	struct _Table
	{
		typedef std::wstring _wstr;
		typedef std::vector<_wstr> _wsArr;
	public:
		struct _Column
		{
			_wstr __sField;
			_wsArr __arData;
			_Column()								{ clear(); }
			void		clear()						{ __sField.clear(); __arData.clear(); }
			bool		empty()						{ return __sField.empty(); }
			bool		valid(int row)				{ return row < __arData.size(); }
		};
		struct _sort_col_
		{
			bool operator () (const _Table::_Column &c1, const _Table::_Column &c2) { return c1.__sField < c2.__sField; }
		};
		struct _find_col_
		{
		public:
			_wstr _field;
			_find_col_(const _wstr &f) : _field(f) {}
			bool operator () (const _Table::_Column &col) { return col.__sField == _field; }
		};
	public:
		bool			empty()							{ return __table.empty(); }
		void			clear()							{ __table.clear(); }
		int				getNumOfColumn()				{ return (int)__table.size(); }
		int				getNumOfRow()					{ return empty() ? 0 : (int)__table[0].__arData.size(); }
		_wstr			getData(int row, int col)		{ return valid(row, col) ? __table[col].__arData[row] : _T(""); }
		_wstr			getField(int col)				{ return valid(col) ? __table[col].__sField : _T(""); }
		void			insert(const _Column & col)		{ __table.push_back(col); }
		const _wsArr*	getColumnData(int col)			{return valid(col) ? &__table[col].__arData : 0;}
		void			sort()							{ std::sort(__table.begin(), __table.end(), _sort_col_()); }
		_wstr			getData(int row, _wstr sfield)	
		{
			std::vector<_Column>::iterator it = std::find_if(__table.begin(), __table.end(), _find_col_(sfield));
			if (it == __table.end()) _wstr();
			if (!it->valid(row)) return _wstr();
			return it->__arData[row];
		}
		void			getRowData(int row, _wsArr & arr)
		{
			if (__table.empty()) return;
			if (__table[0].__arData.size() <= row) return;
			for (size_t i = 0; i < __table.size(); ++i)
				arr.push_back(__table[i].__arData[row]);
		}

		void			getData(_wsArr & arr)
		{
			for (size_t i = 0; i < getNumOfRow(); ++i)
				for (size_t j = 0; j < getNumOfColumn(); ++j)
					arr.push_back(getData(i, j));
		}

	private:
		bool valid(int col)								{ return (col < __table.size() && col >= 0); }
		bool valid(int row, int col)					{ return valid(col) ? (row < __table[col].__arData.size() && row >= 0) : false; }
	private:
		std::vector<_Column> __table;
	};

	

	/************************************************************************/
	// sqlite3接口查询出的数据二维字符串表。如下图
	//	横为行 竖为例 格内为序号，行在前，列在后，通过序号可以读取数据(_Table::getData(row, col))
	//			|	0	|	1	|	2	|	3	|	4	|	5	|	// 列号
	//	|	0	|	00	|	01	|	02	|	03	|	04	|	05	|	// 第一行为字段,以下各行为数据
	//	|	1	|	10	|	11	|	12	|	13	|	14	|	15	|
	//	|	2	|	20	|	21	|	22	|	23	|	24	|	25	|
	//	|	3	|	30	|	31	|	32	|	33	|	34	|	35	|
	//	|	4	|	40	|	41	|	42	|	43	|	44	|	45	|
	//	|	5	|	50	|	51	|	52	|	53	|	54	|	55	|
	/************************************************************************/
	int getSqliteDatas(sqlite3 *db, LPCTSTR zSql, _Table &table)
	{
		std::string pUTF8 = UnicodeToUTF8(CString(zSql).GetBuffer());

		char **pszRel = NULL;
		int nRow(0), nCol(0);
		int nRel = ::sqlite3_get_table(db, pUTF8.c_str(), &pszRel, &nRow, &nCol, 0);
		g_strErr = sqlite3_errmsg(db);
		if (nRel == 1 || !pszRel) return nRel;
		
		_Table::_Column col;
		std::wstring str(_T(""));
		for (int i = 0; i < nCol; ++i)
		{
			for (int j = 0; j <= nRow; ++j)
			{
				int n = ((j)*nCol) + i;
				str = UTF8ToUnicode(pszRel[n]).c_str();
				if (j)
					col.__arData.push_back(str);
				else
					col.__sField = str;
			}
			table.insert(col);
			col.clear();
		}
		::sqlite3_free_table(pszRel);
		return nRel;
	}

	int sqlite3_get_table(sqlite3 *db, LPCTSTR zSql, char ***pazResult, int *pnRow, int *pnColumn, char **pzErrmsg = 0)
	{
		CString str(zSql);
		std::string pUTF8File = UnicodeToUTF8(str.GetBuffer());
		int nRel = ::sqlite3_get_table(db, pUTF8File.c_str(), pazResult, pnRow, pnColumn, pzErrmsg);
		if (1 == nRel)
			g_strErr = sqlite3_errmsg(db);
		return nRel;
	}

}

CUIISQLiteServer::CUIISQLiteServer(void)
{
	m_pSQLiteDb = NULL;
}

CUIISQLiteServer::~CUIISQLiteServer(void)
{
	if (m_pSQLiteDb != NULL)
	{
		sqlite3_close((sqlite3 *)m_pSQLiteDb);
	}
}


BOOL CUIISQLiteServer::InitADOServer(LPCTSTR pszDbFileName)
{
	if (m_pSQLiteDb != NULL)
	{
		 sqlite3_close((sqlite3 *)m_pSQLiteDb);
		 m_pSQLiteDb = NULL;
	}

	std::string pUTF8File = UnicodeToUTF8((LPWSTR)pszDbFileName);

	int nRes = sqlite3_open(pUTF8File.c_str(),(sqlite3 **)&m_pSQLiteDb);
	if (nRes != SQLITE_OK)
	{
		//error can not open database!!!
		return FALSE;
	}
	return TRUE;
}

BOOL CUIISQLiteServer::CreateDBTable(LPCTSTR pszTableName,Ttable& arFields)
{
	if (m_pSQLiteDb != NULL)
	{
		if (IsDbTableExist(pszTableName))
		{
			return FALSE;
		}

		CString strSQL,sTemp;	
		int i;
		int nSize = (int)arFields.GetSize();
		CUIITableField fieldInfo;
		CString keyStr = _T(""),sFormat;

		strSQL.Format(_T("CREATE TABLE %s ("),pszTableName);
		for( i = 0; i< nSize; i++ ) 
		{
			fieldInfo = arFields.GetAt(i);

			if( fieldInfo.m_sFieldType == _T("nvarchar") ||
				fieldInfo.m_sFieldType == _T("varchar"))
			{
				sFormat = _T("[%s] %s (%d) ");
				if(!fieldInfo.m_bPrimaryKey)
				{			
					if( fieldInfo.m_bIsAllowNull)
					{
						sFormat += _T("NULL,");
					}
					else
					{
						sFormat += _T("NOT NULL,");
					}
				}
				else
				{
					sFormat += _T("PRIMARY KEY,");
				}

				sTemp.Format(sFormat, fieldInfo.m_sFieldName,fieldInfo.m_sFieldType, fieldInfo.m_nSize);
			}
			else if(fieldInfo.m_sFieldType.CompareNoCase(_T("int")) == 0 ||
				    fieldInfo.m_sFieldType.CompareNoCase(_T("smallint")) == 0)
			{
				sFormat = _T("[%s] int ");
				if(!fieldInfo.m_bPrimaryKey)
				{			
					if( fieldInfo.m_bIsAllowNull)
					{
						sFormat += _T("NULL,");
					}
					else
					{
						sFormat += _T("NOT NULL,");
					}
				}
				else
				{
					sFormat += _T("PRIMARY KEY,");
				}

				sTemp.Format(sFormat, fieldInfo.m_sFieldName);
			}
			else if( fieldInfo.m_sFieldType == _T("float") )
			{
				sFormat = _T("[%s] float ");
				if(!fieldInfo.m_bPrimaryKey)
				{			
					if( fieldInfo.m_bIsAllowNull)
					{
						sFormat += _T("NULL,");
					}
					else
					{
						sFormat += _T("NOT NULL,");
					}
				}
				else
				{
					sFormat += _T("PRIMARY KEY,");
				}
				sTemp.Format(sFormat, fieldInfo.m_sFieldName);
			}
			else if(fieldInfo.m_sFieldType == _T("image"))
			{
				sFormat = _T("[%s] image NULL,");
				sTemp.Format(sFormat, fieldInfo.m_sFieldName);
			}
			else if(fieldInfo.m_sFieldType == _T("datetime"))
			{
				sFormat = _T("[%s] datetime DEFAULT GETDATE(),");
				sTemp.Format(sFormat, fieldInfo.m_sFieldName);
			}
			else if(fieldInfo.m_sFieldType == _T("text") ||
				fieldInfo.m_sFieldType == _T("ntext"))
			{
				sFormat = _T("[%s] %s NULL,");
				sTemp.Format(sFormat, fieldInfo.m_sFieldName,fieldInfo.m_sFieldType);
			}
			else if(fieldInfo.m_sFieldType == _T("real"))
			{
				sFormat = _T("[%s] real ");
				if(!fieldInfo.m_bPrimaryKey)
				{			
					if( fieldInfo.m_bIsAllowNull)
					{
						sFormat += _T("NULL,");
					}
					else
					{
						sFormat += _T("NOT NULL,");
					}
				}
				else
				{
					sFormat += _T("PRIMARY KEY,");
				}
				sTemp.Format(sFormat, fieldInfo.m_sFieldName);
			}

			if(sTemp.GetLength() > 0)
			{
				strSQL += sTemp;
			}
			sTemp = _T("");
		}

		int nlen = strSQL.GetLength();
		if(nlen > 0)
		{
			strSQL.SetAt(nlen - 1, _T(')'));
		}
		else
		{
			return FALSE;
		}

		try
		{
			ExecuteSQL(strSQL);
		}
		catch(...)
		{
			return FALSE;
		}
		return TRUE;
	}
	return FALSE;
}

BOOL CUIISQLiteServer::IsDbTableExist(LPCTSTR pszTableName)
{
	CString sSQL;
	sSQL.Format(_T("select count(*) from sqlite_master where type='table' and name='%s'"),pszTableName);

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, sSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	std::wstring str = tbl.getData(0, 0);
	int count = _ttoi(str.c_str());

	if (count == 0) return FALSE;

	return TRUE;
}

static int ParaseString(LPCTSTR pszText,CStringArray& arFields,TCHAR ch = _T(','))
{
	CString sTemp,sText;
	sText = pszText;

	for (int i = 0;i < sText.GetLength();i++)
	{
		if (sText.GetAt(i) == ch )
		{
			arFields.Add(sTemp);
			sTemp = _T("");
		}
		else
		{
			sTemp += sText.GetAt(i);
			if (i == sText.GetLength() - 1)
			{
				arFields.Add(sTemp);
			}
		}
	}
	return (int)arFields.GetSize();
}

BOOL CUIISQLiteServer::GetTableStru(LPCTSTR pszTableName,Ttable& arFields,BOOL bTypeAsSQLite)
{
	CString sSQL;
	sSQL.Format(_T("select * from sqlite_master where type = 'table' and name='%s'"), pszTableName);

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, sSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	// 下面解析字符串
	std::wstring wstr = tbl.getData(0, _T("sql"));
	CString str(wstr.c_str());
	str.Replace(_T("\r\n"), _T("@"));
	std::vector<CString> arr(0);
	SplitString(str, _T("@"), arr);

	CString fname(_T("")), stemp;
	Ttable table;
	CUIITableField field;
	for (size_t i = 0; i < arr.size(); ++i)
	{
		stemp = arr[i];
		stemp.TrimLeft(_T(" "));
		fname = stemp;
		if (!fname.IsEmpty() && fname[0] != _T('[')) continue;
		fname = getMidString(_T('['), _T(']'), fname);
		field.m_sFieldName = fname;
		field.m_bIsAllowNull = stemp.Find(_T("NOT NULL")) == -1 ? FALSE : TRUE;
		field.m_bPrimaryKey = stemp.Find(_T("PRIMARY KEY")) == -1 ? FALSE : TRUE;
		// 这里用笨方法即可
		if (stemp.Find(_T("CHAR")) != -1)
		{
			field.m_sFieldType = _T("varchar");
			getMidString(_T('('), _T(')'), fname);
			field.m_nSize = _ttoi(fname);
		}
		else if (stemp.Find(_T("INTEGER")) != -1)
			field.m_sFieldType = _T("int");
		else if (stemp.Find(_T("REAL")) != -1)
			field.m_sFieldType = _T("double");
		else if (stemp.Find(_T("BLOB")) != -1)
			field.m_sFieldType = _T("image");
// 		else if (stemp.Find(_T("")) != -1)
// 			field.m_sFieldType = _T("");
// 		else if (stemp.Find(_T("")) != -1)
// 			field.m_sFieldType = _T("");
// 		else if (stemp.Find(_T("")) != -1)
// 			field.m_sFieldType = _T("");
		arFields.Add(field);
	}

	return TRUE;
}
BOOL CUIISQLiteServer::GetTableStru(LPCTSTR pszTableName,CStringList& listField)
{
	CString sSQL;
	sSQL.Format(_T("select * from '%s'"), pszTableName);

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, sSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	for (int i = 0; i < tbl.getNumOfColumn(); ++i)
		listField.AddTail(tbl.getField(i).c_str());
	return TRUE;
}

BOOL CUIISQLiteServer::DeleteTable(LPCTSTR pszTableName)
{
	if (m_pSQLiteDb != NULL)
	{
		CString strSQL;
		strSQL.Format(_T("DROP TABLE [%s]"),pszTableName);
		ExecuteSQL(strSQL);
		return TRUE;
	}
	return FALSE;
}

BOOL CUIISQLiteServer::DeleteTable(CStringArray& arTableNames)
{
	for (int i = 0;i < arTableNames.GetSize();i++)
	{
		DeleteTable(arTableNames.GetAt(i));
	}
	return TRUE;
}

BOOL CUIISQLiteServer::AppendTableFields(LPCTSTR pszTableName,Ttable& arFields)
{
	if (pszTableName == NULL) return FALSE;

	int nSize = (int)arFields.GetSize();
	int i,bSuccess = 0;
	for(i = 0;i<nSize;i++)
	{
		bSuccess = AppendTableFields(pszTableName,arFields.GetAt(i));
	}
	return bSuccess;
}

BOOL CUIISQLiteServer::AppendTableFields(LPCTSTR pszTableName, CUIITableField& arFields)
{
	if (pszTableName == NULL) return FALSE;

	CString strSQL,sFieldType;
	sFieldType = arFields.m_sFieldType;

	if( sFieldType.CompareNoCase(_T("varchar")) == 0 ||
		sFieldType.CompareNoCase(_T("nvarchar")) == 0)
	{
		strSQL.Format(_T("ALTER TABLE [%s] ADD [%s] %s(%d)"),pszTableName,arFields.m_sFieldName,
			arFields.m_sFieldType,arFields.m_nSize);
	}
	else
	{
		strSQL.Format(_T("ALTER TABLE [%s] ADD [%s] %s"),pszTableName,arFields.m_sFieldName,
			arFields.m_sFieldType);
	}
	return ExecuteSQL(strSQL);
}

int	CUIISQLiteServer::GetSelData(LPCTSTR pszStrSQL,CString& sValue)
{
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszStrSQL, tbl);

	if (nRel == 0 && !tbl.empty())
	{
		sValue = tbl.getData(0, 0).c_str();
		return 1;
	}

	return 0;
}

int	CUIISQLiteServer::GetSelData(LPCTSTR pszStrSQL,CStringArray& arStrValue)
{
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszStrSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	std::vector<std::wstring> vec(0);
	tbl.getData(vec);

	for (size_t i = 0; i < vec.size(); ++i)
		arStrValue.Add(vec[i].c_str());

	return arStrValue.GetSize();
}

int CUIISQLiteServer::GetSelData(LPCTSTR pszStrSQL,CStringArray& arStrValue,int nFr, int nTo)
{
	if (nTo < nFr || nFr < 0) return FALSE;
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszStrSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	if (tbl.getNumOfRow() <= nFr) return FALSE;

	std::vector<std::wstring> vec(0);
	tbl.getData(vec);

	for (size_t i = nFr; i < vec.size() && i <= nTo; ++i)
		arStrValue.Add(vec[i].c_str());

	return arStrValue.GetSize();
}

BOOL CUIISQLiteServer::IsSelEmpty(LPCTSTR pszStrSQL)
{
	if (m_pSQLiteDb == NULL)
		return FALSE;

	char** pazResult = NULL;
	int nRow = 0,nCol = 0;
	DBTools::sqlite3_get_table((sqlite3 *)m_pSQLiteDb, pszStrSQL, &pazResult, &nRow, &nCol, 0);

	if (pazResult != NULL && nRow > 1) //第0行为列名
	{
		sqlite3_free_table(pazResult);
		return TRUE;
	}
	if (pazResult != NULL)
		sqlite3_free_table(pazResult);

	return FALSE;
}

int	CUIISQLiteServer::GetSelData(LPCTSTR pszStrSQL, CStringList& listStrValue, BOOL bMakeLower)
{
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszStrSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	std::vector<std::wstring> vec(0);
	tbl.getData(vec);

	CString str(_T(""));
	for (size_t i = 0; i < vec.size(); ++i)
	{
		str = vec[i].c_str();
		if (bMakeLower) str.MakeLower();
		listStrValue.AddTail(str);
	}

	return listStrValue.GetSize();
}

int	CUIISQLiteServer::GetSelData(LPCTSTR pszStrSQL, CStringList& listStrValue, int nFr, int nTo, BOOL bMakeLower)
{
	if (nTo < nFr || nFr < 0) return FALSE;
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszStrSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	if (tbl.getNumOfRow() <= nFr) return FALSE;

	std::vector<std::wstring> vec(0);
	tbl.getData(vec);

	listStrValue.RemoveAll();
	CString str(_T(""));
	for (size_t i = nFr; i < vec.size() && i <= nTo; ++i)
	{
		str = vec[i].c_str();
		if (bMakeLower) str.MakeLower();
		listStrValue.AddTail(str);
	}

	return listStrValue.GetSize();
}

int	CUIISQLiteServer::GetSelData(LPCTSTR pszStrSQL,CUIIValueTable& valueTable,BOOL bUpdateLable)
{
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszStrSQL, tbl);

	if (nRel == 1 || tbl.empty())
	{//如果没有结果，尝试找到表名。
		CString tblname(pszStrSQL);
		int idx1 = tblname.Find(_T("from"));
		tblname = tblname.Mid(idx1);
		tblname = getMidString(_T('\''), _T('\''), tblname);// 只找from后面第一个 'xxx' 
		if (tblname.IsEmpty())
			tblname = getMidString(_T('['), _T(']'), tblname);// 只找from后面第一个 'xxx' 
		CStringList lst;
		CStringArray ar;
		GetTableStru(tblname, lst);
		for (POSITION ps = lst.GetHeadPosition(); ps != NULL;)
			ar.Add(lst.GetNext(ps));
		valueTable.SetLableRecord(ar);
		return valueTable.GetTableLogicSize();
	}
	
	CStringArray lable, value;
	for (int i=0; i<tbl.getNumOfRow(); i++)
	{
		std::vector<std::wstring> pStrs(0) ;
		tbl.getRowData(i, pStrs);

		for (size_t j=0; j<pStrs.size(); ++j)
		{
			value.Add(pStrs.at(j).c_str());		// 行数据
		}

		valueTable.AddValueRecord(value);
		value.RemoveAll();
	}
	for (int i = 0; i < tbl.getNumOfColumn(); ++i)
	{
		lable.Add(tbl.getField(i).c_str());
	}
	if (bUpdateLable)
		valueTable.SetLableRecord(lable);

	return valueTable.GetTableLogicSize();
}

int	CUIISQLiteServer::GetSelData(LPCTSTR pszStrSQL,CUIIValueTable& valueTable, int nFr, int nTo, BOOL bUpdateLable)
{
	if (nTo < nFr || nFr < 0) return FALSE;
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszStrSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	if (tbl.getNumOfRow() <= nFr) return FALSE;

	CStringArray lable, value;
	for (int i=0; i<tbl.getNumOfRow(); i++)
	{
		std::vector<std::wstring> pStrs(0) ;
		tbl.getRowData(i, pStrs);

		for (size_t j=0; j<pStrs.size(); ++j)
		{
			value.Add(pStrs.at(j).c_str());		// 行数据
		}

		valueTable.AddValueRecord(value);
		value.RemoveAll();
	}
	for (int i = 0; i < tbl.getNumOfColumn(); ++i)
	{
		lable.Add(tbl.getField(i).c_str());
	}

	if (bUpdateLable)
		valueTable.SetLableRecord(lable);

	return valueTable.GetTableLogicSize();
}

//选取两列,一个为Key,一个为Value建map
int	CUIISQLiteServer::GetSelData(LPCTSTR pszSKey_ValueSQL, CMapStringToString& mapKey_Value)
{
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszSKey_ValueSQL, tbl);

	if (nRel == 1 || tbl.getNumOfColumn() < 1) return FALSE;

	const std::vector<std::wstring> *pCol0 = tbl.getColumnData(0);
	const std::vector<std::wstring> *pCol1 = tbl.getColumnData(1);

	if (!pCol0 || !pCol1) return FALSE;

	for (int i = 0; i < tbl.getNumOfRow(); ++i)
		mapKey_Value.SetAt(pCol0->at(i).c_str(), pCol1->at(i).c_str());
	
	return mapKey_Value.GetSize();
}

//选取一行,获得Field到对应数据的映射
int	CUIISQLiteServer::GetSelDataEx(LPCTSTR pszSelectSQL,CMapStringToString& mapFieldToValue)
{
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszSelectSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	for (int i = 0; i < tbl.getNumOfColumn(); ++i)
		mapFieldToValue.SetAt(tbl.getField(i).c_str(), tbl.getData(0, i).c_str());
	return mapFieldToValue.GetSize();
}

int CUIISQLiteServer::GetSelDataEx(LPCTSTR pszSelectSQL, std::map<CString, CString>& mapFieldToValue)
{
	if (m_pSQLiteDb == NULL) return FALSE;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, pszSelectSQL, tbl);

	if (nRel == 1 || tbl.empty()) return FALSE;

	for (int i = 0; i < tbl.getNumOfColumn(); ++i)
		mapFieldToValue.insert(std::make_pair(tbl.getField(i).c_str(), tbl.getData(0, i).c_str()));
	return mapFieldToValue.size();
}

void CUIISQLiteServer::GetDbTableNameArray(CStringArray& arTables)
{
	if (m_pSQLiteDb == NULL) return;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, _T("select name from sqlite_master where type='table'"), tbl);

	if (nRel == 1 || tbl.empty()) return;

	const std::vector<std::wstring> *pCol = tbl.getColumnData(0);

	if (!pCol) return;

	for (int i = 0; i < tbl.getNumOfRow(); ++i)
		arTables.Add(pCol->at(i).c_str());
}

void CUIISQLiteServer::GetDBTableNameList(CStringList& listTables)
{
	if (m_pSQLiteDb == NULL) return;

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pSQLiteDb, _T("select name from sqlite_master where type='table'"), tbl);

	if (nRel == 1 || tbl.empty()) return;

	const std::vector<std::wstring> *pCol = tbl.getColumnData(0);

	if (!pCol) return;

	for (int i = 0; i < tbl.getNumOfRow(); ++i)
		listTables.AddTail(pCol->at(i).c_str());
}

BOOL CUIISQLiteServer::ExecuteSQL(LPCTSTR pszStrSQL)
{
	if (NULL == m_pSQLiteDb || NULL == pszStrSQL)
		return FALSE;

	std::string pUTF8 = UnicodeToUTF8(CString(pszStrSQL).GetBuffer());

	int nRes = sqlite3_exec((sqlite3 *)m_pSQLiteDb,pUTF8.c_str(),NULL,NULL,NULL);
	if (nRes != SQLITE_OK)
	{
		return FALSE;
	}
	return TRUE;
}

BOOL CUIISQLiteServer::IsDatabaseOpen()
{
	return (m_pSQLiteDb != NULL) ? TRUE : FALSE;
}

void CUIISQLiteServer::CloseADOServer()
{
	if (m_pSQLiteDb)
	{
		sqlite3_close((sqlite3 *)m_pSQLiteDb);
		m_pSQLiteDb = NULL;
	}
}

//////////////////////////////////////////////////////////////////////////

namespace
{
	template <class T>
	void DeletePtr(T *ptr)
	{
		if (ptr)
		{
			delete ptr;
			ptr = NULL;
		}
	}
	
	template <class T>
	void DeleteVector(T vec)
	{
		for (size_t i = 0; i < vec.size(); ++i)
			DeletePtr(vec[i]);
		vec.clear();
	}
}

/*
CREATE TABLE [PBAxis] (
[ID] INT64,
[IsArc] BOOL,
[Name] TEXT,
[StartPointX] DOUBLE,
[StartPointY] DOUBLE,
[StartPointZ] DOUBLE,
[EndPointX] DOUBLE,
[EndPointY] DOUBLE,
[EndPointZ] DOUBLE,
[MiddlePointX] DOUBLE,
[MiddlePointY] DOUBLE,
[MiddlePointZ] DOUBLE)
*/
bool SQLTable::InitFieldInfo(LPCTSTR pszTbl)
{
	if (!m_pDb) return false;
	if (!pszTbl) return false;

	// 初始化字段信息
	CString sSQL;
	sSQL.Format(_T("select * from sqlite_master where type = 'table' and name='%s'"), pszTbl);

	DBTools::_Table tbl;
	int nRel = DBTools::getSqliteDatas((sqlite3 *)m_pDb, sSQL, tbl);

	if (nRel == 1 || tbl.empty()) return false;

	std::wstring wstr = tbl.getData(0, _T("sql"));
	CString sSql(wstr.c_str());

	// 先取出表名
	CString sTblName = MiddleString(_T("["), _T("]"), sSql);
	if (sTblName.CompareNoCase(pszTbl) != 0) return false;		// 表名与初始化表名不一至

	// 取出括号间的内容
	CString sBracket = MiddleString(_T("("), _T(")"), sSql);
	std::vector<CString> vec(0), vecSub(0);
	SplitString(sBracket, _T(","), vec);
	CString str(_T(""));
	for (size_t i = 0; i < vec.size(); ++i)
	{
		vecSub.clear();
		str = vec[i];
		str.TrimLeft();
		SplitString(str, _T(" "), vecSub);
		if (vecSub.size() != 2) continue;
		m_AllOfFields.insert(std::make_pair(MiddleString(_T("["), _T("]"), vecSub[0]), ParserFieldType(vecSub[1])));
	}
}

SQLTable::FieldType SQLTable::ParserFieldType(LPCTSTR psz)
{
	if (!psz) return eNULL;
	CString sType(psz);
	if (sType.CompareNoCase(_T("DEC")) == 0 ||
		sType.CompareNoCase(_T("DECIMAL")) == 0 ||
		sType.CompareNoCase(_T("DOUBLE")) == 0 ||
		sType.CompareNoCase(_T("DOUBLE PRECISION")) == 0 ||
		sType.CompareNoCase(_T("FLOAT")) == 0 ||
		sType.CompareNoCase(_T("REAL")) == 0)
		return eFloat;

	if (sType.CompareNoCase(_T("INT")) == 0 ||
		sType.CompareNoCase(_T("INTEGER")) == 0 ||
		sType.CompareNoCase(_T("SMALLINT")) == 0 ||
		sType.CompareNoCase(_T("TINYINT")) == 0 ||
		sType.CompareNoCase(_T("WORD")) == 0)
		return eInt;

	if (sType.CompareNoCase(_T("BIGINT")) == 0 ||
		sType.CompareNoCase(_T("LARGEINT")) == 0 ||
		sType.CompareNoCase(_T("INT64")) == 0 ||
		sType.CompareNoCase(_T("AUTOINC")) == 0)
		return eLargeint;

	if (sType.CompareNoCase(_T("CHAR")) == 0 ||
		sType.CompareNoCase(_T("VARCHAR")) == 0 ||
		sType.CompareNoCase(_T("VARCHAR2")) == 0 ||
		sType.CompareNoCase(_T("TEXT")) == 0 ||
		sType.CompareNoCase(_T("DATETEXT")) == 0 ||
		sType.CompareNoCase(_T("NCHAR")) == 0 ||
		sType.CompareNoCase(_T("NVARCHAR")) == 0 ||
		sType.CompareNoCase(_T("NVARCHAR2")) == 0 ||
		sType.CompareNoCase(_T("NTEXT")) == 0)
		return eWideString;

	if (sType.CompareNoCase(_T("CURRENCY")) == 0 ||
		sType.CompareNoCase(_T("MONEY")) == 0 ||
		sType.CompareNoCase(_T("SMALLMONEY")) == 0)
		return eCurrency;

	if (sType.CompareNoCase(_T("BLOB")) == 0 ||
		sType.CompareNoCase(_T("RAW")) == 0 ||
		sType.CompareNoCase(_T("BINARY")) == 0 ||
		sType.CompareNoCase(_T("VARBINARY")) == 0)
		return eBlob;

	if (sType.CompareNoCase(_T("CLOB")) == 0 ||
		sType.CompareNoCase(_T("MEMO")) == 0)
		return eWideMemo;

	if (sType.CompareNoCase(_T("DATETIME")) == 0 ||
		sType.CompareNoCase(_T("TIMESTAMP")) == 0)
		return eDateTime;

	if (sType.CompareNoCase(_T("DATE")) == 0)
		return eDate;

	if (sType.CompareNoCase(_T("TIME")) == 0)
		return eTime;

	if (sType.CompareNoCase(_T("BOOLEAN")) == 0 ||
		sType.CompareNoCase(_T("BOOL")) == 0)
		return eBoolean;

	if (sType.CompareNoCase(_T("GRAPHIC")) == 0)
		return eGraphic;

	return eNULL;
}

bool SQLTable::InitSqlite(LPCTSTR pszDatabase)
{
	if (!pszDatabase) return false;
	if (m_pDb)
	{
		sqlite3_close(m_pDb);
		m_pDb = NULL;
	}

	std::string pUTF8File = UnicodeToUTF8((LPWSTR)pszDatabase);

	int nRes = sqlite3_open(pUTF8File.c_str(), (sqlite3 **)&m_pDb);
	if (nRes != SQLITE_OK)
	{
		//AfxMessageBox(CString(_T("打开数据库")) + pszDatabase + _T("失败。"));
		m_pDb = NULL;
		return false;
	}
	return true;
}

bool SQLTable::QuerySQL(LPCTSTR pszSql, LPCTSTR pszTblName)
{
	if (!pszSql || !pszTblName) return false;
	if (!m_pDb) return false;

	// 清空一切
	FreeMemo();

	if (!InitFieldInfo(pszTblName)) return false;

	std::string pUTF8 = UnicodeToUTF8(CString(pszSql).GetBuffer());

	char **pszRel = NULL;
	int nRow(0), nCol(0);
	int nRel = ::sqlite3_get_table(m_pDb, pUTF8.c_str(), &pszRel, &nRow, &nCol, 0);
	g_strErr = sqlite3_errmsg(m_pDb);
	if (nRel == 1 || !pszRel) return false;

	m_nRows = nRow;
	m_nCols = nCol;

	// 查询出的数据存在一段连续内存内（pszRel）。总数据量为 (nRow+1)*nCol
	// 此段内存由 nRow + 1 段组成。每段分为 nCol 个字符串。
	// 第一段保存的是字段信息(共nCol个字段)。其它为具体数据。

	// 先取字段
	int i = 0;
	for (; i < nCol; ++i)
	{
		SQLCell *pCell = new SQLCell();
		pCell->m_iCol = i;
		pCell->m_Name = UTF8ToUnicode(pszRel[i]).c_str();
		std::map<CString, FieldType>::iterator it = m_AllOfFields.find(pCell->m_Name);
		if (it == m_AllOfFields.end()) continue;
		pCell->m_type = it->second;
		m_QueryOfFields.push_back(pCell);
	}
	// 再取数据
	for (; i < (nRow+1)*nCol; ++i)
	{
		int idxRow = (int)(i / nCol);
		int idxCol = i- (idxRow * nCol);
		SQLCell *pCell = new SQLCell(idxRow, idxCol, UTF8ToUnicode(pszRel[i]).c_str(), m_QueryOfFields[idxCol]->m_type, m_QueryOfFields[idxCol]->m_Name);
		m_Cells.push_back(pCell);
	}
	CollectColumns();
	CollectRows();
	::sqlite3_free_table(pszRel);
	return true;
}

SQLTable::~SQLTable()
{
	DeleteVector(m_Cells);
	DeleteVector(m_QueryOfFields);
	ReleaseDB();
}

void SQLTable::CollectColumns()
{
	// 按列号排序
	std::sort(m_Cells.begin(), m_Cells.end(), SQLCell::CmpByCol());
	SQLCellPtrs::const_iterator it1 = m_Cells.begin(), it2 = m_Cells.begin();
	SQLCellPtrs vec(0);
	for (int i = 0; i < m_nCols; ++i)
	{
		vec.clear();
		std::advance(it1, i*m_nRows);
		it2 = it1;
		std::advance(it2, m_nRows);
		vec.assign(it1, it2);
		std::sort(vec.begin(), vec.end(), SQLCell::CmpByRow());
		m_Columns.push_back(vec);
		it1 = m_Cells.begin();
	}
}

void SQLTable::CollectRows()
{
	std::sort(m_Cells.begin(), m_Cells.end(), SQLCell::CmpByRow());
	SQLCellPtrs::const_iterator it1 = m_Cells.begin(), it2 = m_Cells.begin();
	SQLCellPtrs vec(0);
	for (int i = 0; i < m_nRows; ++i)
	{
		vec.clear();
		std::advance(it1, i*m_nCols);
		it2 = it1;
		std::advance(it2, m_nCols);
		vec.assign(it1, it2);
		std::sort(vec.begin(), vec.end(), SQLCell::CmpByCol());
		m_Rows.push_back(vec);
		it1 = m_Cells.begin();
	}
}

void SQLTable::FreeMemo()
{
	DeleteVector(m_Cells);
	DeleteVector(m_QueryOfFields);
	m_Rows.clear();
	m_Columns.clear();
	m_AllOfFields.clear();
	m_nCols = m_nRows = 0;
}

bool SQLTable::AttachDB(LPCTSTR pszDB)
{
	if (!pszDB) return false;
	if (m_pDb)
		ReleaseDB();
	FreeMemo();
	return InitSqlite(pszDB);
}

void SQLTable::ReleaseDB()
{
	if (m_pDb)
	{
		sqlite3_close(m_pDb);
		m_pDb = NULL;
	}
}