ILockBytes::ReadAt

Artigo
01/17/2011

ReadAt lê um número determinado de bytes a partir de um deslocamento especificado no início da matriz de bytes.

Sintaxe

HRESULT ReadAt(
ULARGE_INTEGERulOffset,
   void *pv,
   ULONG cb,
   ULONG *pcbRead 
   );

Parâmetros

Parâmetro	Descrição
ulOffset [in]	Especifica o ponto inicial a partir do início do matriz de bytes para leitura de dados
pv [in]	Ponteiro para o buffer para o qual a matriz de bytes é lida.
cb [in]	Especifica o número de bytes de dados necessários para tentar ler da matriz de bytes.
pcbRead [out]	Ponteiro ao local onde esse método gravará o número real de bytes lido da matriz de bytes. Você pode definir esse ponteiro como NULL para indicar que não tem interesse nesse valor. Nesse caso, esse método não fornece o número real de bytes que foram lidos.

Valor de retorno

Termo	Definição
NOERROR	O método obteve êxito.
E_UNEXPECTED	O conjunto de linhas está em um estado "zombied".
STG_E_INVALIDPOINTER	Um ponteiro que foi passado não era válido.

Comentários

O exemplo a seguir mostra como usar o método ILockBytes::ReadAt para recuperar dados de objetos binários grandes (BLOB). Este exemplo lê imagem dados da coluna "Photo" (Foto) da tabela Employees (Funcionários).

O exemplo a seguir foi atualizado para plataformas de 32 e 64 bits.. Os tipos compatíveis de 64 bits são do arquivo de cabeçalho nativo sqlce_oledb.h. Você pode encontrar o arquivo de cabeçalho nativo sqlce_oledb.h na pasta %Arquivos de Programas%\Microsoft SQL Server Compact Edition\v3.5\Include. Para obter mais informações, consulte o tópico de Informações de 64 bits do OLE DB na Guia do Programador do OLE DB no site da Microsoft.

Exemplo

// Declarations
HRESULT            hr;
DBBINDING          rgBindings[1];
DBPROP             dbprop[1];
DBPROPSET          dbpropset[1];
DBOBJECT           dbObject;
BYTE               pData[100];   // Buffer for holding ILockBytes pointer.
HROW               rghRows[1];   // Array of row handles obtained from rowset object.
HROW               *prghRows           = rghRows;
BYTE               pBuffer[1000];  // Buffer for holding a chunk of BLOB data.
ULARGE_INTEGER     ulOffset;
DBROWCOUNT         cRows               = 0;
IDBInitialize      *pIDBInitialize     = NULL;        
IDBProperties      *pIDBProperties     = NULL;        
IDBCreateSession   *pIDBCreateSession  = NULL;
IDBCreateCommand   *pIDBCreateCommand  = NULL;
ICommandText       *pICommandText      = NULL;
IAccessor          *pIAccessor         = NULL;
IRowset            *pIRowset           = NULL;
ILockBytes         *pILockBytes        = NULL;
HACCESSOR          hAccessor           = DB_NULL_HACCESSOR;

if (FAILED(hr = CoInitialize(NULL)))
{
    return;
}

VariantInit(&dbprop[0].vValue);        

// Create an instance of the OLE DB Provider.
hr = CoCreateInstance(CLSID_SQLSERVERCE, 0, CLSCTX_INPROC_SERVER,
                IID_IDBInitialize, (void**)&pIDBInitialize);
if(FAILED(hr))
{
    // Send error-specific message and do error handling.
    goto Exit;
}

// Initialize a property with name of the database.
// Open an exsiting database myDatabase.
dbprop[0].dwPropertyID     = DBPROP_INIT_DATASOURCE;
dbprop[0].dwOptions         = DBPROPOPTIONS_REQUIRED;
dbprop[0].vValue.vt         = VT_BSTR;
dbprop[0].vValue.bstrVal = SysAllocString(L"\\windows\\MyDB.sdf");
if(NULL == dbprop[0].vValue.bstrVal)
{
    hr = E_OUTOFMEMORY;
    goto Exit;
}

// Initialize the property set.
dbpropset[0].guidPropertySet = DBPROPSET_DBINIT;
dbpropset[0].rgProperties     = dbprop;
dbpropset[0].cProperties     = sizeof(dbprop)/sizeof(dbprop[0]);

// Set initialization properties.
hr = pIDBInitialize->QueryInterface(IID_IDBProperties, 
                (void **)&pIDBProperties);
if(FAILED(hr))
{
    goto Exit;
}

// Sets properties in data source and initialization property groups.
hr = pIDBProperties->SetProperties(1, dbpropset); 
if(FAILED(hr))
{
    goto Exit;
}

// Initializes a data source object. 
hr = pIDBInitialize->Initialize();
if(FAILED(hr))
{
    goto Exit;
}

// Get the IDBCreateSession interface.
hr = pIDBInitialize->QueryInterface(IID_IDBCreateSession,
    (void**)&pIDBCreateSession);
if (FAILED(hr))
{
    // Send error-specific message and do error handling.
    goto Exit;
}
// Get the interface to create a command.
hr = pIDBCreateSession->CreateSession(NULL, IID_IDBCreateCommand,
    (IUnknown**) &pIDBCreateCommand);
if (FAILED(hr))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}


// Create the new command that uses parameters.
hr = pIDBCreateCommand->CreateCommand(NULL, IID_ICommandText, (IUnknown**) &pICommandText);
if (FAILED(hr))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}

// Specify the command text using parameter markers in query syntax.
// This command will return 1 row and one image column (Photo).
hr = pICommandText->SetCommandText(DBGUID_DBSQL, L"SELECT Photo FROM Employees WHERE \"Employee ID\" = 2");
if (FAILED(hr))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}

hr = pICommandText->Execute(NULL, IID_IRowset, NULL, NULL, (IUnknown**) &pIRowset);
if(FAILED(hr))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}

// Create the acessor object and column specific bindings.

hr = pIRowset->QueryInterface(IID_IAccessor, (void**) &pIAccessor);
if (FAILED(hr))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}

// Create the bindings for the photo (BLOB) column.
dbObject.dwFlags = STGM_READ;
dbObject.iid     = IID_ILockBytes;
rgBindings[0].iOrdinal = 1;
rgBindings[0].obStatus = 0;
rgBindings[0].obLength = rgBindings[0].obStatus + sizeof(DBSTATUS);
rgBindings[0].obValue = rgBindings[0].obLength + sizeof(DBLENGTH);
rgBindings[0].pTypeInfo = NULL;
rgBindings[0].pObject = &dbObject;
rgBindings[0].pBindExt = NULL;
rgBindings[0].dwPart = DBPART_VALUE | DBPART_LENGTH | DBPART_STATUS;
rgBindings[0].dwMemOwner = DBMEMOWNER_CLIENTOWNED;
rgBindings[0].eParamIO = DBPARAMIO_NOTPARAM;
rgBindings[0].cbMaxLen = sizeof(IUnknown*);
rgBindings[0].dwFlags = 0;
rgBindings[0].wType = DBTYPE_IUNKNOWN;
rgBindings[0].bPrecision = 0;
rgBindings[0].bScale = 0;

// Create accessor.
hr = pIAccessor->CreateAccessor(DBACCESSOR_ROWDATA, 1, rgBindings,
    0, &hAccessor, NULL);
if(FAILED(hr))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}

// Get the first row.
hr = pIRowset->GetNextRows(NULL, 0, 1, &cRows, &prghRows);
if(FAILED(hr) || (0 == cRows))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}

// Get the ILockBytes pointer.
hr = pIRowset->GetData(rghRows[0], hAccessor, pData);
if(FAILED(hr))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}

if(DBSTATUS_S_OK != *(DBSTATUS*)(pData + rgBindings[0].obStatus))
{
    // Send an error-specific message and do error handling.
    goto Exit;
}

// Get the ILockBytes pointer from the buffer.
pILockBytes = *(ILockBytes**)(pData + rgBindings[0].obValue);

// Initialize Offset. 
ulOffset.QuadPart = 0;

// Retrieve data from the interface in chunks. 
// The infinite loop for(;;) will terminate when the ReadAt call fails 
//   or if fewer bytes are returned than were requested. 
for(;;)

{

    ULONG cbRead;

    // Read data at the specified offset.
    hr = pILockBytes->ReadAt(ulOffset, pBuffer, sizeof(pBuffer)-sizeof(WCHAR), 
    &cbRead);

///////////////////////////////////////////////////////////////////////
// Do some useful things here with the chunks of data.
///////////////////////////////////////////////////////////////////////

    if(cbRead < sizeof(pBuffer)-sizeof(WCHAR) || FAILED(hr)) break;

    ulOffset.QuadPart += cbRead;
}

// If more rows need to be read, release the ILockBytes pointer  
//   and row handle here.

Exit: 

// When finished, clear the properties arrays and release interfaces.
// Uninitialize the environment.

return;

Consulte também

Outros recursos

ILockBytes (SQL Server Compact)

ILockBytes::SetSize

ILockBytes::Stat

ILockBytes::WriteAt

Partilhar via