Recordset: recupero di massa di record (ODBC)

  • Articolo

Le informazioni contenute in questo argomento sono valide per le classi ODBC MFC.

La classe CRecordset fornisce il supporto per il recupero di righe bulk, il che significa che è possibile recuperare più record contemporaneamente durante un singolo recupero, anziché recuperare un record alla volta dall'origine dati. È possibile implementare il recupero delle righe bulk solo in una classe derivata CRecordset . Il processo di trasferimento dei dati dall'origine dati all'oggetto recordset è denominato scambio di campi di record bulk (RFX bulk). Si noti che se non si utilizza il recupero di righe bulk in una CRecordsetclasse derivata da , i dati vengono trasferiti tramite lo scambio di campi di record (RFX). Per altre informazioni, vedere Record Field Exchange (RFX).

In questo argomento:

Modalità di recupero delle righe bulk in CRecordset

Prima di aprire l'oggetto recordset, è possibile definire una dimensione del set di righe con la SetRowsetSize funzione membro. La dimensione del set di righe specifica il numero di record da recuperare durante un singolo recupero. Quando viene implementato il recupero delle righe bulk, la dimensione predefinita del set di righe è 25. Se il recupero delle righe bulk non viene implementato, la dimensione del set di righe rimane fissa a 1.

Dopo aver inizializzato le dimensioni del set di righe, chiamare la funzione membro Open . In questo caso è necessario specificare l'opzione CRecordset::useMultiRowFetch del parametro dwOptions per implementare il recupero delle righe bulk. È anche possibile impostare l'opzione CRecordset::userAllocMultiRowBuffers . Il meccanismo di scambio di campi di record bulk usa matrici per archiviare più righe di dati recuperate durante un recupero. Questi buffer di archiviazione possono essere allocati automaticamente dal framework oppure è possibile allocarli manualmente. Se si specifica l'opzione CRecordset::userAllocMultiRowBuffers , si eseguirà l'allocazione.

Nella tabella seguente sono elencate le funzioni membro fornite da CRecordset per supportare il recupero delle righe bulk.

Funzione membro Descrizione
CheckRowsetError Funzione virtuale che gestisce eventuali errori che si verificano durante il recupero.
DoBulkFieldExchange Implementa lo scambio di campi dei record in blocco. Chiamato automaticamente per trasferire più righe di dati dall'origine dati all'oggetto recordset.
GetRowsetSize Recupera l'impostazione corrente per le dimensioni del set di righe.
GetRowsFetched Indica il numero di righe effettivamente recuperate dopo un determinato recupero. Nella maggior parte dei casi, si tratta delle dimensioni del set di righe, a meno che non sia stato recuperato un set di righe incompleto.
GetRowStatus Restituisce uno stato di recupero per una determinata riga all'interno di un set di righe.
RefreshRowset Aggiorna i dati e lo stato di una determinata riga all'interno di un set di righe.
SetRowsetCursorPosition Sposta il cursore su una determinata riga all'interno di un set di righe.
SetRowsetSize Funzione virtuale che modifica l'impostazione per le dimensioni del set di righe sul valore specificato.

Considerazioni speciali

Anche se il recupero delle righe in blocco è un miglioramento delle prestazioni, alcune funzionalità funzionano in modo diverso. Prima di decidere di implementare il recupero delle righe bulk, tenere presente quanto segue:

  • Il framework chiama automaticamente la DoBulkFieldExchange funzione membro per trasferire i dati dall'origine dati all'oggetto recordset. Tuttavia, i dati non vengono trasferiti dal recordset all'origine dati. La chiamata alle AddNewfunzioni membro , EditDelete, o Update comporta un'asserzione non riuscita. Sebbene CRecordset attualmente non fornisca un meccanismo per l'aggiornamento di righe bulk di dati, è possibile scrivere funzioni personalizzate usando la funzione SQLSetPosAPI ODBC . Per altre informazioni su SQLSetPos, vedere le informazioni di riferimento sul programmatore ODBC.

  • Le funzioni IsDeletedmembro , IsFieldDirty, IsFieldNullIsFieldNullable, , SetFieldDirtye SetFieldNull non possono essere usate nei recordset che implementano il recupero delle righe bulk. Tuttavia, è possibile chiamare GetRowStatus al posto di IsDeletede GetODBCFieldInfo al posto di IsFieldNullable.

  • Le Move operazioni riposiziona il recordset in base al set di righe. Si supponga, ad esempio, di aprire un recordset con 100 record con una dimensione iniziale del set di righe pari a 10. Open recupera le righe da 1 a 10, con il record corrente posizionato nella riga 1. Una chiamata a MoveNext recupera il set di righe successivo, non la riga successiva. Questo set di righe è costituito da righe da 11 a 20, con il record corrente posizionato nella riga 11. Si noti che MoveNext e Move( 1 ) non sono equivalenti quando viene implementato il recupero delle righe bulk. Move( 1 ) recupera il set di righe che inizia 1 riga dal record corrente. In questo esempio, la chiamata dopo la chiamata Move( 1 ) Open recupera il set di righe costituito da righe da 2 a 11, con il record corrente posizionato sulla riga 2. Per altre informazioni, vedere la funzione membro Move .

  • A differenza dello scambio di campi di record, le procedure guidate non supportano lo scambio di campi dei record in blocco. Ciò significa che è necessario dichiarare manualmente i membri dati del campo ed eseguire manualmente l'override DoBulkFieldExchange scrivendo chiamate alle funzioni RFX bulk. Per altre informazioni, vedere Record Field Exchange Functions in the Class Library Reference .For more information, see Record Field Exchange Functions in the Class Library Reference.

Come implementare Lo scambio di campi dei record bulk

Lo scambio di campi record bulk trasferisce un set di righe di dati dall'origine dati all'oggetto recordset. Le funzioni RFX bulk usano matrici per archiviare questi dati, nonché matrici per archiviare la lunghezza di ogni elemento di dati nel set di righe. Nella definizione della classe è necessario definire i membri dei dati del campo come puntatori per accedere alle matrici di dati. Inoltre, è necessario definire un set di puntatori per accedere alle matrici di lunghezze. I membri dati dei parametri non devono essere dichiarati come puntatori; dichiarare i membri dei dati dei parametri quando si utilizza lo scambio di campi di record bulk equivale a dichiararli quando si utilizza lo scambio di campi record. Il codice seguente illustra un semplice esempio:

class MultiRowSet : public CRecordset
{
public:
   // Field/Param Data
      // field data members
      long* m_rgID;
      LPSTR m_rgName;

      // pointers for the lengths
      // of the field data
      long* m_rgIDLengths;
      long* m_rgNameLengths;

      // input parameter data member
      CString m_strNameParam;

   .
   .
   .
}

È possibile allocare manualmente questi buffer di archiviazione o disporre del framework per eseguire l'allocazione. Per allocare manualmente i buffer, è necessario specificare l'opzione CRecordset::userAllocMultiRowBuffers del parametro dwOptions nella Open funzione membro. Assicurarsi di impostare le dimensioni delle matrici almeno uguali alle dimensioni del set di righe. Se si vuole fare in modo che il framework esemetta l'allocazione, è necessario inizializzare i puntatori a NULL. Questa operazione viene in genere eseguita nel costruttore dell'oggetto recordset:

MultiRowSet::MultiRowSet( CDatabase* pDB )
   : CRecordset( pDB )
{
   m_rgID = NULL;
   m_rgName = NULL;
   m_rgIDLengths = NULL;
   m_rgNameLengths = NULL;
   m_strNameParam = "";

   m_nFields = 2;
   m_nParams = 1;

   .
   .
   .
}

Infine, è necessario eseguire l'override della DoBulkFieldExchange funzione membro. Per i membri dati sul campo, chiamare le funzioni RFX bulk; per tutti i membri dati dei parametri, chiamare le funzioni RFX. Se è stato aperto il recordset passando un'istruzione SQL o una stored procedure a Open, l'ordine in cui si effettuano le chiamate RFX bulk deve corrispondere all'ordine delle colonne nel recordset. Analogamente, l'ordine delle chiamate RFX per i parametri deve corrispondere all'ordine dei parametri nell'istruzione SQL o nella stored procedure.

void MultiRowSet::DoBulkFieldExchange( CFieldExchange* pFX )
{
   // call the Bulk RFX functions
   // for field data members
   pFX->SetFieldType( CFieldExchange::outputColumn );
   RFX_Long_Bulk( pFX, _T( "[colRecID]" ),
                  &m_rgID, &m_rgIDLengths );
   RFX_Text_Bulk( pFX, _T( "[colName]" ),
                  &m_rgName, &m_rgNameLengths, 30 );

   // call the RFX functions for
   // for parameter data members
   pFX->SetFieldType( CFieldExchange::inputParam );
   RFX_Text( pFX, "NameParam", m_strNameParam );
}

Nota

È necessario chiamare la Close funzione membro prima che la classe derivata CRecordset esula dall'ambito. In questo modo si garantisce che qualsiasi memoria allocata dal framework venga liberata. È buona norma di programmazione chiamare Closesempre in modo esplicito , indipendentemente dal fatto che sia stato implementato il recupero delle righe bulk.

Per altre informazioni sullo scambio di campi di record (RFX), vedere Scambio di campi record: Funzionamento di RFX. Per altre informazioni sull'uso dei parametri, vedere CFieldExchange::SetFieldType e Recordset: Parametrizzazione di un oggetto Recordset (ODBC).For more information about using parameters, see CFieldExchange::SetFieldType and Recordset: Parameterizing a Recordset (ODBC).

Vedi anche

Recordset (ODBC)
CRecordset::m_nFields
CRecordset::m_nParams