Delphi - TIBQuery komponens

Interbase 6. rész

forráskód letöltése
A sorozat most következő részében megismerkedünk a TIBQuery komponens használatával. Megnézzük a legfontosabb tulajdonságokat, metódusokat és eseményeket, és külön megvizsgáljuk a komponens SQL nyelvvel való kapcsolatát. Olvashatunk még a lekérdezésekről és beépítjük példaprogramunkba a komponenst.
Egyik legfontosabb szerepe, hogy lehetővé teszi SQL utasítások végrehajtását.
Először vizsgáljuk meg azt, hogy mi a különbség Table és egy Query komponens között. Ha első ránézésre végigfutunk a tulajdonságaikon, eseményeiken és metódusaikon azt tapasztalhatjuk, hogy igen sok megtalálható mindkét komponensnél nagyjából hasonló paraméterekkel. A két komponens közötti különbség az alkalmazás futása során jön elő:
  • A Table komponenst nem célszerű nagy táblákhoz használni, de tökéletesen megfelel egy kis keresőtáblához. Ha megnyitunk egy Table komponenst, akkor nem az egész tartalom kerül át a helyi gépre, csak akkor mozognak az adatok, amikor bizonyos rekordokat érünk el.
  • A Table komponensnél először a tábla szerkezetét kérdezzük le a kiszolgálótól, és csak azután az adatokat, a Query komponens esetében erre nincsen szükség.
  • Figyelembe kell vennünk, hogy egy egyszerű lekérdezés eredményét általában módosíthatjuk is, majd az adatokat visszaküldhetjük a kiszolgálónak. Ilyen esetekben az UpdateSQL komponenst használjuk.
  • Ha az ügyfél és a kiszolgáló között a forgalmat csökkenteni szeretnénk, a rekordok méretét ugyanúgy figyelembe kell venni, mint a számukat. Ha csak néhány mezőt választunk ki egy lekérdezésben, az azt jelenti, hogy csak ezekre az információkra van szükségünk. A Table komponens esetében viszont az egész rekord letöltődik az ügyfélhez, függetlenül attól, hogy a mezőszerkesztőben hány mezőt választottunk ki.
  • A Query komponens nem korlátozódik a SELECT SQL utasításokra, ha egy műveletet szeretnénk végrehajtani a kiszolgálón, ezt az ExecSQL metódus meghívásával tehetjük meg.
A TIBQuery komponens használata
  • Helyezzünk egy komponenst a Form-ra.
  • Állítsuk be a Database tulajdonságot egy TIBDatabase komponens segítségével.
  • Állítsuk be a Transaction tulajdonságot egy TIBTransaction komponens használatával.
  • Írjuk be a kívánt SQL utasítást a komponens SQL tulajdonságába. A paramétereket állítsuk be a Params tulajdonság használatával.
  • Ha a komponens valamilyen SELECT utasítást használt, akkor a lekérdezés eredményét egy adatmegjelenítő komponens segítségével böngészhetjük.
  • Nyissuk meg a komponenst. Ha a lekérdezés egy eredményhalmazt szolgáltat, akkor az Active tulajdonságot vagy az Open metódust használjuk. Az olyan lekérdezések, amelyek csak egy műveletet hajtanak végre egy táblán, de nem adnak vissza eredményt, az ExecSQL metódussal futtathatjuk.
A Delphi Enterprise változat mellé megkapjuk az SQL Builder segédprogramot, amely nagyon könnyűvé teszi még a bonyolultabb utasítások összeállítását is.
A paraméterek beállítását egy szerkesztőablak segíti, ha kétszer kattintunk a Params tulajdonságon. A megadott SQL utasításokat tesztelhetjük is, ha a komponensre jobb egérgombbal kattintunk, és a megjelenő helyi menüből kiválasztjuk az Execute menüpontot.

Futási időben a következőket tegyük:
  • Zárjuk be a komponenst (Close metódus vagy Active := False).
  • Töröljük az SQL tulajdonság értékét (IBQuery1.SQL.Clear), majd adjuk meg a szükséges SQL utasításokat. Használjuk az SQL.Add metódust.
  • Ha a lekérdezés paramétereket is tartalmaz, adjuk meg ezeket a ParamByName metódus használatával.
  • Hívjuk meg a Prepare eljárást. Ennek hatására a kiszolgáló megkapja a lekérdezést, ellenőrzi az utasításformát, és felméri, hogyan tudná használni az indexeket és egyéb módszereket. Ha később a lekérdezést többször futtatjuk le, gyorsabb lesz, mert ez az előkészítés már megtörtént. Ha változik a lekérdezés szövege, adata akkor természetesen újra futtatni kell a Prepare metódust. Azt, hogy egy lekérdezés elő van-e készítve, a Prepared logikai típusú tulajdonság segítségével vizsgálhatjuk.
  • Hívjuk meg az Open vagy az ExecSQL metódusokat, attól függően, hogy a lekérdezés visszaad-e valamilyen eredményhalmazt vagy sem.
  • Ha nem futtatjuk többet az utasítást, akkor hívjuk meg az UnPrepare metódust, amellyel erőforrásokat szabadíthatunk fel.
Most pár rövid példán keresztül nézzük meg az előbb elmondottakat.
Futási időben történő beállítás:
with IBQuery1 do begin
  Close;  //zárjuk be a lekérdezést, ha aktív volt
  With SQL do begin
     Clear;     //töröljük az SQL tulajdonság jelenlegi értékét, bármi is legyen az
     Add('SELECT * FROM GEPJARMUVEK');             //első sor
     Add('AJTOSZAM = 4');                 //második sor
  End;
  If (Prepared=false) then Prepare;      //ha szükséges, készítsük elő a lekérdezést
  Open;
End;
Ha egy következő lekérdezés során az ötajtós kocsikat keressük, akkor a következőt kell tennünk:
IBQuery1.SQL[1] := 'AJTOSZAM = 5';
Ezen utasítás segítségével felülírtuk az SQL tulajdonság második sorát. Természetesen előbb be kell zárni a lekérdezést, majd újra meg kell nyitni.

Lehetőségünk van arra, hogy az SQL utasítást egy fájlból töltsük be:
IBQuery1.Close;
IBQuery1.SQL.LoadFromFile('c:\ajtosz_query.txt');
IBQuery1.Open;
Természetesen bármilyen fájlt megadhatunk - akármilyen kiterjesztéssel - amelyikben értelmezhető SQL utasítások vannak.

Megoldható az is, hogy a felhasználó futási időben adja meg az SQL utasításokat egy memo komponensben, és ezt rendeljük a lekérdezéshez.
IBQuery1.Close;
IBQuery1.SQL.Assign(Memo1.Lines);
IBQuery1.Open.
Paraméterek megadása

Az SQL utasítás paramétereit háromféleképpen is megadhatjuk.
Legyen adott a következő SQL utasítás:
INSERT INTO TABLA (ADAT1, ADAT2, ADAT3, ADAT4) 
VALUES (:ADAT1, :ADAT2, :ADAT3,:ADAT4);
A következő módokon állíthatjuk be a paraméterek értékeit:
1. A ParamByName metódus használatával:
IBQuery1.ParamByName('ADAT1').AsString := Edit1.Text; IBQuery1.ParamByName('ADAT2').AsString :=
    Edit2.Text; IBQuery1.ParamByName('ADAT3').AsString := Edit3.Text; IBQuery1.ParamByName('ADAT4').AsString
        := Edit4.Text;.
2. A Params tulajdonság használatával:
IBQuery1.Params[0].AsString := Edit1.Text;
IBQuery1.Params[1].AsString := Edit2.Text;
IBQuery1.Params[2].AsString := Edit3.Text;
IBQuery1.Params[3].AsString := Edit4.Text;.
3. Végül a Params.ParamValues tulajdonságot használhatjuk:
IBQuery1.Params.ParamValues['ADAT1;ADAT2;ADAT3;ADAT4'] := VarArrayOf([Edit1.Text, Edit2.Text, Edit3
   .Text, Edit4.Text]);.

A DataSource tulajdonság felhasználása

Csak a paraméteres lekérdezések esetén van értelme. Ha a paraméter értéke egy adatforrás valamely mezőjéből származik (és nem a felhasználó gépeli be azt), akkor a paraméterérték(ek) megadására használhatjuk a TIBQuery komponens DataSource tulajdonságát. Ezt arra az adatforrásra kell irányítanunk, amelyikből a paraméter értéke származik. A lekérdezés lefuttatásakor a rendszer kiértékeli, hogy be van-e állítva a DataSource jellemzője, és ha igen, akkor az ott beállított adatforrásban keres egy - a paraméter nevével megegyező nevű - mezőt. Ennek a mezőnek aktuális rekordbeli értéke kerül a lekérdezésbe paraméterértékként. Később, amikor az aktuális rekord megváltozik, tehát a megfelelő mező értéke is más lesz, a rendszer automatikusan frissíti a lekérdezést, újrafuttatja az új paraméterértékkel.

Amíg nem ismerkedünk meg az UpdateSQL komponenssel, addig az IBQuery komponensen alapuló táblákat csak nézegetni tudjuk.

A komponens és a SQL nyelv kapcsolata

A TIBQuery komponens előnye, hogy gyakorlatilag bármilyen típusú SQL utasítást futtathatunk a segítségével. Általában az adatok módosítására, beszúrására, törlésére használjuk, de létrehozhatunk segítségével adatbázisokat, táblákat, indexeket, generátorokat, tárolt eljárásokat, táblák szerkezetét módosíthatjuk, táblákat törölhetünk és kezelhetjük a felhasználói jogosultságokat is. A komponens másik nagyobb alkalmazási területe tárolt eljárások meghívása, amikor az eljárás egy eredményhalmazzal tér vissza. Ilyenkor nem használható a TIBStoredProc komponens. Ez utóbbi esetet a sorozat következő részében tárgyaljuk.

A lekérdezések

Általában tehát a komponenst lekérdezések futtatására használjuk. Ilyenkor működése nagyon hasonlít a Table komponens működéséhez. Ezért most nézzük meg, hogyan készíthetünk különböző lekérdezéseket.

Az SQL adatkezelő nyelvét sokkal gyakrabban használjuk. Négy fő parancs létezik: SELECT, INSERT, UPDATE, DELETE. Mindegyik elérhető az IBQuery komponens használatával, de csak a SELECT ad vissza eredményhalmazt. Így ezt az Open metódussal vagy az Active tulajdonsággal használjuk, míg a többit az ExecSQL paranccsal hajtjuk végre.

SELECT

Segítségével egy adatbázis tábláiból, nézeteiből gyűjthetjük össze adatainkat. A parancs alakja:
SELECT <mezők> from <táblanév>
A <mezők> részben adhatjuk meg a tábla egy vagy több mezőjét, vesszőkkel elválasztva. Ha a * jelet használjuk, akkor a tábla összes oszlopát kiválasztjuk.
SELECT (VEZ_NEV || '' '' || KER_NEV) AS TELJESNEV, 
UPPER(SZUL-HELY) FROM TULAJDONOSOK
Ebben a példában az UPPER kiszolgálói függvény, amely minden karaktert nagybetűssé alakít, a két vonal ( | | ) pedig a karakterláncokat összefűző műveleti jel. Az AS kulcsszó új nevet ad az egész kifejezésnek, amely a vezeték- és keresztneveket tartalmazza.
A WHERE záradék hozzáadásával azt adhatjuk meg, hogy mely rekordokra van szükségünk, és azt is, hogy mely mezők érdekelnek minket:
SELECT * FROM TULAJDONOSOK
WHERE SZUL_HELY = ''MISKOLC''
Ez a parancs azokat a rekordokat adja vissza, ahol a tulajdonos miskolci születésű. A WHERE kulcsszót egy vagy több kiválasztási feltétel követi, amelyeket az AND, OR vagy a NOT logikai operátorokkal kapcsolhatunk össze:
SELECT * FROM TULAJDONOSOK
WHERE VEZ_NEV = ''KIS'' AND SZUL_HELY = ''MISKOLC''
A kiválasztási feltétel tartalmazhat a kiszolgálón elérhető függvényeket és lehetnek benne szabványos műveleti jelek is (+, -, <, >, =, <>, <=, >=), de néhány SQL operátort is használhatunk:
  • Az IS NULL azt vizsgálja, hogy az adott mező üres-e.
  • Az IN <lista> igaz értékkel tér vissza, ha a mező értéke szerepel az operátor után megadott listában.
  • A BETWEEN <min.érték> AND <max.érték> azt vizsgálja, hogy a mező értéke belül van-e az adott tartományon.
SELECT * FROM TULAJDONOSOK
WHERE LEANY_VEZNEV IS NOT NULL AND SZUL_HELY = ''MISKOLC''
Van még egy hasznos operátor a karakterlánc-minták azonosítására: a LIKE. Ha az összes R betűvel kezdődő nevet keressük, az alábbi utasítást használhatjuk:
SELECT * FROM TULAJDONOSOK
WHERE VEZ_NEV LIKE ''R%''
A % jel azt jelenti, hogy a karakterlánc R utáni része bármi lehet. Az összes Y-ra végződő nevet így választhatjuk ki:
SELECT * FROM TULAJDONOSOK
WHERE UPPER(VEZ_NEV LIKE ''%Y'')
Az UPPER függvény alkalmazásával a keresés nem veszi figyelembe a kis- és nagybetűk közötti különbséget. A LIKE mellett hasonló célra a CONTAINING és a STARTING WITH operátorokat is használhatjuk. Ha egy karakterlánc elejének vizsgálatát végezzük, használjuk a STARTING WITH operátort, amely engedélyezi az indexek használatát és sokkal gyorsabb is.
További lehetőség a SELECT által visszaadott rekordok rendezése az ORDER BY záradékkal. Egy vagy több mező szerint is rendezhetünk:
SELECT * FROM TULAJDONOSOK
ORDER BY VEZ_NEV, KER_NEV
Az ASC és a DESC operátorokkal adhatjuk meg, hogy a rendezés növekvő (ASC) vagy csökkenő (DESC) legyen. Alapértelmezett a növekvő sorrend.
Fontos kiegészítés lehet a DISTINCT szó, ezzel elkerülhetjük az ismétlődő rekordokat az eredményhalmazban. Például megnézhetjük az összes várost, ahol a tulajdonosok születtek.

SELECT DISTINCT SZUL_HELY FROM TULAJDONOSOK

A SELECT utasításban használhatunk összesítő függvényeket is.
  • Az AVG az eredményhalmaz megadott oszlopának átlagát számolja ki. (Csak szám típusú mezőknél működik.)
  • A COUNT az eredményhalmaz elemeit számolja meg. (Ez azoknak az elemeknek a száma, amelyek kielégítik a SELECT utasítás feltételeit.)
  • A MAX és a MIN az eredményhalmaz egy oszlopának legnagyobb és legkisebb értékét adja meg.
  • A SUM összeadja az eredményhalmaz egy oszlopának összes értékét. (Csak szám típusú mezőnél működik.)
Ezek a függvények az eredményhalmazra alkalmazhatók. A következő utasítás megmondja, hogy a nyilvántartott kocsiknak átlagosan hány tulajdonosuk van:
SELECT AVG(TUL_SZAMA) FROM GEPJARMUVEK
További fontos záradék a GROUP BY, amellyel elemeket csoportosíthatunk bizonyos feltételek alapján, mielőtt a fenti számításokat végző függvényeket alkalmaznánk rájuk. Ha például azt szeretnénk tudni, hogy gépkocsinként mennyi a legnagyobb és az átlag tulajdonosszám:
SELECT MAX(TUL_SZAMA), AVG(TUL_SZAMA), GYARTMANY
FROM GEPJARMUVEK
GROUP BY GYARTMANY
Nem szabad elfelejteni, hogy az összes nem számolt mezőnek meg kell jelennie a GROUP BY záradékban. A következő utasítás hibás:
SELECT MAX(TUL_SZAMA), AVG(TUL_SZAMA), GYARTMANY, TIPUS FROM GEPJARMUVEK GROUP BY GYARTMANY
Az összesítő függvényeket arra is használhatjuk, hogy meghatározzuk, hogy hány rekord van az eredményhalmazban. A WHERE záradékban nem használhatjuk, de elhelyezhetjük őket a különleges HAVING záradékban. A következő példában kilistázzuk gyártmányonként a legnagyobb tulajdonosszámokat, ha az érték meghaladja a hármat:
SELECT MAX(TUL_SZAMA), GYARTMANY
FROM GEPJARMUVEK
GROUP BY GYARTMANY
HAVING MAX(TUL_SZAMA) > 3
Egy másik érdekes lehetőség a SELECT utasítások egymásba ágyazása. A következő példában keressük a legtöbb tulajdonossal rendelkező kocsi(k) azonosítóját és rendszámát:
SELECT GK_AZONOSITO, RENDSZAM
FROM GEPJARMUVEK
WHERE TUL_SZAMA = (SELECT MAX(TUL_SZAMA)
FROM GEPJARMUVEK)
Ezt egy egyszerű utasítással már nem tudtuk volna megoldani, mert ha a rendszámot és az azonosítót is szeretnénk látni az eredményhalmazban, akkor hozzá kellett volna adnunk azokat a GROUP BY záradékhoz.

Nézzünk igen röviden még néhány lehetőséget.
Eddig csak egy táblán működtek, ez azonban igen gyakran nem elégséges. Ha több táblából kell összeszedni az adatokat, akkor a táblák összekapcsolásáról beszélünk. Az SQL szabvány kétféle összekapcsolódást támogat: a belsőt és a külsőt.
A belső összekapcsolódást a WHERE záradékban adhatjuk meg:
SELECT * FROM <tábla1>, <tábla2>
WHERE <tábla1.mezőX> = <tábla2.mezőY>
A belső összekapcsolódással könnyen megvalósíthatjuk az egy az egyhez kapcsolatot (amikor az első tábla minden rekordjához csak egy rekord tartozik a másik táblából). A szabvány utasításformája a következő, bár mindkét megközelítés ugyanazt az eredményhalmazt adja.
SELECT * FROM <tábla1> LEFT JOIN <tábla2>
ON <tábla1.mezőX> = <tábla2.mezőY>
A külső összekapcsolódást a következő utasítással hozhatjuk létre:
SELECT * FROM <tábla1> LEFT OUTER JOIN <tábla2>
ON <tábla1.mezőX> = <tábla2.mezőY>
A fő különbség a belső és a külső összekapcsolódás között, hogy a külsőnél nem szerepelnek azok a rekordok, amelyekre a második tábla nem tartalmaz értéket.

Vannak más típusú összekapcsolódások is: egy táblát saját magával vagy két táblánál többet is összekapcsolhatunk, vagy előállíthatjuk táblák Descartes-szorzatát is, ahol nincs WHERE záradék, így a táblák minden sora kombinálódik a többi tábla összes sorával, hatalmas eredményhalmazt hozva létre.

INSERT

A parancs segítségével új sorokat adhatunk egy táblához vagy egy frissíthető nézethez.

Ha csak nem adunk minden mezőnek értéket, fel kell sorolni a kezelni kívánt mezőket.
INSERT INTO ESEMENYEK (GEPKOCSI, IDOPONT, KULCSSZO) 
VALUES (1, ''2001.02.02'', ''ADÁS-VÉTEL'')

UPDATE

A parancs segítségével egy tábla sorait módosíthatjuk. A WHERE részben adhatjuk meg, hogy mely rekordokat szeretnénk módosítani. Például megváltoztathatjuk egy kocsi színét az alábbi utasítással:
UPDATE GEPJARMUVEK 
SET SZIN = ''LILA''
WHERE GK_AZONOSITO = 8
Egy ilyen utasítással módosíthatjuk az összes olyan rekordot, amely kielégíti a feltételt. Ha hibásan adjuk meg a WHERE záradékot, akkor sok rekordnál nem kívánt változások léphetnek életbe, és erről figyelmeztető üzenetet sem kapunk.
A SET utasítást több mezőre is alkalmazhatjuk, ezeket vesszővel kell elválasztani, és az új érték kiszámításához használhatjuk a mezők jelenlegi értékét.

DELETE

A DELETE utasítás használata nagyon egyszerű, ám helytelen használata komoly károkat okozhat az adatbázisban.
DELETE FROM GEPJARMUVEK
WHERE GK_AZONOSITO = 65
Ha az utasítást az IBQuery komponens ExecSQL parancsával futtatjuk, akkor a RowsAffected tulajdonságon keresztül megtudhatjuk, hogy a művelet hány sort érintett. Ez igaz az UPDATE parancs használata esetén is.

A komponens legfontosabb tulajdonságai:
  • Active: Megmutatja vagy beállíthatjuk segítségével, hogy a táblánk aktív-e vagy sem.
  • BufferChunks: Beállíthatjuk, hogy a buffer mérete mennyivel nőjön (rekordokban), ha betelik.
  • ChachedUpdates: A gyorsítótáras frissítés engedélyezését határozhatjuk meg. Amikor a tulajdonságot igazra állítjuk, a frissítések (módosítások, törlések, új rekord beszúrása) csak a program gyorsítótárában, a kliens gépen lesz eltárolva. Amikor végeztünk minden módosítással, az alkalmazásunk helyben tárolt módosításokat egyszerre elküldi, egy tranzakció keretében az adatbázishoz.
  • Constraints: A rekordszintű megszorításokat definiálhatjuk itt.
  • DataSource: Beállíthatjuk, hogy mely adatforrás (TDataSource) alapján épüljön fel egy paraméteres lekérdezés.
  • SELECT * FROM ORDERS O WHERE (O.CUSTNO = :CUSTNO)
  • Ez a formula egy olyan eredményhalmazt ad, ahol az ORDERS tábla eredményei a TDataSource komponens által meghatározott adatbázistól függenek a WHERE záradékban megadottak szerint.
  • ParamCheck: Beállíthatjuk, hogy ha futási időben változnak a lekérdezés paraméterei, újra kell-e azokat generálni. Akkor hasznos számunkra ez a tulajdonság, ha DDL utasítást futtatunk. Tárolt eljárások futtatása esetén többnyire hamis értékűre szokták állítani.
  • ParamCount: Az aktuális lekérdezéshez tartozó paraméterek számát adja meg.
  • Params: A lekérdezéshez szükséges paramétereket adhatjuk meg.
  • Prepared: Jelzi, ha a lekérdezés már elő van készítve.
  • RowsAffected: Azon sorok számát határozza meg, amelyeket az UPDATE vagy DELETE utasítások érintettek. Ha nem történt semmi, a visszatérési értéke -1.
  • SQL: A futtatni kívánt SQL utasítást kell a tulajdonság segítségével megadnunk.
  • StatamentType: A lekérdezés típusával tér vissza. Lehetséges értékei: SQLUnknown, SQLSelect, SQLInsert, SQLDelete, SQLUpdate, SQLDDL, SQLGetSegment, SQLPutSegment, SQLExecProcedure, SQLStartTransaction, SQLCommit, SQLRollback, SQLSelectForUpdate, SQLSetGenerator.
  • UniDirectional: Beállíthatjuk, hogy a kétirányú kurzorok engedélyezettek legyenek-e a tábla számára.
  • UpdateObject: Itt egy kapcsolódást adhatunk meg egy TIBUpdateSQL komponens felé, amelyet akkor használ az alkalmazás, ha frissíteni kell az eredményeket. Ezzel a lehetőséggel a 11. részben foglalkozunk részletesebben.
Események:
Nagyon sok, a TQuery komponensnél már megismert tulajdonsággal találkozhatunk. Itt csak az újabbakkal ismerkednénk meg.
  • AfterDatabaseDisconnect: Az esemény akkor aktiválódik, miután az adatbázissal megszakadt a kapcsolatunk.
  • BeforeDatabaseDisconnect: A kapcsolat megszakadása előtt váltódik ki ez az esemény.
  • DatabaseFree: Az esemény bekövetkezik, amint az adatbázis által használt memória felszabadul.
  • AfterTransactionEnd: Egy tranzakció befejezése után aktiválódó esemény.
  • BeforeTransactionEnd: A tranzakció befejezése előtt következik be ez az esemény.
  • TransactionFree: Az esemény akkor váltódik ki, miután a tranzakció által használt memória felszabadul.
Metódusok:
  • ExecSQL: Olyan SQL utasítások futtatására használhatjuk, amelyek nem adnak vissza eredményhalmazt.
  • ParamByName: A paraméter nevével hivatkozhatunk a paraméterre.
Edit1.Text := IBQuery1.ParamByName('Nev').AsString;
  • Prepare: Arra használhatjuk ezt az eljárást, hogy a lekérdezés számára erőforrást foglaljunk le, és az optimalizálása megtörténhessen. Ezáltal ha többször is meghívjuk a lekérdezést, akkor az gyorsabban fog lefutni. A Delphi rendszer automatikusan optimalizálja a lekérdezést a futtatása előtt, ha mi ezt nem tettük meg, majd a futás után felszabadítja az erőforrásokat. Ezt annyiszor teszi meg, ahányszor az adott lekérdezés lefut.
  • Unprepare: Felszabadítja az utoljára meghívott Prepare metódus által lefoglalt erőforrásokat, mind a kliens, mind a szerver oldalán.
  • Open: A lekérdezés megnyitása, ha eredményhalmazzal tér vissza.
  • Close: A lekérdezés bezárása.

Interbase cikksorozat