SQLBulkOperations függvény

Megfelelőség
Bemutatott verzió: ODBC 3.0 Szabványoknak megfelelés: ODBC

Summary
Az SQLBulkOperations tömeges behelyezéseket és könyvjelző műveleteket végez, beleértve a frissítést, törlést és könyvjelzővel történő lekérést.

Syntax

  
SQLRETURN SQLBulkOperations(  
     SQLHSTMT       StatementHandle,  
     SQLUSMALLINT   Operation);

Arguments

StatementHandle
[Bemenet] Utasításkezelő.

Művelet
[Bemenet] A végrehajtás művelete:

SQL_ADD SQL_UPDATE_BY_BOOKMARK SQL_DELETE_BY_BOOKMARK SQL_FETCH_BY_BOOKMARK

További információért lásd: "Hozzászólások".

Returns

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

Diagnostics

Amikor az SQLBulkOperations SQL_ERROR vagy SQL_SUCCESS_WITH_INFO értéket ad, egy hozzárendelt SQLSTATE érték elérhető az SQLGetDiagRec hívásával, amely SQL_HANDLE_STMT HandleType és StatementHandle Handle nevű HandleType (Handle) hívja. Az alábbi táblázat felsorolja az SQLBulkOperations által általában visszaadott SQLSTATE értékeket, és mindegyiket elmagyarázza ezen függvény kontextusában; a "(DM)" jelölés megelőzi a Driver Manager által visszaadott SQLSTATE-leírásokat. Az egyes SQLSTATE-értékekhez társított visszatérési kód SQL_ERROR, kivéve, ha másként van feltüntetve.

Minden olyan SQLSTATE-nél, amely SQL_SUCCESS_WITH_INFO vagy SQL_ERROR vissza tud adni (kivéve a 01xxx SQLSTATE-eket), SQL_SUCCESS_WITH_INFO akkor jelenik meg, ha hiba egy vagy több, de nem az összes sorban történik egy többsoros műveletben, és SQL_ERROR akkor jelenik meg, ha hiba egysoros műveletnél is előfordul.

SQLSTATE Hiba Description
01000 Általános figyelmeztetés Illesztőprogram-specifikus tájékoztató üzenet. (A függvény SQL_SUCCESS_WITH_INFO ad vissza.)
01004 String adat jobb vágatának levágása Az Operation argumentum SQL_FETCH_BY_BOOKMARK volt, és egy oszlop vagy oszlopok esetén visszaadott string vagy bináris adat, amelynek adattípusa SQL_C_CHAR vagy SQL_C_BINARY, az nem üres karakter vagy nem NULL bináris adatok lerövidítését eredményezte.
01S01 Hiba a sorban Az Operation argumentum SQL_ADD volt, és hiba történt egy vagy több sorban a művelet végrehajtása közben, de legalább egy sor sikeresen hozzáadásra került. (A függvény SQL_SUCCESS_WITH_INFO ad vissza.)

(Ez a hiba csak akkor jelentkezik, ha egy alkalmazás ODBC 2-vel dolgozik. x driver.)
01S07 Tört csonkolás Az Operation argumentum SQL_FETCH_BY_BOOKMARK volt, az alkalmazás puffer adattípusa nem volt SQL_C_CHAR vagy SQL_C_BINARY, és az egy vagy több oszlop alkalmazáspuffereibe visszaküldött adatokat lerövidítették. (Numerikus C adattípusoknál a szám törtrész részét lerövidítették. Az idő-, időbélyeg- és C intervallum adattípusoknál, amelyek időkomponenst tartalmaznak, az idő töredékrésze lerövidített.)

(A függvény SQL_SUCCESS_WITH_INFO ad vissza.)
07006 Korlátozott adattípus-attribútumok megsértése Az Operation argumentum SQL_FETCH_BY_BOOKMARK volt, és az eredményhalmazban lévő oszlop adatértéke nem volt átalakítható a TargetType argumentus által megadott adattípusra az SQLBindCol hívásában.

Az Operation argumentum SQL_UPDATE_BY_BOOKMARK vagy SQL_ADD volt, és az alkalmazás pufferekben lévő adatértéket nem lehetett átalakítani az eredményhalmaz oszlopának adattípusára.
07009 Érvénytelen descriptor index Az Operation argument SQL_ADD volt, és egy oszlopot olyan oszlopszám kötött, amely nagyobb az eredményhalmaz oszlopainak számánál.
21S02 A származtatott tábla mértéke nem egyezik az oszloplistával Az Operation érv SQL_UPDATE_BY_BOOKMARK volt; és egyetlen oszlop sem volt frissíthető, mert minden oszlop vagy kötetlen, vagy csak olvasható, vagy a kötött hosszúság/mutató puffer értéke SQL_COLUMN_IGNORE.
22001 String adat jobb vágatának levágása Egy karakter vagy bináris érték hozzárendelése az eredményhalmaz egyik oszlopához eredményezte a nem üres (karakterek esetén) vagy nem null (bináris esetén) karakterek vagy bájtok lerövidítését eredményezte.
22003 Numerikus érték a tartományon kívül Az Operáció érvelés SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK volt, és ha egy numerikus értéket rendeltek az eredményhalmaz egyik oszlopához, az egész (nem törtrész) rész lerövidítéséhez vezetett.

Az Operation érvelés SQL_FETCH_BY_BOOKMARK volt, és egy vagy több kötött oszlop numerikus értékének visszaküldése jelentős számjegyek elvesztését okozta.
22007 Érvénytelen dátum/idő formátum Az Műveleti érv SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK volt, és ha egy dátum- vagy időbélyegértéket rendeltek az eredményhalmaz egyik oszlopához, az év, hónap vagy nap mező nem volt a hatótávolságon.

Az Operation érvelés SQL_FETCH_BY_BOOKMARK volt, és egy vagy több kötött oszlop időpont- vagy időbélyegértékének visszaadása az év, hónap vagy nap mező hatótávolságon kívül maradt.
22008 Dátum/idő mező túlcsordulása Az Operáció érvelés SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK volt, és az adott idő aritmetika teljesítménye az eredményhalmaz oszlopához küldött adatokon azt eredményezte, hogy az eredmény egy dátumidőmező (az év, hónap, nap, óra, perc vagy második mező) kívül esett a mező megengedett értéktartományán, vagy érvénytelen volt a gergely-naptár természetes dátum-szabályok alapján.

Az Operáció érve SQL_FETCH_BY_BOOKMARK volt, és az eredményhalmazból származó adatokon a datetime aritmetika teljesítménye miatt egy dátumidő mező (év, hónap, nap, óra, perc vagy második mező) született, amely az eredmény kívül esett a mező megengedett értéktartományán, vagy érvénytelenné vált a Gergely-naptár természetes dátumidő-szabályai alapján.
22015 Intervallummező túlcsordult Az Operation argumentum SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK volt, és egy pontos numerikus vagy intervallum C típus hozzárendelése egy intervallum SQL adattípushoz jelentős számjegyek elvesztését okozta.

Az Operation érv SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK volt; amikor egy intervallum SQL típushoz rendeltek, nem volt ábrázolva a C típus értéke az intervallum SQL típusban.

Az Operation argumentum SQL_FETCH_BY_BOOKMARK volt, és egy pontos numerikus vagy intervallum SQL típus C intervallum típushoz való hozzárendelés jelentős számjegyek elvesztését okozta az első mezőben.

Az Operation érv SQL_FETCH_BY_BOOKMARK volt; C intervallum típushoz való hozzárendeléskor nem volt az SQL típus értékének ábrázolása a C intervallum típusban.
22018 Érvénytelen karakterérték az öntött specifikációhoz Az Operation érv SQL_FETCH_BY_BOOKMARK volt; a C típus pontos vagy közelítő numerikus, dátumidő, vagy intervallum adattípus volt; az oszlop SQL típusa karakteradattípus volt; és az oszlopban lévő érték nem volt érvényes literális a kötött C típusból.

Az érv, hogy az Operation SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK volt; az SQL típus pontos vagy közelítő numerikus, dátumidő, illetve intervallum adattípus volt; a C típus SQL_C_CHAR; és az oszlopban lévő érték nem volt a kötött SQL típus érvényes literálisa.
23000 Integritási kényszer megsértése Az Operation érv SQL_ADD, SQL_DELETE_BY_BOOKMARK vagy SQL_UPDATE_BY_BOOKMARK volt, és megsértették az integritási korlátot.

Az Operation argumentum SQL_ADD volt, és egy nem kötött oszlopot NOT NULL-nak definiálnak, és nincs alapértelmezettje.

Az Operation argumentum SQL_ADD volt, a bound StrLen_or_IndPtr pufferben megadott hossz SQL_COLUMN_IGNORE volt, és az oszlopnak nem volt alapértelmezett értéke.
24000 Érvénytelen kurzorállapot A StatementHandle végrehajtott állapotban volt, de nem volt hozzá semmilyen eredményhalmaz.
40001 Szerializálási hiba A tranzakció egy erőforrás holtpontja miatt lett visszaállítva egy másik tranzakcióval.
40003 Az utasítás befejezése ismeretlen A társított kapcsolat a függvény végrehajtása során meghiúsult, és a tranzakció állapota nem határozható meg.
42000 Szintaxishiba vagy hozzáférés-megsértés Az illesztőprogram nem tudta a sort a szükséges sort az Operation argumentumban kért művelet végrehajtásához szükségessé.
44000 A CHECK OPTION megsértése Az Operation argumentum SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK volt, és a beillesztés vagy frissítés egy megtekintett táblán (vagy a megtekintett táblából származtatott táblán) történt, amelyet WITH CHECK OPTION (WITH CHECK OPTION) jelöléssel hoztak létre, így az egy vagy több sor érintett, amelyeket a beillesztés vagy frissítés érintett, már nem szerepel a megtekintett táblában.
HY000 Általános hiba Hiba történt, amely miatt nem volt konkrét SQLSTATE, és amelyhez nem definiáltak implementációspecifikus SQLSTATE-t. Az SQLGetDiagRec által a *MessageText pufferben visszaadott hibaüzenet leírja a hibát és annak okát.
HY001 Memóriafoglalási hiba Az illesztőprogram nem tudta lefoglalni a függvény végrehajtásának vagy befejezésének támogatásához szükséges memóriát.
HY008 A műveletet megszakították Az aszinkron feldolgozás engedélyezve lett a StatementHandle-ben. A függvény meghívása megtörtént, és a végrehajtás befejezése előtt az SQLCancel vagy az SQLCancelHandle meghívása megtörtént az Utasításkezelőben. Ezután a függvény ismét meghívásra került az Utasításkezelőben.

A függvény meghívása megtörtént, és a végrehajtás befejezése előtt az SQLCancel vagy az SQLCancelHandle egy másik szálról lett meghívva a StatementHandle-ra egy többszálas alkalmazásból.
HY010 Függvényütemezési hiba (DM) A StatementHandle-hez társított kapcsolati leíróhoz aszinkron módon végrehajtó függvény lett meghívva. Ez az aszinkron függvény még mindig futott, amikor az SQLBulkOperations függvényt hívták.

(DM) SQLExecute, SQLExecDirect vagy SQLMoreResults lett meghívva az Utasításkezelőhöz , és SQL_PARAM_DATA_AVAILABLE ad vissza. Ez a függvény az összes streamelt paraméter adatainak lekérése előtt lett meghívva.

(DM) A megadott StatementHandle nem volt végrehajtott állapotban. A függvényt anélkül hívták, hogy előbb az SQLExecDirect, SQLExecute vagy katalógus függvény hívták volna meg.

(DM) Egy aszinkron módon végrehajtó függvény (nem ez) lett meghívva az StatementHandle-hez , és a függvény meghívásakor továbbra is végrehajtó volt.

(DM) Az SQLExecute, SQLExecDirect vagy SQLSetPos meghívása a StatementHandle számára, és SQL_NEED_DATA visszaadta. Ezt a függvényt az összes adatvégrehajtási paraméter vagy oszlop adatküldése előtt hívták meg.

(DM) A sofőr egy ODBC 2 volt. x driver, és SQLBulkOperations egy StatementHandle miatt volt meghívva, mielőtt az SQLFetchScroll vagy SQLFetch lett volna elő.

(DM) Az SQLBulkOperations-t az SQLExtendedFetch meghívása után hívták meg a StatementHandle-en.
HY011 Az attribútumot most nem lehet beállítani (DM) A sofőr egy ODBC 2 volt. x illesztőprogramot használt, és az SQL_ATTR_ROW_STATUS_PTR utasítás attribútumot az SQLFetch, SQLFetchScroll és SQLBulkOperations hívásai között állították be.
HY013 Memóriakezelési hiba A függvényhívás nem dolgozható fel, mert a mögöttes memóriaobjektumok nem érhetők el, esetleg a memóriahiány miatt.
HY090 Érvénytelen sztring vagy puffer hossza Az Operation érv SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK volt; egy adatérték nem volt null mutató; a C adattípus SQL_C_BINARY vagy SQL_C_CHAR volt; és az oszlophossz értéke kevesebb volt, mint 0, de nem egyenlő SQL_DATA_AT_EXEC, SQL_COLUMN_IGNORE, SQL_NTS vagy SQL_NULL_DATA, vagy kevesebb vagy egyenlő SQL_LEN_DATA_AT_EXEC_OFFSET-vel.

A hossz/indikátor pufferben az érték SQL_DATA_AT_EXEC volt; az SQL típus SQL_LONGVARCHAR, SQL_LONGVARBINARY vagy egy hosszú, adatforrás-specifikus adattípus volt; és az SQLGetInfo SQL_NEED_LONG_DATA_LEN információs típusa "Y" volt.

Az Operation argument SQL_ADD volt, az SQL_ATTR_USE_BOOKMARK állítás attribútumát SQL_UB_VARIABLE-re állították, és a 0. oszlop egy olyan pufferhez volt kötve, amelynek hossza nem volt megegyezve ennek az eredményhalmaznak a könyvjelző maximális hosszával. (Ez a hossz elérhető az IRD SQL_DESC_OCTET_LENGTH mezőjében, és SQLDescribeCol, SQLColAttribute vagy SQLGetDescField hívásával érhető el.)
HY092 Érvénytelen attribútumazonosító (DM) Az Operation argumentumhoz megadott érték érvénytelen volt.

Az Operation érv SQL_ADD, SQL_UPDATE_BY_BOOKMARK vagy SQL_DELETE_BY_BOOKMARK volt, és a SQL_ATTR_CONCURRENCY állítás attribútuma SQL_CONCUR_READ_ONLY-re volt beállítva.

Az Operation érv SQL_DELETE_BY_BOOKMARK, SQL_FETCH_BY_BOOKMARK vagy SQL_UPDATE_BY_BOOKMARK volt, és a könyvjelzőoszlop nem volt kötözve, vagy a SQL_ATTR_USE_BOOKMARKS állítás attribútuma SQL_UB_OFF-re volt állítva.
HY117 A kapcsolat ismeretlen tranzakciós állapot miatt fel van függesztve. Csak a leválasztási és írásvédett függvények engedélyezettek. (DM) A felfüggesztett állapotról további információt az SQLEndTran függvényben talál.
HYC00 A választható funkció nem implementálva Az illesztőprogram vagy adatforrás nem támogatja az Operation argumentumban kért műveletet.
HYT00 Időtúllépés történt A lekérdezés időtúllépési időtartama lejárt, mielőtt az adatforrás visszaadta az eredményhalmazt. Az idő-out időszakot SQLSetStmtAttr segítségével állítják be SQL_ATTR_QUERY_TIMEOUT attribútumargumentummal .
HYT01 A kapcsolati időkorlát lejárt A kapcsolat időtúllépési időtartama lejárt, mielőtt az adatforrás válaszolt a kérésre. A kapcsolat időtúllépési időszaka az SQLSetConnectAttr SQL_ATTR_CONNECTION_TIMEOUT keresztül van beállítva.
IM001 Az illesztőprogram nem támogatja ezt a függvényt (DM) Az StatementHandle-hez társított illesztőprogram nem támogatja a függvényt.
IM017 A lekérdezés aszinkron értesítési módban le van tiltva Az értesítési modell használata esetén a lekérdezés le van tiltva.
IM018 Az SQLCompleteAsync nem lett meghívva az előző aszinkron művelet végrehajtásához ezen a leírón. Ha a leíró előző függvényhívása SQL_STILL_EXECUTING ad vissza, és ha az értesítési mód engedélyezve van, az SQLCompleteAsync-et a leírón kell meghívni a művelet utófeldolgozásához és befejezéséhez.

Comments

Caution

Információért arról, hogy az SQLBulkOperations milyen állításokat nevezhet, és mit kell tennie az ODBC 2-vel való kompatibilitás érdekében. x alkalmazások esetén lásd a Blokk kurzorok, görgethető kurzorok és visszafelé kompatibilitás szekciót a G melléklet: Driver Guidelines for Backward Compatibility (Driver Guidelines for Backward Compatibility) részben.

Egy alkalmazás az SQLBulkOperations segítségével végrehajtja a következő műveleteket az aktuális lekérdezésnek megfelelő alaptáblán vagy nézeten:

  • Új sorokat adj hozzá.

  • Frissíts egy sorkészletet, ahol minden sort egy könyvjelző azonosít.

  • Törölj egy sorhalmazt, ahol minden sort könyvjelzővel azonosítják.

  • Hozz egy sorkészletet, ahol minden sort egy könyvjelző azonosít.

Az SQLBulkOperations hívása után a blokk kurzor pozíciója nem lesz meghatározva. Az alkalmazásnak SQLFetchScroll-t kell hívnia a kurzor pozíciójának beállításához. Egy alkalmazásnak csak a FetchOrientation argumentummal kell hívnia SQLFetchScroll-et , amely SQL_FETCH_FIRST, SQL_FETCH_LAST, SQL_FETCH_ABSOLUTE vagy SQL_FETCH_BOOKMARK FetchOrientation argumentumot tartalmaz. A kurzor pozíciója definiálatlan, ha az alkalmazás SQLFetch-et vagy SQLFetchScroll-et hív SQL_FETCH_PRIOR, SQL_FETCH_NEXT vagy SQL_FETCH_RELATIVE FetchOrientation argumentummal.

Egy oszlopot figyelmen kívül lehet hagyni tömeges műveletekben, amelyeket SQLBulkOperations hívással végzünk, ha az SQLBindCol hívásban megadott oszlophossz/indikátor puffert SQL_COLUMN_IGNORE-re állítjuk be.

Nem szükséges az alkalmazásnak beállítania a SQL_ATTR_ROW_OPERATION_PTR utasítás attribútumot, amikor SQLBulkOperations hívja, mert a sorokat nem lehet figyelmen kívül hagyni a nagyobb hajú műveletek során ezzel a funkcióval.

A SQL_ATTR_ROWS_FETCHED_PTR utasítás attribútuma által mutatott puffer tartalmazza, hány sort érint az SQLBulkOperations hívása.

Ha az Operation argumentum SQL_ADD vagy SQL_UPDATE_BY_BOOKMARK, és a kurzorhoz tartozó lekérdezési specifikáció kiválasztási listája több hivatkozást tartalmaz ugyanarra az oszlopra, akkor az illesztőgép határozza meg, hogy hiba keletkezik-e, vagy az illesztőgép figyelmen kívül hagyja a duplikált hivatkozásokat, és végrehajtja a kért műveleteket.

További információért az SQLBulkOperations használatáról lásd: Adatok frissítése SQLBulkOperations segítségével.

Nagy hajú betétek végrehajtása

Az adatok beillesztéséhez SQLBulkOperations segítségével egy alkalmazás a következő lépéssorozatot végzi:

  1. Futtat egy lekérdezést, amely eredményhalmazt ad vissza.

  2. A SQL_ATTR_ROW_ARRAY_SIZE utasítás attribútumát a hozzáadni kívánt sor számára állítja be.

  3. Meghívja az SQLBindCol-t, hogy megkösse azokat az adatokat, amelyeket be szeretne illeszteni. Az adatok egy tömbhöz vannak kötve, amelynek mérete megegyezik a SQL_ATTR_ROW_ARRAY_SIZE értékével.

    Note

    A SQL_ATTR_ROW_STATUS_PTR állítás attribútumával jelölt tömb méretének vagy egyenlőnek kell lennie SQL_ATTR_ROW_ARRAY_SIZE-vel, vagy SQL_ATTR_ROW_STATUS_PTR null mutatónak kell lennie.

  4. Az SQLBulkOperations(StatementHandle, SQL_ADD) belépést indítja a beillesztés végrehajtásához.

  5. Ha az alkalmazás beállította az SQL_ATTR_ROW_STATUS_PTR utasítás attribútumot, akkor ellenőrizheti ezt a tömböt a művelet eredményének megtekintése érdekében.

Ha egy alkalmazás az 0. oszlopot köti meg az SQLBulkOperations hívása előtt SQL_ADD műveleti argumentummal, az illesztőprogram frissíti a kötött oszlop 0 pufferjeit az újonnan beillesztett sor könyvjelző értékeivel. Ehhez az alkalmazásnak be kell állítania a SQL_ATTR_USE_BOOKMARKS utasítás attribútumát SQL_UB_VARIABLE-re a kijelentés végrehajtása előtt. (Ez nem működik ODBC 2-vel. x driver.)

A hosszú adatokat az SQLBulkOperations részekben adhatja hozzá, SQLParamData és SQLPutData hívásokkal. További információért lásd a "Hosszú adatok biztosítása tömeges beillesztésekhez és frissítésekhez" (Hosszú adatok biztosítása tömeges beillesztések és frissítésekhez) oldalon ebben a függvényhivatkozásban.

Nem szükséges az alkalmazásnak SQLFetch-et vagy SQLFetchScroll-t hívnia, mielőtt SQLBulkOperations-t hívna (kivéve, ha ODBC 2-vel szembemenne).x driver; lásd Visszafelé kompatibilitás és szabványoknak megfelelés).

A viselkedés illesztővezető által definiált, ha az SQLBulkOperations-t, amelynek műveleti argumentuma SQL_ADD, egy olyan kurzoron hívjuk, amely duplikált oszlopokat tartalmaz. Az illesztőprogram visszaadhat egy driver-definiált SQLSTATE-et, hozzáadhatja az adatokat az eredményhalmazban megjelenő első oszlopba, vagy más illesztőprogram-definiált viselkedést végezhet.

Tömeges frissítések végrehajtása könyvjelzők használatával

Ahhoz, hogy nagy mennyiségű frissítést hajtson végre könyvjelzők használatával SQLBulkOperations-szal, egy alkalmazás a következő lépéseket végzi egymás után:

  1. A SQL_ATTR_USE_BOOKMARKS állítás attribútumát SQL_UB_VARIABLE-re állítja.

  2. Futtat egy lekérdezést, amely eredményhalmazt ad vissza.

  3. A SQL_ATTR_ROW_ARRAY_SIZE utasítás attribútumát a frissíteni kívánt sor számára állítja be.

  4. Felhívja az SQLBindCol-t , hogy megkösse azokat az adatokat, amelyeket frissíteni szeretné. Az adatok egy tömbhöz vannak kötve, amelynek mérete megegyezik a SQL_ATTR_ROW_ARRAY_SIZE értékével. Az SQLBindCol-t is hívja, hogy megkösse a 0-as oszlopot (a könyvjelző oszlopot).

  5. Lemásolja azokat a sorokat, amelyeket szeretné frissíteni, a 0. oszlophoz kötött tömbbe.

  6. Frissíti az adatokat a kötött pufferekben.

    Note

    A SQL_ATTR_ROW_STATUS_PTR állítás attribútumával jelölt tömb méretének egyenlőnek kell lennie SQL_ATTR_ROW_ARRAY_SIZE-vel, vagy SQL_ATTR_ROW_STATUS_PTR null mutatónak kell lennie.

  7. Meghívja SQLBulkOperations(StatementHandle, SQL_UPDATE_BY_BOOKMARK).

    Note

    Ha az alkalmazás beállította az SQL_ATTR_ROW_STATUS_PTR utasítás attribútumot, akkor ellenőrizheti ezt a tömböt a művelet eredményének megtekintése érdekében.

  8. Opcionálisan hívja az SQLBulkOperations(StatementHandle, SQL_FETCH_BY_BOOKMARK) adatgyűjtést a kötött alkalmazáspufferekbe, hogy ellenőrizze a frissítés megtörtént-e.

  9. Ha az adatokat frissítették, az illesztőprogram megváltoztatja a megfelelő sorok értékét a sorállapot tömbjében SQL_ROW_UPDATED-re.

Az SQLBulkOperations által végzett tömeges frissítések hosszú adatokat is tartalmazhatnak, például az SQLParamData és SQLPutData hívások használatával. További információért lásd a "Hosszú adatok biztosítása tömeges beillesztésekhez és frissítésekhez" (Hosszú adatok biztosítása tömeges beillesztések és frissítésekhez) oldalon ebben a függvényhivatkozásban.

Ha a könyvjelzők megmaradnak a kurzorok között, az alkalmazásnak nem kell SQLFetch-et vagy SQLFetchScroll-et hívnia, mielőtt könyvjelzőkkel frissíteni. Használhat olyan könyvjelzőket, amelyeket egy korábbi kurzorról tárolt. Ha a könyvjelzők nem maradnak fenn a kurzorok között, az alkalmazásnak SQLFetch vagy SQLFetchScroll hívása kell a könyvjelzők visszahívásához.

A viselkedés illesztőgép által definiáltható, ha az SQLBulkOperations, amelynek műveleti argumentuma SQL_UPDATE_BY_BOOKMARK, egy olyan kurzoron hívják, amely duplikált oszlopokat tartalmaz. Az illesztőprogram visszaadhat egy driver-definiált SQLSTATE-et, frissítheti az eredményhalmazban megjelenő első oszlopot, vagy más illesztőprogram-definiált viselkedést végezhet.

Tömeges bevásárlások elvégzése könyvjelzőkkel

Ahhoz, hogy nagy mennyiségben lehívják az SQLBulkOperations könyvjelzők segítségével, egy alkalmazás a következő lépéseket végzi sorrendben:

  1. A SQL_ATTR_USE_BOOKMARKS állítás attribútumát SQL_UB_VARIABLE-re állítja.

  2. Futtat egy lekérdezést, amely eredményhalmazt ad vissza.

  3. A SQL_ATTR_ROW_ARRAY_SIZE utasítás attribútumát a sorok számára állítja be, amelyeket le akar hozni.

  4. Hívja az SQLBindCol-t , hogy megkösse az általa beérkezni kívánt adatokat. Az adatok egy tömbhöz vannak kötve, amelynek mérete megegyezik a SQL_ATTR_ROW_ARRAY_SIZE értékével. Az SQLBindCol-t is hívja, hogy megkösse a 0-as oszlopot (a könyvjelző oszlopot).

  5. Lemásolja azokat a sorokat, amelyeket szeretné behozni a 0-as oszlophoz kötött tömbbe. (Ez feltételezi, hogy az alkalmazás már külön megszerezte a könyvjelzőket.)

    Note

    A SQL_ATTR_ROW_STATUS_PTR állítás attribútumával jelölt tömb méretének egyenlőnek kell lennie SQL_ATTR_ROW_ARRAY_SIZE-vel, vagy SQL_ATTR_ROW_STATUS_PTR null mutatónak kell lennie.

  6. Meghívja SQLBulkOperations(StatementHandle, SQL_FETCH_BY_BOOKMARK).

  7. Ha az alkalmazás beállította az SQL_ATTR_ROW_STATUS_PTR utasítás attribútumot, akkor ellenőrizheti ezt a tömböt a művelet eredményének megtekintése érdekében.

Ha a könyvjelzők megmaradnak a kurzorok között, az alkalmazásnak nem kell SQLFetch-et vagy SQLFetchScroll-et hívnia, mielőtt könyvjelzőkkel hívná. Használhat olyan könyvjelzőket, amelyeket egy korábbi kurzorról tárolt. Ha a könyvjelzők nem maradnak meg a kurzorok között, az alkalmazásnak egyszer meg kell hívnia a SQLFetch-et vagy SQLFetchScroll-t a könyvjelzők megszerzéséhez.

Tömeges törlések végrehajtása könyvjelzőkkel

A tömeges törlések végrehajtásához az SQLBulkOperations könyvjelzőkkel egy alkalmazás a következő lépéseket végzi sorrendben:

  1. A SQL_ATTR_USE_BOOKMARKS állítás attribútumát SQL_UB_VARIABLE-re állítja.

  2. Futtat egy lekérdezést, amely eredményhalmazt ad vissza.

  3. A SQL_ATTR_ROW_ARRAY_SIZE utasítás attribútumát a törlésre kívánó sor számára állítja be.

  4. Meghívja az SQLBindCol-t, hogy a 0-as oszlopot (a könyvjelző oszlopot) kössön.

  5. Lemásolja azokat a sorokat, amelyeket érdekel törölni, a 0-as oszlophoz kötött tömbbe.

    Note

    A SQL_ATTR_ROW_STATUS_PTR állítás attribútumával jelölt tömb méretének egyenlőnek kell lennie SQL_ATTR_ROW_ARRAY_SIZE-vel, vagy SQL_ATTR_ROW_STATUS_PTR null mutatónak kell lennie.

  6. Hívja SQLBulkOperations(StatementHandle, SQL_DELETE_BY_BOOKMARK).

  7. Ha az alkalmazás beállította az SQL_ATTR_ROW_STATUS_PTR utasítás attribútumot, akkor ellenőrizheti ezt a tömböt a művelet eredményének megtekintése érdekében.

Ha a könyvjelzők megmaradnak a kurzorok között, az alkalmazásnak nem kell SQLFetch-et vagy SQLFetchScroll-et hívnia, mielőtt könyvjelzőkkel törölné. Használhat olyan könyvjelzőket, amelyeket egy korábbi kurzorról tárolt. Ha a könyvjelzők nem maradnak meg a kurzorok között, az alkalmazásnak egyszer meg kell hívnia a SQLFetch-et vagy SQLFetchScroll-t a könyvjelzők megszerzéséhez.

Hosszú adat biztosítása tömeges beillesztésekhez és frissítésekhez

Hosszú adatok szolgálhatók tömeges beillesztésekhez és frissítésekhez, amelyeket az SQLBulkOperations hívásai végeznek. A hosszú adatok beillesztéséhez vagy frissítéséhez egy alkalmazás a következő lépéseket végzi, a korábban említett "Nagy mennyiségű beszúrás végrehajtása" és "Nagy mennyiségű frissítés könyvjelzők segítségével" szakaszokban leírt lépéseken kívül.

  1. Amikor az adatokat SQLBindCol segítségével köti meg, az alkalmazás egy alkalmazás-definiált értéket, például az oszlopszámot, helyez el a *TargetValuePtr pufferbe az adat-végrehajtásnál lévő oszlopokhoz. Az érték később felhasználható az oszlop azonosítására.

    Az alkalmazás a SQL_LEN_DATA_AT_EXEC(hosszúság) makró eredményét a *StrLen_or_IndPtr pufferbe helyezi. Ha az oszlop SQL adattípusa SQL_LONGVARBINARY, SQL_LONGVARCHAR vagy egy hosszú adatforrás-specifikus adattípus, és az illezser "Y"-t ad vissza az SQLGetInfo-ban a SQL_NEED_LONG_DATA_LEN információtípusra, akkor a hossz a paraméterhez küldendő bájtok száma; egyébként nem negatív értéknek kell lennie, és figyelmen kívül hagyják.

  2. Amikor az SQLBulkOperations hívást alkalmazzuk, ha adat-végrehajtáskor oszlopok vannak, a függvény SQL_NEED_DATA visszatér, és továbblép a következő 3. lépéshez. (Ha nincsenek adat-végrehajtáskor oszlopok, a folyamat befejezett.)

  3. Az alkalmazás az SQLParamData hívását hívja, hogy lekérje az *TargetValuePtr puffer címét az első feldolgozáskor feldolgozandó adat-végrehajtási oszlophoz. SQLParamData SQL_NEED_DATA visszaad. Az alkalmazás a *TargetValuePtr pufferből kéri az alkalmazás által definiált értéket.

    Note

    Bár az adat-végrehajtásnál paraméterek hasonlítanak az adat-végrehajtási oszlopokra, az SQLParamData által visszaadott érték mindegyiknél eltérő.

    Az adat-végrehajtási oszlopok olyan oszlopok egy sorhalmazban, amelyekhez az adatokat SQLPutData segítségével küldik, amikor egy sort frissítenek vagy beillesztenek SQLBulkOperations-szal. Kötöttek az SQLBindCol-hoz. Az SQLParamData által visszaadott érték a *TargetValuePtr pufferben feldolgozott sor címe.

  4. Az alkalmazás egyszer vagy többször hívja az SQLPutData-t , hogy adatokat küldjön az oszlophoz. Ha az SQLPutDataáltal megadott *TargetValuePtr pufferben, az összes adatérték nem tér vissza egynél több hívásra; ugyanazon oszlophoz több hívás az SQLPutData-ra csak akkor engedélyezett, ha C karakter adatot küldenek egy oszlopba, ahol karakter, bináris vagy adatforrás-specifikus adattípus van, vagy ha bináris C adatot küldünk egy karakter-, bináris vagy adatforrás-specifikus adattípusú oszlopba.

  5. Az alkalmazás ismét az SQLParamData-t hívja, hogy jelezze, minden adatot elküldtek az oszlophoz.

    • Ha több adat-végrehajtásnál lévő oszlop van, az SQLParamData SQL_NEED_DATA-ot és a következő adat-végrehajtási adat-futtatási oszlop TargetValuePtr pufferének címét adja vissza. A kérelem megismétli a 4. és 5. lépést.

    • Ha nincs több adat-végrehajtásnál oszlop, a folyamat befejezett. Ha az utasítást sikeresen végrehajtották, az SQLParamData SQL_SUCCESS vagy SQL_SUCCESS_WITH_INFO értéket ad vissza; ha a végrehajtás sikertelen volt, SQL_ERROR visszaad. Ezen a ponton az SQLParamData bármilyen SQL-állapotot visszaadhat, amelyet az SQLBulkOperations vissza tud adni.

Ha a műveletet töröljük, vagy hiba jelentkezik az SQLParamData vagy SQLPutDataSQL_NEED_DATA után , és mielőtt az összes adat-végrehajtásnál lévő oszlop adatát küldik, az alkalmazás csak az utasításhoz vagy az állításhoz kapcsolódó kapcsolathoz csak SQLCancel, SQLGetDiagField, SQLGetDiagRec, SQLGetFunctions, SQLParamData vagy SQLPutData fájlokat hívhatja. Ha bármilyen más függvényt hív az állításhoz vagy az ahhoz kapcsolódó kapcsolathoz, a függvény SQL_ERROR és SQLSTATE HY010-et (Függvénysorozat hiba) ad.

Ha az alkalmazás SQLCancel-t hív, miközben az illezőprogramnak még adatra van szüksége adat-végrehajtáskor lévő oszlopokhoz, az illesztőprogram megszünteti a műveletet. Az alkalmazás ezután ismét hívhatja az SQLBulkOperations-t ; A törlés nem befolyásolja a kurzor állapotát vagy a jelenlegi kurzor pozícióját.

Sorállapot mezők tömbje

A sor státusz tömb tartalmazza az egyes adatsorok állapotértékeit a sorhalmazban az SQLBulkOperations hívása után. Az illezser a tömbben lévő státuszértékeket a SQLFetch, SQLFetchScroll, SQLSetPos vagy SQLBulkOperations hívása után állítja be. Ezt a tömböt kezdetben SQLBulkOperations hívással töltik fel, ha a SQLFetch vagy SQLFetchScroll nem volt meghívva az SQLBulkOperations előtt. Ezt a tömböt a SQL_ATTR_ROW_STATUS_PTR állítás attribútuma mutatja be. A sorállapot tömbökben lévő elemek számának egyenlőnek kell lennie a sorhalmazban lévő sorok számával (ahogy az SQL_ATTR_ROW_ARRAY_SIZE állítás attribútuma definiál). Erről a sorállapot tömbről információért lásd: SQLFetch.

Kódpélda

Az alábbi példa egyszerre 10 sor adatot hoz az Ügyfelek táblából. Ezután a felhasználótól cselekvésre kér egy lépést. A hálózati forgalom csökkentése érdekében a példa puffer helyben frissíti, törli és beilleszti a határolt tömbökben, de a sorhalmaz adatain túli eltolásokkal. Amikor a felhasználó úgy dönt, hogy frissítéseket, törléseket és beillesztéseket küld az adatforrásba, a kód megfelelően állítja be a kötési eloszlást, és meghívja az SQLBulkOperations funkciót. Az egyszerűség érdekében a felhasználó nem tud több frissítést, törlést vagy beillesztést pufferelni.

// 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);  
}
Információ erről: Nézze
Puffer kötése egy eredményhalmaz oszlopához SQLBindCol függvény
Utasításfeldolgozás megszakítása SQLCancel függvény
Adatblokk beolvasása vagy egy eredményhalmaz görgetése SQLFetchScroll függvény
Egyetlen mező megszerzése egy leíró SQLGetDescField függvény
Több mező megszerzése egy leíróból SQLGetDescRec Function
Egyetlen mező beállítása egy leíró SQLSetDescField függvény
Több mező beállítása egy leíró SQLSetDescRec Function
A kurzor pozicionálása, az adatok frissítése a sorhalmazban, vagy adatok frissítése vagy törlése a sorhalmazban SQLSetPos függvény
Utasításattribútum beállítása SQLSetStmtAttr függvény

Kapcsolódó tartalom

  • Last updated on