Jegyzet
Az oldalhoz való hozzáférés engedélyezést igényel. Próbálhatod be jelentkezni vagy könyvtárat váltani.
Az oldalhoz való hozzáférés engedélyezést igényel. Megpróbálhatod a könyvtár váltását.
Az ODBC lehetővé teszi a kapcsolati és utasítási műveletek aszinkron végrehajtását. Egy alkalmazásszál aszinkron módban meghívhat egy ODBC-függvényt, és a függvény a művelet befejezése előtt visszatérhet, így az alkalmazásszál más feladatokat is végrehajthat. A Windows 7 SDK-ban az aszinkron utasítás vagy kapcsolati műveletek esetében egy alkalmazás megállapította, hogy az aszinkron művelet befejeződött a lekérdezési módszerrel. További információ: Aszinkron végrehajtás (Lekérdezési módszer). A Windows 8 SDK-tól kezdve megállapíthatja, hogy az aszinkron művelet befejeződött-e az értesítési módszerrel.
A lekérdezési módszerben az alkalmazásoknak minden alkalommal meg kell hívniuk az aszinkron függvényt, amikor a művelet állapotát szeretné. Az értesítési módszer hasonló a visszahíváshoz és a várakozáshoz ADO.NET. Az ODBC azonban Win32-eseményeket használ értesítési objektumként.
Az ODBC kurzortár és az ODBC aszinkron értesítése nem használható egyszerre. Ha mindkét attribútumot beállítja, az SQLSTATE S1119 hibát ad vissza (a kurzortár és az aszinkron értesítés egyszerre nem engedélyezhető).
Az illesztőprogram-fejlesztőknek szóló információkért lásd a "Aszinkron függvény befejezésének értesítése" részt.
Jegyzet
A kurzortár nem támogatja az értesítési módszert. Az alkalmazás hibaüzenetet kap, ha az SQLSetConnectAttr használatával próbálja engedélyezni a kurzortárat, ha az értesítési módszer engedélyezve van.
Áttekintés
Ha egy ODBC-függvényt aszinkron módban hívják meg, a rendszer azonnal visszaadja a vezérlést a hívó alkalmazásnak a visszatérési kóddal: SQL_STILL_EXECUTING. Az alkalmazásnak ismételten le kell kérdeznie a függvényt, amíg vissza nem ad valamit, ami nem SQL_STILL_EXECUTING. A lekérdezési ciklus növeli a processzorkihasználtságot, ami számos aszinkron forgatókönyvben gyenge teljesítményt okoz.
Az értesítési modell használata esetén a lekérdezési modell le van tiltva. Az alkalmazások nem hívják meg újra az eredeti függvényt. Hívja meg SQLCompleteAsync függvényt az aszinkron művelet végrehajtásához. Ha egy alkalmazás az aszinkron művelet befejezése előtt ismét meghívja az eredeti függvényt, a hívás SQL_ERROR hibát ad vissza az SQLSTATE IM017 hibakóddal (az érdeklődés aszinkron értesítési módban le van tiltva).
Az értesítési modell használatakor az alkalmazás meghívhatja SQLCancel vagy SQLCancelHandle utasítás vagy kapcsolati művelet megszakításához. Ha a lemondási kérelem sikeres, az ODBC SQL_SUCCESS ad vissza. Ez az üzenet nem jelzi, hogy a funkció ténylegesen megszakadt; azt jelzi, hogy a lemondási kérés feldolgozása megtörtént. Az, hogy a függvény valóban le van-e szakítva, illesztőprogram-függő és adatforrás-függő. Ha egy művelet megszakad, az illesztőprogram-kezelő továbbra is jelzi az eseményt. Az Illesztőprogram-kezelő a visszatérési kód pufferében az SQL_ERROR-t ad vissza, az állapot pedig SQLSTATE HY008 (a művelet megszakítva), ami jelzi, hogy a lemondás sikeres. Ha a függvény befejezte a normál feldolgozást, az Illesztőprogram-kezelő SQL_SUCCESS vagy SQL_SUCCESS_WITH_INFO ad vissza.
Alacsony szintű viselkedés
Az értesítést teljes körűen támogató ODBC Driver Manager-verzió az ODBC 3.81.
| Alkalmazás ODBC-verziója | Illesztőprogram-kezelő verziója | Illesztőprogram verziója | Magatartás |
|---|---|---|---|
| Bármely ODBC-verzió új alkalmazása | ODBC 3.81 | ODBC 3.80-meghajtó | Az alkalmazás akkor használhatja ezt a funkciót, ha az illesztőprogram támogatja ezt a funkciót, ellenkező esetben az Illesztőprogram-kezelő hibát jelez. |
| Bármely ODBC-verzió új alkalmazása | ODBC 3.81 | Pre-ODBC 3.80 illesztőprogram | Az Illesztőprogram-kezelő hibát jelez, ha az illesztőprogram nem támogatja ezt a funkciót. |
| Bármely ODBC-verzió új alkalmazása | ODBC előtti 3.81 | Bármely | Amikor az alkalmazás ezt a funkciót használja, egy régi illesztőprogram-kezelő az új attribútumokat illesztőprogram-specifikus attribútumoknak tekinti, és az illesztőprogramnak hibát kell okoznia. Az új illesztőprogram-kezelő nem adja át ezeket az attribútumokat az illesztőprogramnak. |
A funkció használata előtt egy alkalmazásnak ellenőriznie kell az Illesztőprogram-kezelő verzióját. Ellenkező esetben, ha egy rosszul írt illesztőprogram nem ad hibát, és az Illesztőprogram-kezelő verziója az ODBC 3.81 előtti, a viselkedés meghatározatlan.
Használati esetek
Ez a szakasz az aszinkron végrehajtás és a lekérdezési mechanizmus használati eseteit mutatja be.
Adatok integrálása több ODBC-forrásból
Az adatintegrációs alkalmazások aszinkron módon több adatforrásból kérnek le adatokat. Az adatok egy része távoli adatforrásból származik, egyes adatok pedig helyi fájlokból származnak. Az alkalmazás csak az aszinkron műveletek befejezéséig folytatható.
A művelet ismételt lekérdezése helyett az alkalmazás létrehozhat egy eseményobjektumot, és hozzárendelheti egy ODBC kapcsolati leíróhoz vagy egy ODBC-utasítás leíróhoz. Az alkalmazás ezután meghívja az operációsrendszer-szinkronizálási API-kat, hogy várakozzon egy eseményobjektumon vagy számos eseményobjektumon (odBC-eseményeken és más Windows-eseményeken). Az ODBC jelzi az eseményobjektumot a megfelelő ODBC aszinkron művelet befejezésekor.
Windows rendszeren Win32 eseményobjektumok lesznek használatban, amelyek egységes programozási modellt biztosítanak a felhasználónak. Más platformok illesztőprogram-kezelői az adott platformokra jellemző eseményobjektum-implementációt használhatják.
Az alábbi kódminta a kapcsolat és az utasítás aszinkron értesítésének használatát mutatja be:
// This function opens NUMBER_OPERATIONS connections and executes one query on statement of each connection.
// Asynchronous Notification is used
#define NUMBER_OPERATIONS 5
int AsyncNotificationSample(void)
{
RETCODE rc;
SQLHENV hEnv = NULL;
SQLHDBC arhDbc[NUMBER_OPERATIONS] = {NULL};
SQLHSTMT arhStmt[NUMBER_OPERATIONS] = {NULL};
HANDLE arhDBCEvent[NUMBER_OPERATIONS] = {NULL};
RETCODE arrcDBC[NUMBER_OPERATIONS] = {0};
HANDLE arhSTMTEvent[NUMBER_OPERATIONS] = {NULL};
RETCODE arrcSTMT[NUMBER_OPERATIONS] = {0};
rc = SQLAllocHandle(SQL_HANDLE_ENV, NULL, &hEnv);
if ( !SQL_SUCCEEDED(rc) ) goto Cleanup;
rc = SQLSetEnvAttr(hEnv,
SQL_ATTR_ODBC_VERSION,
(SQLPOINTER) SQL_OV_ODBC3_80,
SQL_IS_INTEGER);
if ( !SQL_SUCCEEDED(rc) ) goto Cleanup;
// Connection operations begin here
// Alloc NUMBER_OPERATIONS connection handles
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
rc = SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &arhDbc[i]);
if ( !SQL_SUCCEEDED(rc) ) goto Cleanup;
}
// Enable DBC Async on all connection handles
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
rc= SQLSetConnectAttr(arhDbc[i], SQL_ATTR_ASYNC_DBC_FUNCTIONS_ENABLE, (SQLPOINTER)SQL_ASYNC_DBC_ENABLE_ON, SQL_IS_INTEGER);
if ( !SQL_SUCCEEDED(rc) ) goto Cleanup;
}
// Application must create event objects
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
arhDBCEvent[i] = CreateEvent(NULL, FALSE, FALSE, NULL); // Auto-reset, initial state is not-signaled
if (!arhDBCEvent[i]) goto Cleanup;
}
// Enable notification on all connection handles
// Event
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
rc= SQLSetConnectAttr(arhDbc[i], SQL_ATTR_ASYNC_DBC_EVENT, arhDBCEvent[i], SQL_IS_POINTER);
if ( !SQL_SUCCEEDED(rc) ) goto Cleanup;
}
// Initiate connect establishing
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
SQLDriverConnect(arhDbc[i], NULL, (SQLTCHAR*)TEXT("Driver={ODBC Driver 11 for SQL Server};SERVER=dp-srv-sql2k;DATABASE=pubs;UID=sa;PWD=XYZ;"), SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT);
}
// Can do some other staff before calling WaitForMultipleObjects
WaitForMultipleObjects(NUMBER_OPERATIONS, arhDBCEvent, TRUE, INFINITE); // Wait All
// Complete connect API calls
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
SQLCompleteAsync(SQL_HANDLE_DBC, arhDbc[i], & arrcDBC[i]);
}
BOOL fFail = FALSE; // Whether some connection opening fails.
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if ( !SQL_SUCCEEDED(arrcDBC[i]) )
fFail = TRUE;
}
// If some SQLDriverConnect() fail, clean up.
if (fFail)
{
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if (SQL_SUCCEEDED(arrcDBC[i]) )
{
SQLDisconnect(arhDbc[i]); // This is also async
}
else
{
SetEvent(arhDBCEvent[i]); // Previous SQLDriverConnect() failed. No need to call SQLDisconnect().
}
}
WaitForMultipleObjects(NUMBER_OPERATIONS, arhDBCEvent, TRUE, INFINITE);
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if (SQL_SUCCEEDED(arrcDBC[i]) )
{
SQLCompleteAsync(SQL_HANDLE_DBC, arhDbc[i], &arrcDBC[i]);; // To Complete
}
}
goto Cleanup;
}
// Statement Operations begin here
// Alloc statement handle
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
rc = SQLAllocHandle(SQL_HANDLE_STMT, arhDbc[i], &arhStmt[i]);
if ( !SQL_SUCCEEDED(rc) ) goto Cleanup;
}
// Enable STMT Async on all statement handles
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
rc = SQLSetStmtAttr(arhStmt[i], SQL_ATTR_ASYNC_ENABLE, (SQLPOINTER)SQL_ASYNC_ENABLE_ON, SQL_IS_INTEGER);
if ( !SQL_SUCCEEDED(rc) ) goto Cleanup;
}
// Create event objects
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
arhSTMTEvent[i] = CreateEvent(NULL, FALSE, FALSE, NULL); // Auto-reset, initial state is not-signaled
if (!arhSTMTEvent[i]) goto Cleanup;
}
// Enable notification on all statement handles
// Event
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
rc= SQLSetStmtAttr(arhStmt[i], SQL_ATTR_ASYNC_STMT_EVENT, arhSTMTEvent[i], SQL_IS_POINTER);
if ( !SQL_SUCCEEDED(rc) ) goto Cleanup;
}
// Initiate SQLExecDirect() calls
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
SQLExecDirect(arhStmt[i], (SQLTCHAR*)TEXT("select au_lname, au_fname from authors"), SQL_NTS);
}
// Can do some other staff before calling WaitForMultipleObjects
WaitForMultipleObjects(NUMBER_OPERATIONS, arhSTMTEvent, TRUE, INFINITE); // Wait All
// Now, call SQLCompleteAsync to complete the operation and get return code
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
SQLCompleteAsync(SQL_HANDLE_STMT, arhStmt[i], &arrcSTMT[i]);
}
// Check return values
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if ( !SQL_SUCCEEDED(arrcSTMT[i]) ) goto Cleanup;
}
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
//Do some binding jobs here, set SQL_ATTR_ROW_ARRAY_SIZE
}
// Now, initiate fetching
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
SQLFetch(arhStmt[i]);
}
// Can do some other staff before calling WaitForMultipleObjects
WaitForMultipleObjects(NUMBER_OPERATIONS, arhSTMTEvent, TRUE, INFINITE);
// Now, to complete the operations and get return code
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
SQLCompleteAsync(SQL_HANDLE_STMT, arhStmt[i], &arrcSTMT[i]);
}
// Check return code
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if ( !SQL_SUCCEEDED(arrcSTMT[i]) ) goto Cleanup;
}
// USE fetched data here!!
Cleanup:
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if (arhStmt[NUMBER_OPERATIONS])
{
SQLFreeHandle(SQL_HANDLE_STMT, arhStmt[i]);
arhStmt[i] = NULL;
}
}
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if (arhSTMTEvent[i])
{
CloseHandle(arhSTMTEvent[i]);
arhSTMTEvent[i] = NULL;
}
}
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if (arhDbc[i])
{
SQLFreeHandle(SQL_HANDLE_DBC, arhDbc[i]);
arhDbc[i] = NULL;
}
}
for (int i=0; i<NUMBER_OPERATIONS; i++)
{
if (arhDBCEvent[i])
{
CloseHandle(arhDBCEvent[i]);
arhDBCEvent[i] = NULL;
}
}
if (hEnv)
{
SQLFreeHandle(SQL_HANDLE_ENV, hEnv);
hEnv = NULL;
}
return 0;
}
Annak meghatározása, hogy egy illesztőprogram támogatja-e az aszinkron értesítést
Az ODBC-alkalmazások az SQLGetInfo meghívásával megállapíthatják, hogy egy ODBC-illesztő támogatja-e az aszinkron értesítéseket. Az ODBC Driver Manager ezért a meghívja az illesztőprogram SQLGetInfo függvényét az SQL_ASYNC_NOTIFICATION argumentummal.
SQLUINTEGER InfoValue;
SQLLEN cbInfoLength;
SQLRETURN retcode;
retcode = SQLGetInfo (hDbc,
SQL_ASYNC_NOTIFICATION,
&InfoValue,
sizeof(InfoValue),
NULL);
if (SQL_SUCCEEDED(retcode))
{
if (SQL_ASYNC_NOTIFICATION_CAPABLE == InfoValue)
{
// The driver supports asynchronous notification
}
else if (SQL_ASYNC_NOTIFICATION_NOT_CAPABLE == InfoValue)
{
// The driver does not support asynchronous notification
}
}
Win32 eseményleíró társítása ODBC-leíróval
Az alkalmazások feladata Win32-eseményobjektumok létrehozása a megfelelő Win32-függvények használatával. Egy alkalmazás egy Win32 eseménykezelőt társíthat egy ODBC kapcsolati leíróhoz vagy egy ODBC-utasításkezelőhöz.
A kapcsolatattribútumok SQL_ATTR_ASYNC_DBC_FUNCTION_ENABLE és SQL_ATTR_ASYNC_DBC_EVENT határozzák meg, hogy az ODBC aszinkron módban fut-e, és hogy az ODBC engedélyezi-e a kapcsolatkezelő értesítési módját. Az utasításattribútumok SQL_ATTR_ASYNC_ENABLE és SQL_ATTR_ASYNC_STMT_EVENT határozzák meg, hogy az ODBC aszinkron módban fut-e, és hogy az ODBC engedélyezi-e az értesítési módot egy utasításkezelőhöz.
| SQL_ATTR_ASYNC_ENABLE vagy SQL_ATTR_ASYNC_DBC_FUNCTION_ENABLE | SQL_ATTR_ASYNC_STMT_EVENT vagy SQL_ATTR_ASYNC_DBC_EVENT | Üzemmód |
|---|---|---|
| Engedélyez | nem nulla | Aszinkron értesítés |
| Engedélyez | null | Aszinkron lekérdezés |
| Letilt | bármely | Egyidejű |
Az alkalmazások ideiglenesen letilthatják az aszinkron üzemmódot. Az ODBC figyelmen kívül hagyja a SQL_ATTR_ASYNC_DBC_EVENT értékeit, ha a kapcsolati szint aszinkron művelete le van tiltva. Az ODBC figyelmen kívül hagyja a SQL_ATTR_ASYNC_STMT_EVENT értékeit, ha az utasításszintű aszinkron művelet le van tiltva.
SQLSetStmtAttr és SQLSetConnectAttr szinkron hívása
SQLSetConnectAttr támogatja az aszinkron műveleteket, de a SQLSetConnectAttr meghívása a SQL_ATTR_ASYNC_DBC_EVENT beállításához mindig szinkron.
SQLSetStmtAttr nem támogatja az aszinkron végrehajtást.
Hibaelhárítási forgatókönyv
Amikor a SQLSetConnectAttr függvényt meghívják a kapcsolat létrehozása előtt, az illesztőprogram-kezelő nem tudja meghatározni, hogy melyik illesztőprogramot használja. Ezért az Illesztőprogram-kezelő az SQLSetConnectAttr
Kapcsolatattribútumok öröklése
A kapcsolat utasításai általában öröklik a kapcsolatattribútumokat. A SQL_ATTR_ASYNC_DBC_EVENT attribútum azonban nem örökölhető, és csak a kapcsolati műveleteket érinti.
Az eseményleíró odbc kapcsolati leíróhoz való társításához egy ODBC-alkalmazás meghívja az ODBC API-t SQLSetConnectAttr, és attribútumként SQL_ATTR_ASYNC_DBC_EVENT, attribútumértékként pedig az eseménykezelőt adja meg. Az új ODBC-attribútum SQL_ATTR_ASYNC_DBC_EVENT SQL_IS_POINTER típusú.
HANDLE hEvent;
hEvent = CreateEvent(
NULL, // default security attributes
FALSE, // auto-reset event
FALSE, // initial state is non-signaled
NULL // no name
);
Az alkalmazások általában automatikusan visszaállítják az eseményobjektumokat. Az ODBC nem állítja alaphelyzetbe az eseményobjektumot. Az alkalmazásoknak meg kell győződniük arról, hogy az objektum nincs jelezve, mielőtt bármilyen aszinkron ODBC-függvényt hívna meg.
SQLRETURN retcode;
retcode = SQLSetConnectAttr ( hDBC,
SQL_ATTR_ASYNC_DBC_EVENT, // Attribute name
(SQLPOINTER) hEvent, // Win32 Event handle
SQL_IS_POINTER); // Length Indicator
Az SQL_ATTR_ASYNC_DBC_EVENT egy olyan attribútum, amelyet csak az Illesztőprogram-kezelő használ, és nem lesz beállítva az illesztőprogramban.
A SQL_ATTR_ASYNC_DBC_EVENT alapértelmezett értéke NULL. Ha az illesztőprogram nem támogatja az aszinkron értesítéseket, a SQL_ATTR_ASYNC_DBC_EVENT lekérése vagy beállítása esetén az SQLSTATE HY092-vel (érvénytelen attribútum/beállításazonosító) SQL_ERROR értéket ad vissza.
Ha az ODBC kapcsolati leíróján beállított utolsó SQL_ATTR_ASYNC_DBC_EVENT érték nem NULL, és az alkalmazás aszinkron üzemmódot engedélyezett az SQL_ATTR_ASYNC_DBC_FUNCTION_ENABLE attribútum SQL_ASYNC_DBC_ENABLE_ON beállításával, az aszinkron módot támogató ODBC kapcsolati függvény meghívása befejező értesítést kap. Ha az ODBC kapcsolati leíróján beállított utolsó SQL_ATTR_ASYNC_DBC_EVENT érték NULL, az ODBC nem küld értesítést az alkalmazásnak, függetlenül attól, hogy engedélyezve van-e az aszinkron mód.
Egy alkalmazás SQL_ATTR_ASYNC_DBC_EVENT állíthat be az attribútum SQL_ATTR_ASYNC_DBC_FUNCTION_ENABLE beállítása előtt vagy után.
Az alkalmazások a kapcsolati függvények (SQLConnect, SQLBrowseConnectvagy SQLDriverConnect) meghívása előtt beállíthatják a SQL_ATTR_ASYNC_DBC_EVENT attribútumot egy ODBC-kapcsolati leírón. Mivel az ODBC Illesztőprogram-kezelő nem tudja, hogy az alkalmazás melyik ODBC-illesztőprogramot fogja használni, SQL_SUCCESS fog visszatérni. Amikor az alkalmazás meghív egy kapcsolati függvényt, az ODBC Illesztőprogram-kezelő ellenőrzi, hogy az illesztőprogram támogatja-e az aszinkron értesítést. Ha az illesztőprogram nem támogatja az aszinkron értesítést, az ODBC-illesztőprogram-kezelő SQL_ERROR-t ad vissza az SQLSTATE S1_118 kóddal (Az illesztőprogram nem támogatja az aszinkron értesítést). Ha az illesztőprogram támogatja az aszinkron értesítést, az ODBC illesztőprogram-kezelője meghívja az illesztőprogramot, és beállítja a megfelelő attribútumokat SQL_ATTR_ASYNC_DBC_NOTIFICATION_CALLBACK és SQL_ATTR_ASYNC_DBC_NOTIFICATION_CONTEXT.
Hasonlóképpen, egy alkalmazás meghívja SQLSetStmtAttr egy ODBC-utasításkezelőn, és megadja a SQL_ATTR_ASYNC_STMT_EVENT attribútumot az utasításszintű aszinkron értesítés engedélyezéséhez vagy letiltásához. Mivel az utasításfüggvények mindig a kapcsolat létrejötte után lesznek meghívva, az SQLSetStmtAttr azonnal visszaad egy SQL_ERROR-t az SQLSTATE S1_118 hibakóddal (az illesztőprogram nem támogatja az aszinkron értesítést), ha a megfelelő illesztőprogram nem támogatja az aszinkron műveleteket, vagy bár támogatja az aszinkron műveleteket, de nem támogatja az értesítést.
SQLRETURN retcode;
retcode = SQLSetStmtAttr ( hSTMT,
SQL_ATTR_ASYNC_STMT_EVENT, // Attribute name
(SQLPOINTER) hEvent, // Win32 Event handle
SQL_IS_POINTER); // length Indicator
SQL_ATTR_ASYNC_STMT_EVENT, amely NULL értékre állítható be, egy csak Illesztőprogram-kezelő attribútum, amely nem lesz beállítva az illesztőprogramban.
A SQL_ATTR_ASYNC_STMT_EVENT alapértelmezett értéke NULL. Ha az illesztőprogram nem támogatja az aszinkron értesítéseket, a SQL_ATTR_ASYNC_STMT_EVENT attribútum lekérése vagy beállítása SQL_ERROR-t SQLSTATE HY092-vel (érvénytelen attribútum- vagy beállításazonosító).
Egy alkalmazás nem társíthat ugyanazt az eseménykezelőt egynél több ODBC-leíróhoz. Ellenkező esetben egy értesítés elveszik, ha két aszinkron ODBC-függvényhívás fejeződik be az ugyanazon eseménykezelővel rendelkező két leírón. Annak elkerülése érdekében, hogy egy utasításkezelő ugyanazt az eseményleírót örökölje a kapcsolati leírótól, az ODBC SQL_ERROR ad vissza SQLSTATE IM016 -tal (Nem állítható be utasításattribútum a kapcsolati leíróba), ha egy alkalmazás SQL_ATTR_ASYNC_STMT_EVENT állít be egy kapcsolati leírón.
Aszinkron ODBC-függvények meghívása
Az aszinkron értesítés engedélyezése és az aszinkron művelet elindítása után az alkalmazás bármilyen ODBC-függvényt meghívhat. Ha a függvény az aszinkron műveletet támogató függvények csoportjába tartozik, az alkalmazás értesítést kap a művelet befejezésekor, függetlenül attól, hogy a függvény sikertelen volt vagy sikeres volt. Az egyetlen kivétel az, hogy az alkalmazás érvénytelen kapcsolat- vagy utasításleíróval meghív egy ODBC-függvényt. Ebben az esetben az ODBC nem fogja lekérni az eseménykezelő fogantyúját, és nem állítja azt a jelzett állapotra.
Az alkalmazásnak meg kell győződnie arról, hogy a társított eseményobjektum nem jelzett állapotban van, mielőtt aszinkron műveletet indít a megfelelő ODBC-leírón. Az ODBC nem állítja alaphelyzetbe az eseményobjektumot.
Értesítés lekérése az ODBC-ből
Az alkalmazás szál meghívhatja a WaitForSingleObject függvényt, hogy várjon egy eseményleírón, vagy meghívhatja a WaitForMultipleObjects függvényt, hogy várakozzon egy eseményleíró tömbön, és fel van függesztve, amíg az eseményobjektumok közül legalább egyet vagy mindegyiket megjelölték, vagy eltelik az időtúllépési időintervallum.
DWORD dwStatus = WaitForSingleObject(
hEvent, // The event associated with the ODBC handle
5000 // timeout is 5000 millisecond
);
If (dwStatus == WAIT_TIMEOUT)
{
// time-out interval elapsed before all the events are signaled.
}
Else
{
// Call the corresponding Asynchronous ODBC API to complete all processing and retrieve the return code.
}