ado 读写二进制数据

1. 写二进制数据：
   1. 1. pRs->AppendChunk(_T("tpContent"),buff,dwLen);
2. 读二进制数据：

   1.   CADOFieldInfo info;   
         pRs->GetFieldInfo(_T("tpcontent"),&info); //topology设备上下文，在数据表中以二进制存在
         void *buff=malloc(info.m_lSize);
         memset(buff,0,info.m_lSize);
         pRs->GetChunk(_T("tpcontent"),buff);  //使用tpcontent字段的内容来填充buff
        

      pRs是自己封装的一个类，CADORecordset，其他的定义：

      _RecordsetPtr m_pRecordset

      BOOL CADORecordset::AppendChunk(LPCTSTR lpFieldName, LPVOID lpData, UINT nBytes)
      {
      
      	FieldPtr pField = m_pRecordset->Fields->GetItem(lpFieldName);
      
      	return AppendChunk(pField, lpData, nBytes);
      }
      
      
      BOOL CADORecordset::AppendChunk(int nIndex, LPVOID lpData, UINT nBytes)
      {
      	_variant_t vtIndex;
      	
      	vtIndex.vt = VT_I2;
      	vtIndex.iVal = nIndex;
      
      	FieldPtr pField = m_pRecordset->Fields->GetItem(vtIndex);
      
      	return AppendChunk(pField, lpData, nBytes);
      }
      
      BOOL CADORecordset::AppendChunk(FieldPtr pField, LPVOID lpData, UINT nBytes)
      {
      	HRESULT hr;
      	_variant_t varChunk;
      	long lngOffset = 0;
      	UCHAR chData;
      	SAFEARRAY FAR *psa = NULL;
      	SAFEARRAYBOUND rgsabound[1];
      
      	try
      	{
      		//Create a safe array to store the array of BYTES 
      		rgsabound[0].lLbound = 0;
      		rgsabound[0].cElements = nBytes;
      		psa = SafeArrayCreate(VT_UI1,1,rgsabound);
      
      		while(lngOffset < (long)nBytes)
      		{
      			chData	= ((UCHAR*)lpData)[lngOffset];
      			hr = SafeArrayPutElement(psa, &lngOffset, &chData);
      
      			if(FAILED(hr))
      				return FALSE;
      			
      			lngOffset++;
      		}
      		lngOffset = 0;
      
      		//Assign the Safe array  to a variant. 
      		varChunk.vt = VT_ARRAY|VT_UI1;
      		varChunk.parray = psa;
      
      		hr = pField->AppendChunk(varChunk);
      
      		if(SUCCEEDED(hr)) return TRUE;
      	}
      	catch(_com_error &e)
      	{
      		dump_com_error(e);
      		return FALSE;
      	}
      
      	return FALSE;
      }
      

      
       

      BOOL CADORecordset::GetFieldInfo(FieldPtr pField, CADOFieldInfo* fldInfo)
      {
      	memset(fldInfo, 0, sizeof(CADOFieldInfo));
      
      	strcpy(fldInfo->m_strName, (LPCTSTR)pField->GetName());
      	fldInfo->m_lDefinedSize = pField->GetDefinedSize();
      	fldInfo->m_nType = pField->GetType();
      	fldInfo->m_lAttributes = pField->GetAttributes();
      	if(!IsEof())
      		fldInfo->m_lSize = pField->GetActualSize();
      	return TRUE;
      }
      BOOL CADORecordset::GetChunk(LPCTSTR lpFieldName, LPVOID lpData)
      {
      	FieldPtr pField = m_pRecordset->Fields->GetItem(lpFieldName);
      
      	return GetChunk(pField, lpData);
      }
      
      BOOL CADORecordset::GetChunk(int nIndex, LPVOID lpData)
      {
      	_variant_t vtIndex;
      	
      	vtIndex.vt = VT_I2;
      	vtIndex.iVal = nIndex;
      
      	FieldPtr pField = m_pRecordset->Fields->GetItem(vtIndex);
      
      	return GetChunk(pField, lpData);
      }
      
      BOOL CADORecordset::GetChunk(FieldPtr pField, LPVOID lpData)
      {
      	long lngSize, lngOffSet = 0;
      	_variant_t varChunk;    
      	UCHAR chData;
      	HRESULT hr;
      	long lBytesCopied = 0;
      
      	lngSize = pField->ActualSize;
      	
      	while(lngOffSet < lngSize)
      	{ 
      		try
      		{
      			varChunk = pField->GetChunk(ChunkSize);
      
      			//Copy the data only upto the Actual Size of Field.  
                  for(long lIndex = 0; lIndex <= (ChunkSize - 1); lIndex++)
                  {
                      hr= SafeArrayGetElement(varChunk.parray, &lIndex, &chData);
                      if(SUCCEEDED(hr))
                      {
                          //Take BYTE by BYTE and advance Memory Location
                          //hr = SafeArrayPutElement((SAFEARRAY FAR*)lpData, &lBytesCopied ,&chData); 
      					((UCHAR*)lpData)[lBytesCopied] = chData;
                          lBytesCopied++;
                      }
                      else
                          break;
                  }
      			lngOffSet += ChunkSize;
      		}
      		catch(_com_error &e)
      		{
      			dump_com_error(e);
      			return FALSE;
      		}
      	}
      
      	lngOffSet = 0;
      	return TRUE;
      }