xoledatabase.cpp

数据库访问原代码

		delete m_lpMalloc;
		m_lpMalloc = NULL;
	}
}

HRESULT XOleRowset::Create(IRowset *lpRowset, void *lpBuffer, 
						   long nColumn, const WORD *lpType, 
						   const long *lpSize)
{
	HRESULT   hr;
	long   i, nOffset;
	DBBINDING  lpBind[20];

	if(lpRowset == NULL) 
		return E_POINTER;

	// Attach lpRowset
	ReleaseRowset();
	lpRowset->AddRef();
	m_dbRowset.Attach(lpRowset);

	// Set binding info
	nOffset = 0;
	m_nColumn = nColumn;
	for(i = 0; i < nColumn; i ++)
	{
		// Field info
		m_lpDesc[i].dwType = lpType[i];
		m_lpDesc[i].dwSize = lpSize[i];
		m_lpDesc[i].dwOffset = nOffset;

		// Bind info
		memset(lpBind + i, 0, sizeof(DBBINDING));
		lpBind[i].iOrdinal = i + 1;     // Ordinal
		lpBind[i].obValue = nOffset;    // nOffset
		lpBind[i].wType = lpType[i];    // DB_TYPE
		nOffset = nOffset + lpSize[i];  // nOffset
		lpBind[i].cbMaxLen = lpSize[i]; // nMaxLen
		lpBind[i].dwPart = DBPART_VALUE;// PartVal
		lpBind[i].eParamIO = DBPARAMIO_NOTPARAM;
		lpBind[i].dwMemOwner = DBMEMOWNER_CLIENTOWNED;
	}

	// Create Accessor interface
	hr = m_dbRowset.QueryInterface(IID_IAccessor, &m_dbAccessor);
	if(hr != S_OK)   return hr;
	
	// Create hAccessor
	hr = m_dbAccessor->CreateAccessor( 
				DBACCESSOR_ROWDATA, nColumn, 
				lpBind, nOffset, &m_hAccessor, NULL );
	if(hr != S_OK)   return hr;

	// Create buffer
	m_lpBuffer = (unsigned char *)lpBuffer;
	if(m_lpBuffer == NULL) 
	{
		m_lpMalloc = new BYTE[nOffset];
		m_lpBuffer = m_lpMalloc;
	}

	return  S_OK;
}

HRESULT XOleRowset::Create(IRowset *lpRowset)
{
	HRESULT   hr;
	LPOLESTR  lpOleStr;
	DBBINDING  lpBind[20];
	DBCOLUMNINFO  *lpDesc;

	DWORD  i, dwCount;
	DWORD  dwSize, dwOffset = 0;
	XComPtr<IColumnsInfo>  dbColumn;

	if(lpRowset == NULL) 
		return E_POINTER;

	// Attach lpRowset
	ReleaseRowset();
	lpRowset->AddRef();
	m_dbRowset.Attach(lpRowset);

	// Get Column infomation
	hr = m_dbRowset.QueryInterface(IID_IColumnsInfo, &dbColumn);
	if(hr != S_OK)  return hr;

	hr = dbColumn->GetColumnInfo(&dwCount, &lpDesc, &lpOleStr);
	if(hr != S_OK)  return hr;

	dwOffset = 0;
	m_nColumn = dwCount;

	for(i = 0; i < dwCount; i ++)
	{
		// Field information
		if(lpDesc[i].pwszName == NULL)
			m_lpDesc[i].lpName[0] = 0x00;
		else 
			WStrToStr( lpDesc[i].pwszName, 
				       m_lpDesc[i].lpName, 20 );
		m_lpDesc[i].dwOffset = dwOffset;
		m_lpDesc[i].dwType = lpDesc[i].wType;
		m_lpDesc[i].dwSize = lpDesc[i].ulColumnSize;
		if(lpDesc[i].wType == DBTYPE_STR) 
			m_lpDesc[i].dwSize += 2;
		else if(lpDesc[i].wType == DBTYPE_WSTR)
		{
			dwSize = lpDesc[i].ulColumnSize;
			m_lpDesc[i].dwSize += (dwSize + 4);
		}

		// Bind information
		memset(lpBind + i, 0, sizeof(DBBINDING));
		lpBind[i].obValue = dwOffset;
		lpBind[i].dwPart = DBPART_VALUE;
		lpBind[i].wType = lpDesc[i].wType;
		lpBind[i].bScale = lpDesc[i].bScale;
		lpBind[i].cbMaxLen = m_lpDesc[i].dwSize;
		lpBind[i].eParamIO = DBPARAMIO_NOTPARAM;
		lpBind[i].dwMemOwner = DBMEMOWNER_CLIENTOWNED;
		lpBind[i].bPrecision = lpDesc[i].bPrecision;
		lpBind[i].iOrdinal = lpDesc[i].iOrdinal;
		dwOffset += m_lpDesc[i].dwSize;
	}

	CoTaskMemFree( lpDesc );
	CoTaskMemFree( lpOleStr );

	// Create Accessor interface
	hr = m_dbRowset.QueryInterface(IID_IAccessor, &m_dbAccessor);
	if(hr != S_OK)   return hr;
	
	// Create hAccessor
	hr = m_dbAccessor->CreateAccessor(DBACCESSOR_ROWDATA, 
				  dwCount, lpBind, dwOffset, &m_hAccessor, NULL);

	// Okey return
	m_lpMalloc = new BYTE[dwOffset];
	m_lpBuffer = m_lpMalloc;
	return  hr;
}

HRESULT XOleRowset::ReleaseRow()
{
	HRESULT  hr = S_OK;

	if(m_hRow != NULL)
	{
		hr = m_dbRowset->ReleaseRows( 1, 
				 &m_hRow, NULL, NULL, NULL );
		m_hRow = NULL;
	}

	return hr;
}

HRESULT XOleRowset::ReloadRow()
{
	HRESULT  hr = S_OK;
	DWORD    nRowCount;
	HROW*    lpRow = &m_hRow;

	if(m_dbRowset.m_lpPtr == NULL) 
		return E_POINTER;

	if(m_hRow == NULL)
	{
		hr = m_dbRowset->GetNextRows(NULL, -1, 
				   1, &nRowCount, &lpRow);
		if(hr != S_OK)  return hr;

		hr = m_dbRowset->GetData( m_hRow, 
					m_hAccessor, m_lpBuffer );
	}

	return  hr;
}

BOOL XOleRowset::IsRowExist()
{
	return  (m_hRow != NULL); 
}

HRESULT XOleRowset::MoveFirst()
{
	HRESULT  hr;
	DWORD    nRowCount;
	HROW*    lpRow = &m_hRow;

	ReleaseRow();
	if(m_dbRowset.m_lpPtr == NULL) 
		return E_POINTER;

	hr = m_dbRowset->RestartPosition(NULL);
	if(hr != S_OK)  return hr;

	hr = m_dbRowset->GetNextRows( NULL, 0, 
			  1, &nRowCount, &lpRow);
	if(hr != S_OK)  return hr;

	hr = m_dbRowset->GetData( m_hRow, 
				m_hAccessor, m_lpBuffer );

	return hr;
}

HRESULT XOleRowset::MoveLast()
{
	HRESULT  hr;
	DWORD    nRowCount;
	HROW*    lpRow = &m_hRow;

	ReleaseRow();
	if(m_dbRowset.m_lpPtr == NULL) 
		return E_POINTER;

	hr = m_dbRowset->RestartPosition(NULL);
	if(hr != S_OK)  return hr;

	hr = m_dbRowset->GetNextRows(NULL, -1, 
				1, &nRowCount, &lpRow);
	if(hr != S_OK)  return hr;

	hr = m_dbRowset->GetData( m_hRow, 
				m_hAccessor, m_lpBuffer );

	return hr;
}

HRESULT XOleRowset::MoveOffset(long nOffset)
{
	HRESULT  hr;
	DWORD    nRowCount;
	HROW*    lpRow = &m_hRow;

	ReleaseRow();
	if(m_dbRowset.m_lpPtr == NULL) 
		return E_POINTER;

	hr = m_dbRowset->GetNextRows(NULL, nOffset, 
				 1, &nRowCount, &lpRow);
	if(hr != S_OK)   return  hr;

	hr = m_dbRowset->GetData( m_hRow, 
				m_hAccessor, m_lpBuffer );

	return hr;
}

HRESULT XOleRowset::MovePrev()
{
	HRESULT  hr;
	DWORD    nRowCount;
	HROW*    lpRow = &m_hRow;

	ReleaseRow();
	if(m_dbRowset.m_lpPtr == NULL) 
		return E_POINTER;

	hr = m_dbRowset->GetNextRows(NULL, -2, 
				1, &nRowCount, &lpRow);
	if(hr != S_OK)  return  hr;

	hr = m_dbRowset->GetData( m_hRow, 
				m_hAccessor, m_lpBuffer);

	return hr;
}

HRESULT XOleRowset::MoveNext()
{
	HRESULT  hr;
	DWORD    nRowCount;
	HROW*    lpRow = &m_hRow;

	ReleaseRow();
	if(m_dbRowset.m_lpPtr == NULL) 
		return E_POINTER;

	hr = m_dbRowset->GetNextRows(NULL, 0, 
				1, &nRowCount, &lpRow);
	if(hr != S_OK)   return  hr;
	
	hr = m_dbRowset->GetData( m_hRow, 
				m_hAccessor, m_lpBuffer);

	return hr;
}

HRESULT XOleRowset::InitializeChange()
{
	// Query change interface
	if(m_dbChange.m_lpPtr != NULL)
		return S_OK;

	return  m_dbRowset.QueryInterface( 
		      IID_IRowsetChange, &m_dbChange );
}

HRESULT XOleRowset::InsertRow()
{
	HRESULT  hr;

	if(m_dbChange.m_lpPtr == NULL)
		return  E_NOINTERFACE;

	ReleaseRow();
	hr = m_dbChange->InsertRow( NULL, m_hAccessor, 
					m_lpBuffer, &m_hRow );

	return hr;
}

HRESULT XOleRowset::DeleteRow()
{
	if( m_hRow == NULL || 
		m_dbChange.m_lpPtr == NULL )
		return  E_NOINTERFACE;

	return  m_dbChange->DeleteRows( NULL, 
				  1, &m_hRow, NULL);
}

HRESULT XOleRowset::ModifyRow()
{
	if( m_hRow == NULL || 
		m_dbChange.m_lpPtr == NULL )
		return  E_NOINTERFACE;

	return  m_dbChange->SetData( m_hRow, 
				  m_hAccessor, m_lpBuffer );
}

long XOleRowset::GetFieldIndex(LPCTSTR strName) 
{
	long  nIdx = 0;

	while(nIdx < m_nColumn)
	{
		if(lstrcmpi(m_lpDesc[nIdx].lpName, strName) == 0) 
			return  nIdx;    nIdx ++;
	}

	return  -1;
}

void XOleRowset::GetFieldValue(long nIdx, void *lpBuffer)
{
	if(nIdx >= 0 && nIdx < m_nColumn)
	{
		memcpy( lpBuffer, m_lpBuffer + 
				m_lpDesc[nIdx].dwOffset, 
				m_lpDesc[nIdx].dwSize );
	}
}

void XOleRowset::GetFieldString(long nIdx, LPTSTR lpBuffer)
{
	if(nIdx >= 0 && nIdx < m_nColumn)
	{
		XFormatOleVariant( m_lpDesc[nIdx].dwType, 
				m_lpBuffer + m_lpDesc[nIdx].dwOffset, 
				lpBuffer, m_lpDesc[nIdx].dwSize); 
	}
}

void XOleRowset::SetFieldValue(long nIdx, void *lpBuffer)
{
	if(nIdx >= 0 && nIdx < m_nColumn)
	{
		memcpy( m_lpBuffer + m_lpDesc[nIdx].dwOffset, 
				lpBuffer, m_lpDesc[nIdx].dwSize);
	}
}

//获取记录的条数
DWORD XOleRowset::GetRecordCount()
{
	HRESULT  hr;
	DWORD    nRows = 0;
	hr = MoveFirst();
	while(hr == S_OK)
	{
		nRows ++;
		hr = MoveNext();
	}
	MoveFirst();
	return nRows;
}

void XOleRowset::FillStruct(void *lpStruct, const long *lpSize) 
{
	long  i, nIdx = 0;
	LPBYTE  lpBuffer = (BYTE *)lpStruct;
	for(i = 0; i < m_nColumn; i ++)
	{
		memcpy( lpBuffer + nIdx, m_lpBuffer + 
				m_lpDesc[i].dwOffset, lpSize[i] );
		nIdx += lpSize[i];
	}
}

void XOleRowset::LoadStruct(void *lpStruct, const long *lpSize) 
{
	long  i, nIdx = 0;
	LPBYTE  lpBuffer = (BYTE *)lpStruct;
	for(i = 0; i < m_nColumn; i ++)
	{
		memcpy( m_lpBuffer + m_lpDesc[i].dwOffset, 
				lpBuffer + nIdx, lpSize[i]);
		nIdx += lpSize[i];
	}
}

// 通过系统选择数据源
BOOL  XSelectDataSource(HWND hWnd, LPTSTR lpConnect)
{
	HRESULT  hr;
	XComPtr<IDBInitialize>    dbInit;
	XComPtr<IDBProperties>    dbPropert;
	XComPtr<IDataInitialize>  dbDataInit;
	XComPtr<IDBPromptInitialize>  dbPrompt; 
	
	hr = CoCreateInstance( CLSID_DataLinks, NULL, CLSCTX_INPROC_SERVER,
					IID_IDBPromptInitialize, (void **) &dbPrompt);
	if(hr != S_OK)   return FALSE;

	hr = dbPrompt->PromptDataSource( NULL, hWnd, 
				DBPROMPTOPTIONS_WIZARDSHEET, 0, NULL, NULL, 
				IID_IDBProperties, (IUnknown **) &dbPropert);
	if(hr != S_OK)  return FALSE;

	hr = dbPropert.QueryInterface(IID_IDBInitialize, &dbInit);
	if(hr != S_OK)  return FALSE;

	hr = dbInit->Initialize();
	if(hr != S_OK)  return FALSE;

	hr = CoCreateInstance( CLSID_MSDAINITIALIZE, NULL, 
						   CLSCTX_INPROC_SERVER, 
						   IID_IDataInitialize,
						   (void **) &dbDataInit);
	if(hr != S_OK)   return hr;

	// Get connect string
	LPOLESTR    szInitStr;
	hr = dbDataInit->GetInitializationString( 
						dbInit, TRUE, &szInitStr ); 
	if(hr == S_OK)
	{
		WStrToStr(szInitStr, lpConnect, 2048); 
		CoTaskMemFree(szInitStr);//释放内存
		return TRUE;
	}

	CoTaskMemFree(szInitStr);
	return FALSE;
}