class WorkStream : public ISequentialStream
{
private:  
   ULONG m_ulRefCount;  
   ULONG m_ulBufSize;  
   ULONG m_ulReadSize;  
   ULONG m_ulBytesLeft;  
   ULONG m_ulReadPos;  
   BYTE * m_pSrcData;  
   BYTE * m_pReadPtr;  
   BOOL m_fWasRead;  

public:

   WorkStream() {  
      m_ulRefCount = 1;  
      m_ulBufSize = 0;  
      m_ulReadSize = 0;  
      m_ulBytesLeft = 0;  
      m_ulReadPos = 0;  
      m_pSrcData = NULL;  
      m_pReadPtr = NULL;  
      m_fWasRead = FALSE;  
   }  
  
   ~WorkStream() {}  
  
   virtual ULONG STDMETHODCALLTYPE AddRef() {  
      return ++m_ulRefCount;  
   }  
  
   virtual ULONG STDMETHODCALLTYPE Release() {  
      --m_ulRefCount;  
      if (m_ulRefCount == 0) {  
         delete this;  
         return 0;  
      }  
      return m_ulRefCount;  
   }  
  
   virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void ** ppvObj) {  
      if (!ppvObj)  
         return E_INVALIDARG;  
      else  
         *ppvObj = NULL;  
  
      if (riid != IID_ISequentialStream && riid != IID_IUnknown)  
         return E_NOINTERFACE;  
  
      AddRef();  
      *ppvObj = this;  
      return S_OK;  
   }  
  
   HRESULT Init(const void * pSrcData, const ULONG ulBufSize, const ULONG ulReadSize) {  
      if (NULL == pSrcData)  
         return E_INVALIDARG;  
  
      // Data length must be non-zero  
      if (0 == ulBufSize)  
         return E_INVALIDARG;  
  
      m_ulBufSize = ulBufSize;  
      m_ulReadSize = ulReadSize;  
      m_pSrcData = (BYTE *)pSrcData;  
      m_pReadPtr = m_pSrcData;  
      m_ulBytesLeft = m_ulReadSize;  
      m_ulReadPos = 0;  
      m_fWasRead = FALSE;  
  
      return S_OK;  
   }  
  
   // Can't write data to SQL Server providers (SQLOLEDB/SQLNCLI).  Instead, they read from our object.  
   virtual HRESULT STDMETHODCALLTYPE Write(const void *, ULONG, ULONG * ) {  
      return E_NOTIMPL;  
   }  
  
   // This implementation simply copies data from the source buffer in whatever size requested.  
   // But you can do anything here such as reading from a file, reading from a different rowset, stream, etc.  
   virtual HRESULT STDMETHODCALLTYPE Read(void * pv, ULONG cb, ULONG * pcbRead) {  // cb всегда 1024 байта.
      ULONG ulBytesWritten = 0;  
      ULONG ulCBToWrite = cb;  
      ULONG ulCBToCopy;  
      BYTE * pvb = (BYTE *)pv;  
  
      m_fWasRead = TRUE;  
  
      if (NULL == m_pSrcData)  
         return E_FAIL;  
  
      if (NULL == pv)  
         return STG_E_INVALIDPOINTER;  
  
      while (ulBytesWritten < ulCBToWrite && m_ulBytesLeft) {  
         // Make sure we don't write more than our max read size or the size they asked for  
         ulCBToCopy = min(m_ulBytesLeft, cb);  
  
         // Make sure we don't read past the end of the internal buffer  
         ulCBToCopy = min(m_ulBufSize - m_ulReadPos, ulCBToCopy);  
  
         memcpy(pvb, m_pReadPtr + m_ulReadPos, ulCBToCopy);  
         pvb += ulCBToCopy;  
         ulBytesWritten += ulCBToCopy;  
         m_ulBytesLeft -= ulCBToCopy;  
         cb -= ulCBToCopy;  
  
         // Wrap reads around the src buffer  
         m_ulReadPos += ulCBToCopy;  
         if (m_ulReadPos >= m_ulBufSize)  
            m_ulReadPos = 0;  
      }  
  
      if (pcbRead)  
         *pcbRead = ulBytesWritten;  
  
      return S_OK;  
   }  
};

struct SP_Insert_Blobs_PARAMS
{
    VARIANT        params[6];

    ISequentialStream*  pISeqStreamData;
    DBLENGTH        blobLengthData;

    SP_Insert_Blobs_PARAMS() { for(int i = 0; i < 6; i++) VariantInit(&params[i]);}
    ~SP_Insert_Blobs_PARAMS() { for(int i = 0; i < 6; i++) VariantClear(&params[i]);}
};

DBBINDING*    acDBBinding = new DBBINDING[paramsCount];

for(int i = 0; i < paramsCount; i++)
{
    acDBBinding[i].obLength = 0;
    acDBBinding[i].obStatus = 0;
    acDBBinding[i].pTypeInfo = NULL;
    acDBBinding[i].pObject = NULL;
    acDBBinding[i].pBindExt = NULL;
    acDBBinding[i].dwPart = DBPART_VALUE;
    acDBBinding[i].dwMemOwner = DBMEMOWNER_CLIENTOWNED;
    acDBBinding[i].dwFlags = 0;
    acDBBinding[i].bScale = 0;
}

acDBBinding[0].iOrdinal = 1;
acDBBinding[0].obValue = offsetof(SP_Insert_Blobs_PARAMS, params[0]);
acDBBinding[0].eParamIO = DBPARAMIO_INPUT;
acDBBinding[0].cbMaxLen = sizeof(VARIANT);
acDBBinding[0].wType = DBTYPE_VARIANT;
acDBBinding[0].bPrecision = 11;

acDBBinding[1].iOrdinal = 2;
acDBBinding[1].obValue = offsetof(SP_Insert_Blobs_PARAMS, params[1]);
acDBBinding[1].eParamIO = DBPARAMIO_INPUT;
acDBBinding[1].cbMaxLen = sizeof(VARIANT);
acDBBinding[1].wType = DBTYPE_VARIANT;
acDBBinding[1].bPrecision = 11;

acDBBinding[2].iOrdinal = 3;
acDBBinding[2].obValue = offsetof(SP_Insert_Blobs_PARAMS, pISeqStreamData);
acDBBinding[2].obLength = offsetof(SP_Insert_Blobs_PARAMS, blobLengthData);
acDBBinding[2].dwPart = DBPART_VALUE | DBPART_LENGTH;
acDBBinding[2].pObject = new DBOBJECT();
acDBBinding[2].pObject->dwFlags = STGM_READ;
acDBBinding[2].pObject->iid = IID_ISequentialStream;
acDBBinding[2].eParamIO = DBPARAMIO_INPUT;
acDBBinding[2].cbMaxLen = 0;
acDBBinding[2].wType = DBTYPE_IUNKNOWN;
acDBBinding[2].bPrecision = 11;

...

CreateStoredProcedure(Name, paramsCount, sizeof(VARIANT) * paramsCount, acDBBinding);

delete[] acDBBinding;

WorkStream* pWorkStream = new WorkStream();
pWorkStream->AddRef();
pWorkStream->Init(pByte, ullSize, ullSize);
    
SP_Insert_Blobs_PARAMS    tmpBlobs;


tmpBlobs.params[0] = variant_t((long)1009);        
tmpBlobs.params[1] = _variant_t(TEXT("SimpleFileName"));

tmpBlobs.pISeqStreamData = (ISequentialStream*)pWorkStream;
tmpBlobs.blobLengthData = ullSize;

ExecuteStoredProcedure((LPVOID)&tmpBlobs);