Inserindo uma bolha com Ole DB
-
20-09-2019 - |
Pergunta
Estou trabalhando em um aplicativo que está usando o Ole DB e o SQL Server Native Client para acessar um DB do SQL Server. Até o momento, eu só lidei com o SQL bastante simples. Para isso, eu tenho obtido um ICommandText
e usando SetCommandText
. Agora quero inserir um grande objeto no banco de dados. eu vejo isso ICommandStream
existe, mas parece que usar isso exigiria que eu adicionaria uma classe que implementa IStream
e também para citar meu blob adequadamente (escape de apóstrofos, etc.). Certamente há uma maneira mais fácil?
Nota lateral: Ole DB não foi minha escolha e não posso alterá -la nesta fase. Portanto, a maneira mais fácil de "usar algo mais alto" não estiver disponível.
Solução 2
Acontece que há um Resposta no blog da equipe da Microsoft SQLNCLI.
Para expandir isso, aqui está o código que acabei usando. Primeiro, você precisa de um ISequentStream para o cliente nativo do SQL Server estar lendo. Eu tenho meus dados na memória, para que eu possa construir isso com um ponteiro para o meu blob, mas é trivial ir e obter os dados de outros lugares. Não faz parte do contrato, mas talvez seja útil saber que as leituras parecem acontecer em pedaços de 1024 bytes. Aqui está minha aula de stream:
struct ISequentialStream;
class XYZSQLStream : public ISequentialStream
{
public:
XYZSQLStream(LPBYTE data, __int64 ulLength);
virtual ~XYZSQLStream();
virtual BOOL Clear();
virtual ULONG Length() { return m_cBufSize; };
virtual operator void* const() { return m_pBuffer; };
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
STDMETHODIMP QueryInterface(REFIID riid, LPVOID *ppv);
STDMETHODIMP Read(void __RPC_FAR *pv, ULONG cb, ULONG __RPC_FAR *pcbRead);
STDMETHODIMP Write(const void __RPC_FAR *pv, ULONG cb, ULONG __RPC_FAR *pcbWritten);
private:
ULONG m_cRef; // reference count
void* m_pBuffer; // buffer
ULONG m_cBufSize; // buffer size
ULONG m_iPos; // current index position in the buffer
};
A implementação disso é trivial:
XYZSQLStream::XYZSQLStream(LPBYTE data, ULONG ulLength)
{
m_iPos = 0;
m_cRef = 0;
m_pBuffer = data;
m_cBufSize = ulLength;
AddRef();
}
XYZSQLStream::~XYZSQLStream()
{
// Shouldn't have any references left
if (m_cRef)
throw L"Destroying SQLStream with references";
delete[] m_pBuffer;
}
ULONG XYZSQLStream::AddRef()
{
return ++m_cRef;
}
ULONG XYZSQLStream::Release()
{
if (!m_cRef)
throw L"Releasing referenceless SQLStream";
if (--m_cRef)
return m_cRef;
delete this;
return 0;
}
HRESULT XYZSQLStream::QueryInterface(REFIID riid, void** ppv)
{
if (!ppv)
return E_INVALIDARG;
*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;
}
BOOL XYZSQLStream::Clear()
{
m_iPos = 0;
m_cBufSize = 0;
m_pBuffer = NULL;
return TRUE;
}
HRESULT XYZSQLStream::Read(void *pv, ULONG cb, ULONG* pcbRead)
{
if (pcbRead)
*pcbRead = 0;
if (!pv)
return STG_E_INVALIDPOINTER;
if (cb == 0)
return S_OK;
ULONG cBytesLeft = m_cBufSize - m_iPos;
ULONG cBytesRead = cb > cBytesLeft ? cBytesLeft : cb;
//DEBUG(L"cb %d, left %d, read %d\n", cb, cBytesLeft, cBytesRead);
if (cBytesLeft == 0)
return S_FALSE;
// Copy to users buffer the number of bytes requested or remaining
memcpy(pv, (void*)((BYTE*)m_pBuffer + m_iPos), cBytesRead);
m_iPos += cBytesRead;
if (pcbRead)
*pcbRead = cBytesRead;
if (cb != cBytesRead)
return S_FALSE;
return S_OK;
}
HRESULT XYZSQLStream::Write(const void *pv, ULONG cb, ULONG* pcbWritten)
{
// Parameter checking
if (!pv)
return STG_E_INVALIDPOINTER;
if (pcbWritten)
*pcbWritten = 0;
if (cb == 0)
return S_OK;
// Enlarge the current buffer
m_cBufSize += cb;
// Need to append to the end of the stream
m_pBuffer = CoTaskMemRealloc(m_pBuffer, m_cBufSize);
memcpy((void*)((BYTE*)m_pBuffer + m_iPos), pv, cb);
// m_iPos += cb;
if (pcbWritten)
*pcbWritten = cb;
return S_OK;
}
Usando um ICommandText
, você pode então executar um SELECT
na mesa. Na verdade você não vai recuperar dados usando isso, é apenas uma maneira de obter um IRowsetChange
. Eu tenho um método extra de execução para isso para isso. O SQL aprovado no PSQL é (semelhante a) SELECT x,y,z FROM TableWithBlob
. FAIL
é uma macro personalizada que registra o problema e retorna.
HRESULT XYZSQLCommand::ExecuteCommand(TCHAR* pSQL, IRowset** ppRowSet, IRowsetChange** ppRowSetChange)
{
HRESULT hr;
IRowsetChange* pIRowsetChange;
IRowset* pIRowset;
hr = m_pICommandText->SetCommandText(DBGUID_DBSQL, pSQL);
if (FAILED(hr))
FAIL(hr);
hr = m_pICommandText->Execute(NULL, IID_IRowsetChange, NULL, NULL, (IUnknown**)&pIRowsetChange);
if (FAILED(hr))
FAIL(hr);
hr = pIRowsetChange->QueryInterface(IID_IRowset, (void**)&pIRowset);
if (FAILED(hr))
{
pIRowsetChange->Release();
FAIL(hr);
}
*ppRowSet = pIRowset;
*ppRowSetChange = pIRowsetChange;
return S_OK;
}
Agora tenho um Irowset e um IroSHETHANGE para a tabela em questão. Você então construa um DBBINDING
como você normalmente faria. Estou eliminando isso - não é realmente relevante para a pergunta. A parte relevante é:
static DBOBJECT streamObj = {STGM_READ, IID_ISequentialStream};
pDBBindings[nCol].pObject = &streamObj;
pDBBindings[nCol].wType = DBTYPE_IUNKNOWN;
pDBBindings[nCol].cbMaxLen = sizeof(ISequentialStream*);
Ao preencher posteriormente o bloco de memória de dados correspondente, você pode fazer isso (desculpe pelos elencos feios):
XYZSQLStream *stream = new XYZSQLStream(data_to_write, length_of_data);
*((ISequentialStream**)(pbData+pDBBindings[x].obValue)) = stream;
*((DBLENGTH*)(pbData+pDBBindings[x].obLength)) = (DBLENGTH)length_of_data;
*((DBSTATUS*)(pbData+pDBBindings[x].obStatus)) = DBSTATUS_S_OK;
Pegue -se um IAccessor
usando o seu IRowsetChange
e vinculá -lo:
IAccessor* pIAccessor;
HACCESSOR hAccessor;
DBBINDSTATUS* pDBBindStatus;
hr = pRowsetChange->QueryInterface(IID_IAccessor, (void**) &pIAccessor);
// Error handling elided
pDBBindStatus = new DBBINDSTATUS[ulCols];
//Associate the bindings with the data accessor for the rowset
hr = pIAccessor->CreateAccessor( DBACCESSOR_ROWDATA, ulCols, pDBBindings, 0, hAccessor, pDBBindStatus);
// Error handling, cleanup elided
Finalmente, você pode inserir sua linha:
hr = pRowsetChange->InsertRow(NULL, hAccessor, pbData, NULL);
O cliente nativo do SQL Server lerá seu fluxo e inserirá a linha. O salto de aro está agora feito. ReleaseAccessor
, limpeza, etc. Elided.
Outras dicas
Um blob é apenas dados binários, então você precisará usar algum tipo de matriz de bytes.