sypodlobjects.h

这是一个基于COM的数据库访问技术

		hr = m_pSet->Delete();

		if(FAILED(hr))
		{
			ThrowError(IDS_SYPODL_ERR_DELETERECORD, hr);
			return false;
		}

		return true;
	}

	//===============================================================================

	bool Update()
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return false;
		}

		hr = m_pSet->Update();

		if(FAILED(hr))
		{
			ThrowError(IDS_SYPODL_ERR_UPDATEROWSET, hr);
			return false;
		}

		return true;
	}

	//===============================================================================

	bool MoveNext()
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return false;
		}

		hr = ((CRowset *)m_pSet)->MoveNext();
		if(hr == S_OK)
			m_bBOF = false;
		else
			m_bEOF = true;

		return GetMoveStatus(hr);
	}

	//===============================================================================

	bool MovePrev()
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return false;
		}

		hr = ((CRowset *)m_pSet)->MovePrev();
		if(hr == S_OK)
			m_bEOF = false;
		else
			m_bBOF = true;

		return GetMoveStatus(hr);
	}

	//===============================================================================

	bool MoveFirst()
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return false;
		}

		hr = ((CRowset *)m_pSet)->MoveFirst();
		if(hr == S_OK)
		{
			m_bBOF = false;
			m_bEOF = false;
		}
		else
		{
			m_bBOF = true;
			m_bEOF = true;
		}

		return GetMoveStatus(hr);
	}

	//===============================================================================

	bool MoveLast()
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return false;
		}

		hr = ((CRowset *)m_pSet)->MoveLast();
		if(hr == S_OK)
		{
			m_bBOF = false;
			m_bEOF = false;
		}
		else
		{
			m_bBOF = true;
			m_bEOF = true;
		}

		return GetMoveStatus(hr);
	}

	//===============================================================================

	virtual ULONG GetRecordCount()
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return -1;
		}

		ULONG mRecCount;

		hr = ((CRowset *)m_pSet)->GetApproximatePosition(NULL, NULL, &mRecCount);

		if(FAILED(hr))
		{
			ThrowError(IDS_SYPODL_ERR_GETROWCOUNT, hr);
			return -1;
		}

		return mRecCount;
	}

	//===============================================================================

	ULONG GetColumnCount()
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return -1;
		}

		if(m_pColsInfo[0].iOrdinal == 0)
			return m_nColCount-1;
		else
			return m_nColCount;
	}

	//===============================================================================

	void GetColumnName(UINT index, TCHAR *pChar)
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return;
		}

		if(index < 1 || index > GetColumnCount())
		{
			ThrowError(IDS_SYPODL_ERR_INVALIDCOLINDEX);
			return;
		}

		wcscpy(pChar, m_pColsInfo[GetColumnIndex(index)].pwszName);
	}

	//===============================================================================

	CString GetColumnName(UINT index)
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return "";
		}

		if(index < 1 || index > GetColumnCount())
		{
			ThrowError(IDS_SYPODL_ERR_INVALIDCOLINDEX);
			return "";
		}

		return CString(m_pColsInfo[GetColumnIndex(index)].pwszName);
	}

	//===============================================================================

	int GetColumnType(UINT index, CString& pChar)
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return -1;
		}

		if(index < 1 || index > GetColumnCount())
		{
			ThrowError(IDS_SYPODL_ERR_INVALIDCOLINDEX);
			return -1;
		}

		pChar = GetDataTypeName(m_pColsInfo[index].wType);
		return (m_pColsInfo[GetColumnIndex(index)].wType);
	}

	//===============================================================================

	bool AttachADORecordset(CComPtr<ADORecordset>& pRs)
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return false;
		}

		if(!pRs)
		{
			hr = pRs.CoCreateInstance(CLSID_CADORecordset);
			if(FAILED(hr))
			{
				ThrowError(IDS_SYPODL_ERR_CREATERECORDSET, hr);
				return false;
			}
		}

		CComPtr<ADORecordsetConstruction> spADOsCt;

		hr = pRs->QueryInterface(__uuidof(ADORecordsetConstruction),(void**)&spADOsCt);
		if(FAILED(hr))
		{
			ThrowError(IDS_SYPODL_ERR_CONSTRUCTRECORDSET, hr);
			return false;
		}

		hr= spADOsCt->put_Rowset(m_pSet->m_spRowset);
		if(FAILED(hr))
		{
			ThrowError(IDS_SYPODL_ERR_ATTACHROWSET, hr);
			return false;
		}

		return true;
	}

	//===============================================================================

	bool SetBookmark(ULONG& mBookmarkPosition)
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return false;
		}

		hr = m_pSet->GetApproximatePosition(&m_BK, &mBookmarkPosition, NULL);

		if(FAILED(hr))
		{
			ThrowError(IDS_SYPODL_ERR_SETBOOKMARK, hr);
			return false;
		}

		return true;

	}

	//===============================================================================

	bool MoveToBookmark(ULONG mBookmarkPosition)
	{
		if(!m_bIsOpen)
		{
			ThrowError(IDS_SYPODL_ERR_RECORDSETNOTOPEN);
			return false;
		}

		ULONG mRecCount;

		hr = m_pSet->MoveToBookmark(m_BK, mBookmarkPosition);

		if(FAILED(hr))
		{
			ThrowError(IDS_SYPODL_ERR_MOVETOBOOKMARK, hr);
			return false;
		}

		return true;

	}

	//===============================================================================

	void GetChunk(ISequentialStream* pISequentialStream, BYTE *buffer)
	{

		BYTE    rgBuffer[BUFFERSIZE];
		ULONG	cb;
		ULONG	TotalBytes = 0;
		HRESULT hr;

		do
		{
			 hr = pISequentialStream->Read(rgBuffer, BUFFERSIZE, &cb);
			 if (cb > 0 || hr == S_OK)
			 {
				memcpy(buffer + TotalBytes, rgBuffer, cb);
				TotalBytes += cb;
			 }
		} while (cb >= sizeof(rgBuffer));

	}

	//===============================================================================

	ULONG GetChunkSize(ISequentialStream* pISequentialStream)
	{
		BYTE    rgBuffer[BUFFERSIZE];
		ULONG	cb;
		ULONG	TotalBytes = 0;
		HRESULT hr;

		do
		{
			 hr = pISequentialStream->Read(rgBuffer, BUFFERSIZE, &cb);
			 if (cb > 0 || hr == S_OK)
				TotalBytes += cb;
		} while (cb >= sizeof(rgBuffer));

		return TotalBytes;
	}

	//===============================================================================

protected:

	void ThrowError(UINT m_cause, HRESULT hr=0)
	{
			if(m_bEnableThrow)
			{
				if(m_nRowsetType == 1 || !m_bIsOpen)
					throw CSypODLException(m_cause, hr);
				else
				{
					CCommand<TAccessor > *pCmd = (CCommand<TAccessor > *)m_pSet;
					throw CSypODLException(m_cause, hr, (CComPtr<struct IUnknown>)pCmd->m_spCommand);
				}
			}
	}

	//===============================================================================

	virtual bool GetMoveStatus(HRESULT hr)
	{
		if(FAILED(hr))
		{
			ThrowError(IDS_SYPODL_ERR_NAVIGATERECORD, hr);
			return false;
		}

		if(SUCCEEDED(hr))
		{
			if(hr == S_OK)
				return true;
		}

		return false;
	}

	//===============================================================================

	void MoveToFirstRecord()
	{
		hr = ((CRowset *)m_pSet)->MoveFirst();
		if(!GetMoveStatus(hr))
		{
			m_bBOF = true;
			m_bEOF = true;
		}
		else
			m_bBOF = false;
	}

	//===============================================================================

	UINT GetColumnIndex(UINT index)
	{
		if(m_pColsInfo[0].iOrdinal == 0)
			return index;
		else
			return (index - 1);
	}
};

//****************************************************************************************

class CSypOLEDBErr
{
public:
	bool AreDBErrorsSupported(CComPtr<IUnknown> m_spUnk);
	bool GetDBErrors(CComPtr<IUnknown> m_spUnk, TCHAR *msg);
	void GetHRRESULTMessage(HRESULT hr, TCHAR *msg);
	bool GetSingleError(TCHAR *msg);
	bool GetSQLCodes(TCHAR *msg, CDBErrorInfo *errInfo, ULONG errorNum = 0);
};

#endif

//****************************************************************************************