datalink.cpp

数据访问的定义类

		{
			nStart = lstrlen(lpszSelectList);
			nCount = 0;
			return FALSE;
		}
		lpchStart++;       // point past the separator
	}

	nStart = (int)(lpchStart - lpszSelectList);
	LPCTSTR lpchEnd = _tcschr2(lpchStart, _T(','));
	nCount = (lpchEnd == NULL) ? lstrlen(lpchStart) : (int)(lpchEnd - lpchStart);
	return TRUE;
}

int SqlString_ColumnIndex(LPCTSTR lpszSelectList, LPCTSTR lpszAlias)
{
	int nIndex = 0;
	LPCTSTR lpchEnd = lpszSelectList;
	while (*lpchEnd != 0)
	{
		int nLen = (int)_tcscspn2(lpchEnd, _T(" ,\t\n"));
		if (_tcsnicmp2(lpchEnd, _T("as"), nLen) == 0)
		{
			lpchEnd += nLen;
			if (*lpchEnd != 0)
				lpchEnd++;	// point past the space

			nLen = (int)_tcscspn2(lpchEnd, _T(" ,\t\n"));
			if (_tcsnicmp2(lpchEnd, lpszAlias, nLen) == 0)
				return nIndex;
		}

		lpchEnd += nLen;
		if (*lpchEnd == _T(','))
			nIndex++;
		if (*lpchEnd != 0)
			lpchEnd++;	// point past the space
	}

	return -1;
}

BOOL SqlString_ColumnAlias(LPCTSTR lpszExpression, int& nStart, int& nCount)
{
	nStart = (int)_tcskey1(lpszExpression, _T("as"));
	lpszExpression += nStart;
	nCount = (int)lstrlen(lpszExpression);
	return (nCount > 0);
}

BOOL SqlString_ColumnName(LPCTSTR lpszExpression, int& nStart, int& nCount)
{
	nStart = 0;
	nCount = (int)_tcskey2(lpszExpression, _T("as"));
	return (nCount > 0);
}

BOOL SqlString_TableSource(LPCTSTR lpszFullString, int& nIndex, int& nCount)
{
	nIndex = (int)_tcskey1(lpszFullString, _T("from"));
	lpszFullString += nIndex;
	if (*lpszFullString == 0)
	{
		nCount = 0;
		return FALSE;
	}

	int nNewLength = lstrlen(lpszFullString);
	nCount = (int)_tcskey2(lpszFullString, _T("where"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpszFullString, _T("group"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpszFullString, _T("order"));
	return TRUE;
}

BOOL SqlString_Table(LPCTSTR lpszFullString, int& nIndex, int& nCount)
{
	nIndex = (int)_tcskey1(lpszFullString, _T("from"));
	lpszFullString += nIndex;
	if (*lpszFullString == 0)
	{
		nCount = 0;
		return FALSE;
	}

	int nNewLength = lstrlen(lpszFullString);
	nCount = (int)_tcskey3(lpszFullString, _T("join"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpszFullString, _T("where"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpszFullString, _T("group"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpszFullString, _T("order"));
	return TRUE;
}

int SqlString_TableCount(LPCTSTR lpszTableSource)
{
	for (int nCount = 0; lpszTableSource != NULL; nCount++)
	{
		lpszTableSource = _tcschr2(lpszTableSource, _T(','));
		if (lpszTableSource != NULL)
			lpszTableSource++;
	}

	return nCount;
}

BOOL SqlString_TableItem(LPCTSTR lpszTableSource, int nIndex, int& nStart
						 , int& nCount)
{
	LPCTSTR lpchStart = lpszTableSource;
	while (nIndex--)
	{
		lpchStart = _tcschr2(lpchStart, _T(','));
		if (lpchStart == NULL)
		{
			nStart = lstrlen(lpszTableSource);
			nCount = 0;
			return FALSE;
		}
		lpchStart++;       // point past the separator
	}

	nStart = (int)(lpchStart - lpszTableSource);
	LPCTSTR lpchEnd = _tcschr2(lpchStart, _T(','));
	nCount = (lpchEnd == NULL) ? lstrlen(lpchStart) : (int)(lpchEnd - lpchStart);
	return TRUE;
}

int SqlString_TableIndex(LPCTSTR lpszTableSource, LPCTSTR lpszAlias)
{
	int nIndex = 0;
	LPCTSTR lpchEnd = lpszTableSource;
	while (*lpchEnd != 0)
	{
		int nLen = (int)_tcscspn2(lpchEnd, _T(" ,\t\n"));
		if (_istspace2(*(lpchEnd+nLen)))
		{
			lpchEnd += nLen + 1;	// point past the space

			nLen = (int)_tcscspn2(lpchEnd, _T(" ,\t\n"));
			if (_tcsnicmp2(lpchEnd, lpszAlias, nLen) == 0)
				return nIndex;
		}

		lpchEnd += nLen;
		if (*lpchEnd == _T(','))
			nIndex++;
		if (*lpchEnd != 0)
			lpchEnd++;	// point past the space
	}

	return -1;
}

BOOL SqlString_TableAlias(LPCTSTR lpszExpression, int nIndex, int& nStart
						  , int& nCount)
{
	nStart = (int)_tcscspn2(lpszExpression, _T(" \t\n"));
	lpszExpression += nStart;
	if (*lpszExpression == 0)
	{
		nCount = 0;
		return FALSE;
	}

	lpszExpression++; // point past the space
	nStart++;
	nCount = (int)lstrlen(lpszExpression);
	return (nCount > 0);
}

BOOL SqlString_TableName(LPCTSTR lpszExpression, int nIndex, int& nStart
						 , int& nCount)
{
	nStart = 0;
	nCount = (int)_tcscspn2(lpszExpression, _T(" \t\n"));
	return (nCount > 0);
}

BOOL SqlString_JoinedTable(LPCTSTR lpszFullString, int& nIndex, int& nCount)
{
	nIndex = (int)_tcskey3(lpszFullString, _T("join"));
	lpszFullString += nIndex;
	if (*lpszFullString == 0)
	{
		nCount = 0;
		return FALSE;
	}

	// point past the space
	lpszFullString++;
	nIndex++;

	int nNewLength = lstrlen(lpszFullString);
	nCount = (int)_tcskey2(lpszFullString, _T("where"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpszFullString, _T("group"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpszFullString, _T("order"));
	return TRUE;
}

int SqlString_JoinedTableCount(LPCTSTR lpszJoinedTable)
{
	int nLen;
	for (int nCount=0; ; nCount++)
	{
		nLen = (int)_tcskey1(lpszJoinedTable, _T("join"));
		lpszJoinedTable += nLen;
		if (*lpszJoinedTable == 0)
			break;
	}

	return nCount;
}

BOOL SqlString_JoinedTableItem(LPCTSTR lpszJoinedTable, int nItem, int& nStart, 
							   int& nCount)
{
	int nLen;
	LPCTSTR lpchStart = lpszJoinedTable;
	while (nItem--)
	{
		nLen = (int)_tcskey1(lpchStart, _T("join"));
		lpchStart += nLen;
		nLen = (int)_tcskey3(lpchStart, _T("join"));
		lpchStart += nLen;
		if (*lpchStart == 0)
		{
			nStart = lstrlen(lpszJoinedTable);
			nCount = 0;
			return FALSE;
		}
		lpchStart++;	// point past the space
	}

	nStart = (int)(lpchStart - lpszJoinedTable);

	LPCTSTR lpchEnd = lpchStart;
	nLen = (int)_tcskey1(lpchEnd, _T("join"));
	lpchEnd += nLen;
	nLen = (int)_tcskey3(lpchEnd, _T("join"));
	lpchEnd += nLen;

	nCount = (int)(lpchEnd - lpchStart);
	return TRUE;
}

int SqlString_JoinedTableIndex(LPCTSTR lpszJoinedTable, LPCTSTR lpszAlias)
{
	int nIndex = 0;
	LPCTSTR lpchEnd = lpszJoinedTable;
	while (*lpchEnd != 0)
	{
		int nLen = (int)_tcskey1(lpchEnd, _T("join"));
		lpchEnd += nLen;
		nLen = (int)_tcscspn2(lpchEnd, _T(" \t\n"));
		lpchEnd += nLen;
		if (*lpchEnd != 0)
			lpchEnd++;	// point past the space

		nLen = (int)_tcscspn2(lpchEnd, _T(" \t\n"));
		if (_tcsnicmp2(lpchEnd, lpszAlias, nLen) == 0)
			return nIndex;

		nIndex++;
	}

	return -1;
}

BOOL SqlString_JoinedTableAlias(LPCTSTR lpszTableItem, int& nIndex, int& nCount)
{
	LPCTSTR lpchStart = lpszTableItem;
	int nLen = (int)_tcskey1(lpchStart, _T("join"));
	lpchStart += nLen;
	nLen = (int)_tcscspn2(lpchStart, _T(" \t\n"));
	lpchStart += nLen;
	if (*lpchStart != 0)
		lpchStart++;

	nIndex = (int)(lpchStart - lpszTableItem);
	nLen = (int)_tcscspn2(lpchStart, _T(" \t\n"));
	nCount = (_tcsnicmp2(lpchStart, _T("on"), nLen) != 0) ? nLen : 0;
	return (nCount > 0);
}

BOOL SqlString_JoinedTableName(LPCTSTR lpszTableItem, int& nIndex, int& nCount)
{
	nIndex = (int)_tcskey1(lpszTableItem, _T("join"));
	lpszTableItem += nIndex;
	nCount = (int)_tcscspn2(lpszTableItem, _T(" \t\n"));
	return (nCount > 0);
}

BOOL SqlString_JoinType(LPCTSTR lpszTableItem, int& nIndex, int& nCount)
{
	nIndex = 0;
	nCount = (int)_tcskey1(lpszTableItem, _T("join"));
	if (nCount == lstrlen(lpszTableItem))
	{
		nCount = 0;
		return FALSE;
	}

	if (nCount > 0)
		nCount--;
	return TRUE;
}

BOOL SqlString_JoinCondition(LPCTSTR lpszTableItem, int& nIndex, int& nCount)
{
	nIndex = (int)_tcskey1(lpszTableItem, _T("on"));
	lpszTableItem += nIndex;
	nCount = lstrlen(lpszTableItem);
	return (nCount > 0);
}

BOOL SqlString_SearchCondition(LPCTSTR lpszFullString, int& nIndex, int& nCount
							   , BOOL bCompute = FALSE)
{
	nIndex = (int)_tcskey1(lpszFullString, bCompute ? _T("having") : _T("where"));
	lpszFullString += nIndex;
	if (*lpszFullString == 0)
	{
		nCount = 0;
		return FALSE;
	}

	int nNewLength = lstrlen(lpszFullString);
	nCount = (int)_tcskey2(lpszFullString, _T("group"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpszFullString, _T("order"));
	return TRUE;
}

BOOL SqlString_GroupByExpression(LPCTSTR lpszFullString, int& nIndex, int& nCount)
{
	LPCTSTR lpchStart = lpszFullString;
	int nLen = (int)_tcskey1(lpchStart, _T("group"));
	lpchStart += nLen;
	nLen = (int)_tcscspn2(lpchStart, _T(" \t\n"));
	if (_tcsnicmp2(lpchStart, _T("by"), nLen) == 0)
	{
		lpchStart += nLen;
		if (*lpchStart != 0)
			lpchStart++;
	}

	if (*lpchStart == 0)
	{
		// group by is before order by
		nIndex = (int)_tcskey2(lpszFullString, _T("order"));
		nCount = 0;
		return FALSE;
	}

	nIndex = (int)(lpchStart - lpszFullString);
	int nNewLength = lstrlen(lpchStart);
	nCount = (int)_tcskey2(lpchStart, _T("having"));
	if (nCount == nNewLength)
		nCount = (int)_tcskey2(lpchStart, _T("order"));
	return TRUE;
}

BOOL SqlString_SortExpression(LPCTSTR lpszFullString, int& nIndex, int& nCount)
{
	LPCTSTR lpchStart = lpszFullString;
	int nLen = (int)_tcskey1(lpchStart, _T("order"));
	lpchStart += nLen;
	nLen = (int)_tcscspn2(lpchStart, _T(" \t\n"));
	if (_tcsnicmp2(lpchStart, _T("by"), nLen) == 0)
	{
		lpchStart += nLen;
		if (*lpchStart != 0)
			lpchStart++;
	}

	nIndex = (int)(lpchStart - lpszFullString);
	nCount = lstrlen(lpchStart);
	return (nCount > 0);
}


/////////////////////////////////////////////////////////////////////////////
// variant cast globals helpers

COleDateTime vartodate(const _variant_t& var)
{
	COleDateTime value;
	switch (var.vt) 
	{
	case VT_DATE:
		{
			value = var.date;
		}
		break;
	case VT_EMPTY:
	case VT_NULL:
		value.SetStatus(COleDateTime::null);
		break;
	default:
		value.SetStatus(COleDateTime::null);
		TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
	}
	return value;
}

COleCurrency vartocy(const _variant_t& var)
{
	COleCurrency value;
	switch (var.vt) 
	{
	case VT_CY:
		value = (CURRENCY)var.cyVal;
		break;
	case VT_EMPTY:
	case VT_NULL:
		value.m_status = COleCurrency::null;
		break;
	default:
		value.m_status = COleCurrency::null;
		TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
	}
	return value;
}

bool vartobool(const _variant_t& var)
{
	bool value = false;
	switch (var.vt)
	{
	case VT_BOOL:
		value = var.boolVal ? true : false;
	case VT_EMPTY:
	case VT_NULL:
		break;
	default:
		TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
	}
	return value;
}

BYTE vartoby(const _variant_t& var)
{
	BYTE value = 0;
	switch (var.vt)
	{
	case VT_I1:
	case VT_UI1:
		value = var.bVal;
		break;
	case VT_NULL:
	case VT_EMPTY:
		value = 0;
		break;
	default:
		TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
	}
	return value;
}

short vartoi(const _variant_t& var)
{
	short value = 0;
	switch (var.vt)
	{
	case VT_BOOL:
		value = var.boolVal;
		break;
	case VT_UI1:
	case VT_I1:
		value = var.bVal;
		break;
	case VT_I2:
	case VT_I4:
	case VT_UI2:
	case VT_UI4:
		value = var.iVal;
		break;
	case VT_NULL:
	case VT_EMPTY:
		value = 0;
		break;
	default:
		TRACE(_T("Warning: 未处理的 _variant_t 类型值; 文件: %s; 行: %d\n"), __FILE__, __LINE__);
	}	
	return value;
}

long vartol(const _variant_t& var)
{
	long value = 0;
	switch (var.vt)
	{
	case VT_BOOL:
		value = var.boolVal;
		break;
	case VT_UI1: