SQLBulkOperations-Funktion

Konformität
Version eingeführt: ODBC 3.0-Standardkonformität: ODBC

Zusammenfassung
SQLBulkOperations führt Masseneinfügungen und Massenlesevorgänge durch, einschließlich Aktualisieren, Löschen und Abrufen per Lesezeichen.

Syntax

  
SQLRETURN SQLBulkOperations(  
     SQLHSTMT       StatementHandle,  
     SQLUSMALLINT   Operation);  

Argumente

StatementHandle
[Eingabe] Anweisungshandle.

Vorgang
[Eingabe] Auszuführende Operation:

SQL_ADD SQL_UPDATE_BY_BOOKMARK SQL_DELETE_BY_BOOKMARK SQL_FETCH_BY_BOOKMARK

Weitere Informationen finden Sie unter Kommentare.

Gibt zurück

SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_NEED_DATA, SQL_STILL_EXECUTING, SQL_ERROR oder SQL_INVALID_HANDLE.

Diagnose

Wenn SQLBulkOperations SQL_ERROR oder SQL_SUCCESS_WITH_INFO zurückgibt, kann ein zugeordneter SQLSTATE-Wert abgerufen werden, indem SQLGetDiagRec mit einem HandleType von SQL_HANDLE_STMT und einem Handle of StatementHandle aufgerufen wird. In der folgenden Tabelle sind die SQLSTATE-Werte aufgeführt, die in der Regel von SQLBulkOperations zurückgegeben werden, und die einzelnen Werte werden im Kontext dieser Funktion erläutert. die Notation "(DM)" geht den Beschreibungen von SQLSTATEs voran, die vom Treiber-Manager zurückgegeben werden. Der rückgabecode, der jedem SQLSTATE-Wert zugeordnet ist, ist SQL_ERROR, sofern nicht anders angegeben.

Für alle SQLSTATEs, die SQL_SUCCESS_WITH_INFO oder SQL_ERROR zurückgeben können (außer 01xxx SQLSTATEs), wird SQL_SUCCESS_WITH_INFO zurückgegeben, wenn ein Fehler für eine oder mehrere Zeilen eines Mehrzeilenvorgangs auftritt, und SQL_ERROR zurückgegeben wird, wenn ein Fehler bei einem Einzeilenvorgang auftritt.

Kommentare

Eine Anwendung verwendet SQLBulkOperations , um die folgenden Vorgänge für die Basistabelle oder -sicht auszuführen, die der aktuellen Abfrage entspricht:

• Fügen Sie neue Zeilen hinzu.

• Aktualisieren Sie eine Reihe von Zeilen, in denen jede Zeile durch ein Lesezeichen identifiziert wird.

• Löschen Sie eine Reihe von Zeilen, in denen jede Zeile durch ein Lesezeichen identifiziert wird.

• Ruft eine Reihe von Zeilen ab, in denen jede Zeile durch ein Lesezeichen identifiziert wird.

Nach einem Aufruf von SQLBulkOperations ist die Position des Blockcursors nicht definiert. Die Anwendung muss SQLFetchScroll aufrufen, um die Cursorposition festzulegen. Eine Anwendung sollte SQLFetchScroll nur mit dem FetchOrientation-Argument SQL_FETCH_FIRST, SQL_FETCH_LAST, SQL_FETCH_ABSOLUTE oder SQL_FETCH_BOOKMARK aufrufen. Die Cursorposition ist nicht definiert, wenn die Anwendung SQLFetch oder SQLFetchScroll mit dem FetchOrientation-Argument SQL_FETCH_PRIOR, SQL_FETCH_NEXT oder SQL_FETCH_RELATIVE aufruft.

Eine Spalte kann in Massenvorgängen ignoriert werden, die durch einen Aufruf von SQLBulkOperations ausgeführt werden, indem sie die Spaltenlänge/den Indikatorpuffer, der im Aufruf von SQLBindCol angegeben ist, auf SQL_COLUMN_IGNORE festlegen.

Es ist nicht erforderlich, dass die Anwendung das Attribut SQL_ATTR_ROW_OPERATION_PTR-Anweisung beim Aufrufen von SQLBulkOperations festlegen, da Zeilen beim Ausführen von Massenvorgängen mit dieser Funktion nicht ignoriert werden können.

Der Puffer, auf den das SQL_ATTR_ROWS_FETCHED_PTR-Anweisungsattribut verweist, enthält die Anzahl der Zeilen, die von einem Aufruf von SQLBulkOperations betroffen sind.

Wenn das Argument Operation SQL_ADD oder SQL_UPDATE_BY_BOOKMARK ist und die Auswahlliste der Abfragespezifikation, die dem Cursor zugeordnet ist, mehr als einen Verweis auf dieselbe Spalte enthält, wird vom Treiber definiert, ob ein Fehler generiert wird oder der Treiber die duplizierten Verweise ignoriert und die angeforderten Vorgänge ausführt.

Weitere Informationen zur Verwendung von SQLBulkOperations finden Sie unter Aktualisieren von Daten mit SQLBulkOperations.

Ausführen von Masseneinfügungen

Um Daten mit SQLBulkOperations einzufügen, führt eine Anwendung die folgenden Schritte aus:

1. Führt eine Abfrage aus, die ein Resultset zurückgibt.

2. Legt das Attribut der SQL_ATTR_ROW_ARRAY_SIZE-Anweisung auf die Anzahl der Zeilen fest, die eingefügt werden sollen.

3. Ruft SQLBindCol auf, um die Daten zu binden, die eingefügt werden sollen. Die Daten sind an ein Array mit einer Größe gebunden, die dem Wert von SQL_ATTR_ROW_ARRAY_SIZE entspricht.

   Hinweis

   Die Größe des Arrays, auf das das Attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung verweist, sollte entweder gleich SQL_ATTR_ROW_ARRAY_SIZE oder SQL_ATTR_ROW_STATUS_PTR ein NULL-Zeiger sein.

4. Ruft SQLBulkOperations(StatementHandle, SQL_ADD) auf, um die Einfügung durchzuführen.

5. Wenn die Anwendung das Attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung festgelegt hat, kann sie dieses Array überprüfen, um das Ergebnis des Vorgangs zu sehen.

Wenn eine Anwendung Spalte 0 bindet, bevor SQLBulkOperations mit dem Argument Operation SQL_ADD aufgerufen wird, aktualisiert der Treiber die gebundenen Puffer von Spalte 0 mit den Lesezeichenwerten für die neu eingefügte Zeile. Damit dies geschieht, muss die Anwendung das Attribut SQL_ATTR_USE_BOOKMARKS-Anweisung auf SQL_UB_VARIABLE festgelegt haben, bevor die Anweisung ausgeführt wird. (Dies funktioniert nicht mit ODBC 2. x Treiber.)

Lange Daten können von SQLBulkOperations mithilfe von Aufrufen von SQLParamData und SQLPutData in Teilen hinzugefügt werden. Weitere Informationen finden Sie weiter unten in dieser Funktionsreferenz unter Bereitstellen langer Daten für Masseneinfügungen und Aktualisierungen.

Es ist nicht erforderlich, dass die Anwendung SQLFetch oder SQLFetchScroll aufruft, bevor SQLBulkOperations aufgerufen wird (außer bei verwendung von ODBC 2. x Treiber; siehe Abwärtskompatibilität und Standardkonformität).

Das Verhalten ist treiberdefiniert, wenn SQLBulkOperations mit dem Argument Operation SQL_ADD auf einem Cursor aufgerufen wird, der doppelte Spalten enthält. Der Treiber kann einen vom Treiber definierten SQLSTATE zurückgeben, die Daten der ersten Spalte hinzufügen, die im Resultset angezeigt wird, oder ein anderes vom Treiber definiertes Verhalten ausführen.

Ausführen von Massen Aktualisierungen mithilfe von Lesezeichen

Um Massenupdates mithilfe von Lesezeichen mit SQLBulkOperations durchzuführen, führt eine Anwendung die folgenden Schritte nacheinander aus:

1. Legt das Attribut SQL_ATTR_USE_BOOKMARKS-Anweisung auf SQL_UB_VARIABLE fest.

2. Führt eine Abfrage aus, die ein Resultset zurückgibt.

3. Legt das Attribut SQL_ATTR_ROW_ARRAY_SIZE-Anweisung auf die Anzahl der Zeilen fest, die aktualisiert werden sollen.

4. Ruft SQLBindCol auf, um die Zu aktualisierenden Daten zu binden. Die Daten sind an ein Array mit einer Größe gebunden, die dem Wert von SQL_ATTR_ROW_ARRAY_SIZE entspricht. Außerdem wird SQLBindCol aufgerufen, um Spalte 0 (die Lesezeichenspalte) zu binden.

5. Kopiert die Lesezeichen für Zeilen, die an der Aktualisierung interessiert sind, in das Array, das an Spalte 0 gebunden ist.

6. Aktualisierungen die Daten in den gebundenen Puffern.

   Hinweis

   Die Größe des Arrays, auf das vom attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung verwiesen wird, sollte gleich SQL_ATTR_ROW_ARRAY_SIZE sein, oder SQL_ATTR_ROW_STATUS_PTR sollte ein NULL-Zeiger sein.

7. Ruft SQLBulkOperations(StatementHandle, SQL_UPDATE_BY_BOOKMARK) auf.

   Hinweis

   Wenn die Anwendung das Attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung festgelegt hat, kann sie dieses Array überprüfen, um das Ergebnis des Vorgangs zu sehen.

8. Ruft optional SQLBulkOperations(StatementHandle, SQL_FETCH_BY_BOOKMARK) auf, um Daten in die gebundenen Anwendungspuffer abzurufen, um zu überprüfen, ob das Update erfolgt ist.

9. Wenn Daten aktualisiert wurden, ändert der Treiber den Wert im Zeilenstatusarray für die entsprechenden Zeilen in SQL_ROW_UPDATED.

Massenupdates, die von SQLBulkOperations ausgeführt werden, können lange Daten enthalten, indem Aufrufe von SQLParamData und SQLPutData verwendet werden. Weitere Informationen finden Sie weiter unten in dieser Funktionsreferenz unter Bereitstellen langer Daten für Masseneinfügungen und Aktualisierungen.

Wenn Lesezeichen cursorübergreifend beibehalten werden, muss die Anwendung sqlFetch oder SQLFetchScroll vor der Aktualisierung durch Lesezeichen nicht aufrufen. Es kann Lesezeichen verwenden, die von einem vorherigen Cursor gespeichert wurden. Wenn Lesezeichen nicht cursorübergreifend beibehalten werden, muss die Anwendung SQLFetch oder SQLFetchScroll aufrufen, um die Lesezeichen abzurufen.

Das Verhalten ist treiberdefiniert, wenn SQLBulkOperations mit dem Argument Operation SQL_UPDATE_BY_BOOKMARK auf einem Cursor aufgerufen wird, der doppelte Spalten enthält. Der Treiber kann einen vom Treiber definierten SQLSTATE zurückgeben, die erste Spalte aktualisieren, die im Resultset angezeigt wird, oder ein anderes vom Treiber definiertes Verhalten ausführen.

Ausführen von Massenabrufen mithilfe von Lesezeichen

Um Massenabrufe mithilfe von Lesezeichen mit SQLBulkOperations durchzuführen, führt eine Anwendung die folgenden Schritte nacheinander aus:

1. Legt das Attribut SQL_ATTR_USE_BOOKMARKS-Anweisung auf SQL_UB_VARIABLE fest.

2. Führt eine Abfrage aus, die ein Resultset zurückgibt.

3. Legt das SQL_ATTR_ROW_ARRAY_SIZE-Anweisungsattribut auf die Anzahl der Zeilen fest, die abgerufen werden sollen.

4. Ruft SQLBindCol auf, um die Daten zu binden, die abgerufen werden sollen. Die Daten sind an ein Array mit einer Größe gebunden, die dem Wert von SQL_ATTR_ROW_ARRAY_SIZE entspricht. Außerdem wird SQLBindCol aufgerufen, um Spalte 0 (die Lesezeichenspalte) zu binden.

5. Kopiert die Lesezeichen für Zeilen, die sie abrufen möchten, in das an Spalte 0 gebundene Array. (Dabei wird vorausgesetzt, dass die Anwendung die Lesezeichen bereits separat abgerufen hat.)

   Hinweis

   Die Größe des Arrays, auf das vom attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung verwiesen wird, sollte gleich SQL_ATTR_ROW_ARRAY_SIZE sein, oder SQL_ATTR_ROW_STATUS_PTR sollte ein NULL-Zeiger sein.

6. Ruft SQLBulkOperations(StatementHandle, SQL_FETCH_BY_BOOKMARK) auf.

7. Wenn die Anwendung das Attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung festgelegt hat, kann sie dieses Array überprüfen, um das Ergebnis des Vorgangs zu sehen.

Wenn Lesezeichen cursorübergreifend beibehalten werden, muss die Anwendung SQLFetch oder SQLFetchScroll nicht aufrufen, bevor sie über Lesezeichen abgerufen wird. Es kann Lesezeichen verwenden, die von einem vorherigen Cursor gespeichert wurden. Wenn Lesezeichen nicht cursorübergreifend beibehalten werden, muss die Anwendung SQLFetch oder SQLFetchScroll einmal aufrufen, um die Lesezeichen abzurufen.

Ausführen von Massenlöschvorgängen mithilfe von Lesezeichen

Zum Ausführen von Massenlöschvorgängen mithilfe von Lesezeichen mit SQLBulkOperations führt eine Anwendung die folgenden Schritte nacheinander aus:

1. Legt das Attribut SQL_ATTR_USE_BOOKMARKS-Anweisung auf SQL_UB_VARIABLE fest.

2. Führt eine Abfrage aus, die ein Resultset zurückgibt.

3. Legt das Attribut SQL_ATTR_ROW_ARRAY_SIZE-Anweisung auf die Anzahl der Zeilen fest, die gelöscht werden sollen.

4. Ruft SQLBindCol auf, um Spalte 0 (die Lesezeichenspalte) zu binden.

5. Kopiert die Lesezeichen für Zeilen, die gelöscht werden sollen, in das Array, das an Spalte 0 gebunden ist.

   Hinweis

   Die Größe des Arrays, auf das vom attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung verwiesen wird, sollte gleich SQL_ATTR_ROW_ARRAY_SIZE sein, oder SQL_ATTR_ROW_STATUS_PTR sollte ein NULL-Zeiger sein.

6. Ruft SQLBulkOperations(StatementHandle, SQL_DELETE_BY_BOOKMARK) auf.

7. Wenn die Anwendung das Attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung festgelegt hat, kann sie dieses Array überprüfen, um das Ergebnis des Vorgangs zu sehen.

Wenn Lesezeichen cursorübergreifend beibehalten werden, muss die Anwendung SQLFetch oder SQLFetchScroll nicht aufrufen, bevor sie durch Lesezeichen gelöscht wird. Es kann Lesezeichen verwenden, die von einem vorherigen Cursor gespeichert wurden. Wenn Lesezeichen nicht cursorübergreifend beibehalten werden, muss die Anwendung SQLFetch oder SQLFetchScroll einmal aufrufen, um die Lesezeichen abzurufen.

Bereitstellen langer Daten für Masseneinfügungen und Aktualisierungen

Lange Daten können für Masseneinfügungen und Updates bereitgestellt werden, die durch Aufrufe von SQLBulkOperations ausgeführt werden. Um lange Daten einzufügen oder zu aktualisieren, führt eine Anwendung die folgenden Schritte aus, zusätzlich zu den Schritten, die weiter oben in diesem Thema in den Abschnitten "Ausführen von Masseneinfügungen" und "Ausführen von Massenvorgängen Aktualisierungen Verwenden von Lesezeichen" beschrieben sind.

1. Wenn die Daten mithilfe von SQLBindCol gebunden werden, platziert die Anwendung einen anwendungsdefinierten Wert, z. B. die Spaltennummer, im *TargetValuePtr-Puffer für Daten bei der Ausführung. Der Wert kann später verwendet werden, um die Spalte zu identifizieren.

   Die Anwendung platziert das Ergebnis des makros SQL_LEN_DATA_AT_EXEC(length) im Puffer *StrLen_or_IndPtr . Wenn der SQL-Datentyp der Spalte SQL_LONGVARBINARY, SQL_LONGVARCHAR oder ein langer datenquellenspezifischer Datentyp ist und der Treiber "Y" für den SQL_NEED_LONG_DATA_LEN Informationstyp in SQLGetInfo zurückgibt, gibt die Länge die Anzahl der Bytes an, die für den Parameter gesendet werden sollen. Andernfalls muss es sich um einen nicht abweichenden Wert handelt und wird ignoriert.

2. Wenn SQLBulkOperations aufgerufen wird, gibt die Funktion datenbasierte Spalten bei der Ausführung zurück, SQL_NEED_DATA und fährt mit Schritt 3 fort, der folgt. (Wenn keine Data-at-Execution-Spalten vorhanden sind, ist der Prozess abgeschlossen.)

3. Die Anwendung ruft SQLParamData auf, um die Adresse des *TargetValuePtr-Puffers für die erste zu verarbeitende Data-at-Execution-Spalte abzurufen. SQLParamData gibt SQL_NEED_DATA zurück. Die Anwendung ruft den von der Anwendung definierten Wert aus dem *TargetValuePtr-Puffer ab.

   Hinweis

   Obwohl Data-at-Execution-Parameter Daten bei ausführungsbasierten Spalten ähneln, ist der von SQLParamData zurückgegebene Wert für jeden von unterschiedlich.

   Data-at-Execution-Spalten sind Spalten in einem Rowset, für die Daten mit SQLPutData gesendet werden, wenn eine Zeile mit SQLBulkOperations aktualisiert oder eingefügt wird. Sie sind an SQLBindCol gebunden. Der von SQLParamData zurückgegebene Wert ist die Adresse der Zeile im *TargetValuePtr-Puffer , der verarbeitet wird.

4. Die Anwendung ruft SQLPutData mehrmals auf, um Daten für die Spalte zu senden. Mehrere Aufrufe sind erforderlich, wenn der gesamte Datenwert nicht im * TargetValuePtr-Puffer zurückgegeben werden kann, der in SQLPutData angegeben ist. Mehrere Aufrufe von SQLPutData für dieselbe Spalte sind nur beim Senden von Zeichen C-Daten an eine Spalte mit einem Zeichen-, Binär- oder datenquellenspezifischen Datentyp oder beim Senden von binären C-Daten an eine Spalte mit einem Zeichen-, Binär- oder datenquellenspezifischen Datentyp zulässig.

5. Die Anwendung ruft SQLParamData erneut auf, um zu signalisieren, dass alle Daten für die Spalte gesendet wurden.

   • Wenn mehr Data-at-Execution-Spalten vorhanden sind, gibt SQLParamData SQL_NEED_DATA und die Adresse des TargetValuePtr-Puffers für die nächste zu verarbeitende Data-at-Execution-Spalte zurück. Die Anwendung wiederholt die Schritte 4 und 5.

   • Wenn keine weiteren Datenspalten bei der Ausführung vorhanden sind, ist der Prozess abgeschlossen. Wenn die Anweisung erfolgreich ausgeführt wurde, gibt SQLParamData SQL_SUCCESS oder SQL_SUCCESS_WITH_INFO zurück. wenn bei der Ausführung ein Fehler aufgetreten ist, wird SQL_ERROR zurückgegeben. An diesem Punkt kann SQLParamData jeden SQLSTATE zurückgeben, der von SQLBulkOperations zurückgegeben werden kann.

Wenn der Vorgang abgebrochen wird oder ein Fehler in SQLParamData oder SQLPutData auftritt, nachdem SQLBulkOperations SQL_NEED_DATA zurückgibt und bevor Daten für alle Data-at-Execution-Spalten gesendet werden, kann die Anwendung nur SQLCancel, SQLGetDiagField, SQLGetDiagRec, SQLGetFunctions, SQLParamData oder SQLPutData für die Anweisung oder die verbindung aufrufen, die der Anweisung zugeordnet ist. Wenn eine andere Funktion für die -Anweisung oder die der -Anweisung zugeordnete Verbindung aufgerufen wird, gibt die Funktion SQL_ERROR und SQLSTATE HY010 (Funktionssequenzfehler) zurück.

Wenn die Anwendung SQLCancel aufruft, während der Treiber weiterhin Daten für Daten bei der Ausführung benötigt, bricht der Treiber den Vorgang ab. Die Anwendung kann SQLBulkOperations dann erneut aufrufen. Das Abbrechen wirkt sich nicht auf den Cursorzustand oder die aktuelle Cursorposition aus.

Zeilenstatusarray

Das Zeilenstatusarray enthält Statuswerte für jede Datenzeile im Rowset nach einem Aufruf von SQLBulkOperations. Der Treiber legt die Statuswerte in diesem Array nach einem Aufruf von SQLFetch, SQLFetchScroll, SQLSetPos oder SQLBulkOperations fest. Dieses Array wird zunächst durch einen Aufruf von SQLBulkOperations aufgefüllt, wenn SQLFetch oder SQLFetchScroll vor SQLBulkOperations nicht aufgerufen wurde. Auf dieses Array verweist das Attribut SQL_ATTR_ROW_STATUS_PTR-Anweisung. Die Anzahl der Elemente in den Zeilenstatusarrays muss der Anzahl von Zeilen im Rowset entsprechen (wie durch das SQL_ATTR_ROW_ARRAY_SIZE-Anweisungsattribut definiert). Informationen zu diesem Zeilenstatusarray finden Sie unter SQLFetch.

Codebeispiel

Im folgenden Beispiel werden 10 Datenzeilen gleichzeitig aus der Tabelle Customers abgerufen. Anschließend wird der Benutzer aufgefordert, eine Aktion auszuführen. Um den Netzwerkdatenverkehr zu reduzieren, aktualisiert, löscht und fügt der Beispielpuffer lokal in den gebundenen Arrays ein, aber bei Offsets über die Rowsetdaten hinaus. Wenn der Benutzer Updates, Löschvorgänge und Einfügevorgänge an die Datenquelle sendet, legt der Code den Bindungsoffset entsprechend fest und ruft SQLBulkOperations auf. Der Einfachheit halber kann der Benutzer nicht mehr als 10 Updates, Löschvorgänge oder Einfügungen puffern.

// SQLBulkOperations_Function.cpp  
// compile with: ODBC32.lib  
#include <windows.h>  
#include <sqlext.h>  
#include "stdio.h"  
  
#define UPDATE_ROW 100  
#define DELETE_ROW 101  
#define ADD_ROW 102  
#define SEND_TO_DATA_SOURCE 103  
#define UPDATE_OFFSET 10  
#define INSERT_OFFSET 20  
#define DELETE_OFFSET 30  
  
// Define structure for customer data (assume 10 byte maximum bookmark size).  
typedef struct tagCustStruct {  
   SQLCHAR Bookmark[10];  
   SQLINTEGER BookmarkLen;  
   SQLUINTEGER CustomerID;  
   SQLINTEGER CustIDInd;  
   SQLCHAR CompanyName[51];  
   SQLINTEGER NameLenOrInd;  
   SQLCHAR Address[51];  
   SQLINTEGER AddressLenOrInd;  
   SQLCHAR Phone[11];  
   SQLINTEGER PhoneLenOrInd;  
} CustStruct;  
  
// Allocate 40 of these structures. Elements 0-9 are for the current rowset,  
// elements 10-19 are for the buffered updates, elements 20-29 are for  
// the buffered inserts, and elements 30-39 are for the buffered deletes.  
CustStruct CustArray[40];  
SQLUSMALLINT RowStatusArray[10], Action, RowNum, NumUpdates = 0, NumInserts = 0,  
NumDeletes = 0;  
SQLLEN BindOffset = 0;  
SQLRETURN retcode;  
SQLHENV henv = NULL;  
SQLHDBC hdbc = NULL;  
SQLHSTMT hstmt = NULL;  
  
int main() {  
   retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv);  
   retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER*)SQL_OV_ODBC3, 0);   
  
   retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc);   
   retcode = SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, 0);  
  
   retcode = SQLConnect(hdbc, (SQLCHAR*) "Northwind", SQL_NTS, (SQLCHAR*) NULL, 0, NULL, 0);  
   retcode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);  
  
   // Set the following statement attributes:  
   // SQL_ATTR_CURSOR_TYPE:           Keyset-driven  
   // SQL_ATTR_ROW_BIND_TYPE:         Row-wise  
   // SQL_ATTR_ROW_ARRAY_SIZE:        10  
   // SQL_ATTR_USE_BOOKMARKS:         Use variable-length bookmarks  
   // SQL_ATTR_ROW_STATUS_PTR:        Points to RowStatusArray  
   // SQL_ATTR_ROW_BIND_OFFSET_PTR:   Points to BindOffset  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_CURSOR_TYPE, (SQLPOINTER)SQL_CURSOR_KEYSET_DRIVEN, 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_BIND_TYPE, (SQLPOINTER)sizeof(CustStruct), 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)10, 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_USE_BOOKMARKS, (SQLPOINTER)SQL_UB_VARIABLE, 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_STATUS_PTR, RowStatusArray, 0);  
   retcode = SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_BIND_OFFSET_PTR, &BindOffset, 0);  
  
   // Bind arrays to the bookmark, CustomerID, CompanyName, Address, and Phone columns.  
   retcode = SQLBindCol(hstmt, 0, SQL_C_VARBOOKMARK, CustArray[0].Bookmark, sizeof(CustArray[0].Bookmark), &CustArray[0].BookmarkLen);  
   retcode = SQLBindCol(hstmt, 1, SQL_C_ULONG, &CustArray[0].CustomerID, 0, &CustArray[0].CustIDInd);  
   retcode = SQLBindCol(hstmt, 2, SQL_C_CHAR, CustArray[0].CompanyName, sizeof(CustArray[0].CompanyName), &CustArray[0].NameLenOrInd);  
   retcode = SQLBindCol(hstmt, 3, SQL_C_CHAR, CustArray[0].Address, sizeof(CustArray[0].Address), &CustArray[0].AddressLenOrInd);  
   retcode = SQLBindCol(hstmt, 4, SQL_C_CHAR, CustArray[0].Phone, sizeof(CustArray[0].Phone), &CustArray[0].PhoneLenOrInd);  
  
   // Execute a statement to retrieve rows from the Customers table.  
   retcode = SQLExecDirect(hstmt, (SQLCHAR*)"SELECT CustomerID, CompanyName, Address, Phone FROM Customers", SQL_NTS);  
  
   // Fetch and display the first 10 rows.  
   retcode = SQLFetchScroll(hstmt, SQL_FETCH_NEXT, 0);  
   // DisplayCustData(CustArray, 10);  
  
   // Call GetAction to get an action and a row number from the user.  
   // while (GetAction(&Action, &RowNum)) {  
   Action = SQL_FETCH_NEXT;  
   RowNum = 2;  
   switch (Action) {  
      case SQL_FETCH_NEXT:  
      case SQL_FETCH_PRIOR:  
      case SQL_FETCH_FIRST:  
      case SQL_FETCH_LAST:  
      case SQL_FETCH_ABSOLUTE:  
      case SQL_FETCH_RELATIVE:  
         // Fetch and display the requested data.  
         SQLFetchScroll(hstmt, Action, RowNum);  
         // DisplayCustData(CustArray, 10);  
         break;  
  
      case UPDATE_ROW:  
         // Check if we have reached the maximum number of buffered updates.  
         if (NumUpdates < 10) {  
            // Get the new customer data and place it in the next available element of  
            // the buffered updates section of CustArray, copy the bookmark of the row  
            // being updated to the same element, and increment the update counter.  
            // Checking to see we have not already buffered an update for this  
            // row not shown.  
            // GetNewCustData(CustArray, UPDATE_OFFSET + NumUpdates);  
            memcpy(CustArray[UPDATE_OFFSET + NumUpdates].Bookmark,  
               CustArray[RowNum - 1].Bookmark,  
               CustArray[RowNum - 1].BookmarkLen);  
            CustArray[UPDATE_OFFSET + NumUpdates].BookmarkLen =  
               CustArray[RowNum - 1].BookmarkLen;  
            NumUpdates++;  
         } else {  
            printf("Buffers full. Send buffered changes to the data source.");  
         }  
         break;  
      case DELETE_ROW:  
         // Check if we have reached the maximum number of buffered deletes.  
         if (NumDeletes < 10) {  
            // Copy the bookmark of the row being deleted to the next available element  
            // of the buffered deletes section of CustArray and increment the delete  
            // counter. Checking to see we have not already buffered an update for  
            // this row not shown.  
            memcpy(CustArray[DELETE_OFFSET + NumDeletes].Bookmark,  
               CustArray[RowNum - 1].Bookmark,  
               CustArray[RowNum - 1].BookmarkLen);  
  
            CustArray[DELETE_OFFSET + NumDeletes].BookmarkLen =  
               CustArray[RowNum - 1].BookmarkLen;  
  
            NumDeletes++;  
         } else  
            printf("Buffers full. Send buffered changes to the data source.");  
         break;  
  
      case ADD_ROW:  
         // reached maximum number of buffered inserts?  
         if (NumInserts < 10) {  
            // Get the new customer data and place it in the next available element of  
            // the buffered inserts section of CustArray and increment insert counter.  
            // GetNewCustData(CustArray, INSERT_OFFSET + NumInserts);  
            NumInserts++;  
         } else  
            printf("Buffers full. Send buffered changes to the data source.");  
         break;  
  
      case SEND_TO_DATA_SOURCE:  
         // If there are any buffered updates, inserts, or deletes, set the array size  
         // to that number, set the binding offset to use the data in the buffered  
         // update, insert, or delete part of CustArray, and call SQLBulkOperations to  
         // do the updates, inserts, or deletes. Because we will never have more than  
         // 10 updates, inserts, or deletes, we can use the same row status array.  
         if (NumUpdates) {  
            SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)NumUpdates, 0);  
            BindOffset = UPDATE_OFFSET * sizeof(CustStruct);  
            SQLBulkOperations(hstmt, SQL_UPDATE_BY_BOOKMARK);  
            NumUpdates = 0;  
         }  
  
         if (NumInserts) {  
            SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)NumInserts, 0);  
            BindOffset = INSERT_OFFSET * sizeof(CustStruct);  
            SQLBulkOperations(hstmt, SQL_ADD);  
            NumInserts = 0;  
         }  
  
         if (NumDeletes) {  
            SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)NumDeletes, 0);  
            BindOffset = DELETE_OFFSET * sizeof(CustStruct);  
            SQLBulkOperations(hstmt, SQL_DELETE_BY_BOOKMARK);  
            NumDeletes = 0;  
         }  
  
         // If there were any updates, inserts, or deletes, reset the binding offset  
         // and array size to their original values.  
         if (NumUpdates || NumInserts || NumDeletes) {  
            SQLSetStmtAttr(hstmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER)10, 0);  
            BindOffset = 0;  
         }  
         break;  
   }  
   // }  
  
   // Close the cursor.  
   SQLFreeStmt(hstmt, SQL_CLOSE);  
}  

Verwandte Funktionen

Weitere Informationen

ODBC-API-Referenz
ODBC-Headerdateien