OLE DB ATL을 이용한 BLOB 제어...

BLOB(Image, Binary)타입을 별로 쓰고싶지 않았지만...
쓸수밖에 없기에 ㅡㅡ;;; 삽질했다..흐흐흐
path를 넣고 접근하는게 훨~~~~~씬 좋겠지만...
나같이 해야만 한다면 참고하시라..


1. 다음 코드를 StdAfx.h 에 선언한다

#define _BLOB_ENTRY_CODE_EX(nOrdinal, IID, flags, dataOffset, lengthOffset, statusOffset)
if (pBuffer != NULL)
{
CAccessorBase::FreeType(DBTYPE_IUNKNOWN, pBuffer + dataOffset);
}
else if (pBinding != NULL)
{
DBOBJECT* pObject = NULL;
ATLTRY(pObject = new DBOBJECT);
if (pObject == NULL)
return E_OUTOFMEMORY;
pObject->dwFlags = flags;
pObject->iid = IID;
CAccessorBase::Bind(pBinding, nOrdinal, DBTYPE_IUNKNOWN, sizeof(IUnknown*), 0, 0, eParamIO,
dataOffset, lengthOffset, statusOffset, pObject);
pBinding++;
}
nColumns++;

#define BLOB_ENTRY_LENGTH_STATUS(nOrdinal, IID, flags, data, length, status)
_BLOB_ENTRY_CODE_EX(nOrdinal, IID, flags, offsetbuf(data), offsetbuf(length), offsetbuf(status));

2. Visual Studio 메뉴에 Insert - New ATL Object 에서
Data Access - Consumer - Command로 하고 DB접근 옵션을 설정한다. (command옵션은 change, insert, delete모두해주고..)

3. 생성된 템플릿에
ULONG m_BLOBDATA_LENGTH;
ULONG m_BLOBDATA_STATUS;
를 추가하고...
BLOB_ENTRY(2, IID_ISequentialStream, STGM_READ, m_data1)
같은 코드를
BLOB_ENTRY_LENGTH_STATUS(2, IID_ISequentialStream, STGM_READ, m_data1, m_BLOBDATA_LENGTH, m_BLOBDATA_STATUS)
로 수정한다.

4. BLOB타입을 사용하기 위해서는 ISequentialStream을 사용해야되는데 사용상의 편의를 위해서 MSDN에서 긁어온(?) 상속받은 소스를 추가한다

class CISSHelper : public ISequentialStream
{
public:

// Constructor/destructor.
CISSHelper();
virtual ~CISSHelper();

// Helper function to clean up memory.
virtual void Clear();

// ISequentialStream interface implementation.
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
STDMETHODIMP QueryInterface(REFIID riid, LPVOID *ppv);
STDMETHODIMP Read(
/* [out] */ void __RPC_FAR *pv,
/* [in] */ ULONG cb,
/* [out] */ ULONG __RPC_FAR *pcbRead);
STDMETHODIMP Write(
/* [in] */ const void __RPC_FAR *pv,
/* [in] */ ULONG cb,
/* [out] */ ULONG __RPC_FAR *pcbWritten);

public:

void* m_pBuffer; // Buffer
ULONG m_ulLength; // Total buffer size.
ULONG m_ulStatus; // Column status.

private:

ULONG m_cRef; // Reference count (not used).
ULONG m_iReadPos; // Current index position for reading from the buffer.
ULONG m_iWritePos; // Current index position for writing to the buffer.

};

// ISSHelper.cpp: implementation of the CISSHelper class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ISSHelper.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////
// Class CISSHelper
//
// Implementation of ISequentialStream interface
///////////////////////////////////////////////////////////////////////////////

CISSHelper::CISSHelper()
{
m_cRef = 0;
m_pBuffer = NULL;
m_ulLength = 0;
m_ulStatus = DBSTATUS_S_OK;
m_iReadPos = 0;
m_iWritePos = 0;
}

CISSHelper::~CISSHelper()
{
Clear();
}

void CISSHelper::Clear()
{
CoTaskMemFree( m_pBuffer );
m_cRef = 0;
m_pBuffer = NULL;
m_ulLength = 0;
m_ulStatus = DBSTATUS_S_OK;
m_iReadPos = 0;
m_iWritePos = 0;
}

ULONG CISSHelper::AddRef(void)
{
return ++m_cRef;
}

ULONG CISSHelper::Release(void)
{
return --m_cRef;
}

HRESULT CISSHelper::QueryInterface( REFIID riid, void** ppv )
{
*ppv = NULL;
if ( riid == IID_IUnknown ) *ppv = this;
if ( riid == IID_ISequentialStream ) *ppv = this;
if ( *ppv )
{
( (IUnknown*) *ppv )->AddRef();
return S_OK;
}
return E_NOINTERFACE;
}

HRESULT CISSHelper::Read( void *pv, ULONG cb, ULONG* pcbRead )
{
// Check parameters.
if ( pcbRead ) *pcbRead = 0;
if ( !pv ) return STG_E_INVALIDPOINTER;
if ( 0 == cb ) return S_OK;

// Calculate bytes left and bytes to read.
ULONG cBytesLeft = m_ulLength - m_iReadPos;
ULONG cBytesRead = cb > cBytesLeft ? cBytesLeft : cb;

// If no more bytes to retrive return S_FALSE.
if ( 0 == cBytesLeft ) return S_FALSE;

// Copy to users buffer the number of bytes requested or remaining
memcpy( pv, (void*)((BYTE*)m_pBuffer + m_iReadPos), cBytesRead );
m_iReadPos += cBytesRead;

// Return bytes read to caller.
if ( pcbRead ) *pcbRead = cBytesRead;
if ( cb != cBytesRead ) return S_FALSE;

return S_OK;
}

HRESULT CISSHelper::Write( const void *pv, ULONG cb, ULONG* pcbWritten )
{
// Check parameters.
if ( !pv ) return STG_E_INVALIDPOINTER;
if ( pcbWritten ) *pcbWritten = 0;
if ( 0 == cb ) return S_OK;

// Enlarge the current buffer.
m_ulLength += cb;

// Grow internal buffer to new size.
m_pBuffer = CoTaskMemRealloc( m_pBuffer, m_ulLength );

// Check for out of memory situation.
if ( NULL == m_pBuffer )
{
Clear();
return E_OUTOFMEMORY;
}

// Copy callers memory to internal bufffer and update write position.
memcpy( (void*)((BYTE*)m_pBuffer + m_iWritePos), pv, cb );
m_iWritePos += cb;

// Return bytes written to caller.
if ( pcbWritten ) *pcbWritten = cb;

return S_OK;
}

5. Insert할때는 일반쿼리를 이용해서 레코드를 추가한 상태에서
update를 하는것으로 구현한다.

Cdbofiabt rs;
rs.Open();
rs.MoveFirst();

if ( DBSTATUS_S_OK == rs.m_BLOBDATA_STATUS ) rs.m_data1->Release();

// Set ISequentialStream pointer to our implementation.
rs.m_data1 = (ISequentialStream*) &ISSHelper;

// Set length field and status (required by some providers).
rs.m_BLOBDATA_LENGTH = ISSHelper.m_ulLength;
rs.m_BLOBDATA_STATUS = DBSTATUS_S_OK;

// Call SetData to trigger update.
hr = rs.SetData();
if ( FAILED(hr) )
{
AfxMessageBox("뷁1");
}

rs.FreeRecordMemory();
rs.Close();

6. 긁어올때

HRESULT hr;

Cdbofiabt rs;
rs.Open();
rs.MoveFirst();
rs.MoveNext();

char p[32];
memset(p, 0x00, sizeof(p));
int nSize = 32;

CISSHelper ISSHelper2;

memset(p, 0x00, sizeof(p));

ULONG ulBytesRead;

if ( DBSTATUS_S_OK != rs.m_BLOBDATA_STATUS )
{
AfxMessageBox("뷁343432");
}

do
{
hr = rs.m_data1->Read( p, nSize, &ulBytesRead );
if ( FAILED(hr) )
{
AfxMessageBox("뷁2");
}

// Stuff data into helper class which is used as a dynamic buffer here.
hr = ISSHelper2.Write( p, nSize, NULL );
if ( FAILED(hr) )
{
AfxMessageBox("뷁3");
};
}
while ( ulBytesRead < 0 );

rs.FreeRecordMemory();
rs.Close();

AfxMessageBox(p);

이상!