Programozás | SQL » Interbase SQL összefoglaló

F3. Local SQL összefoglaló A BDE-vel (Borland Database Engine) használható Local SQL, vagy más néven a client-based SQL segítségével - amely az ANSI-92 SQL Paradox és dBASE tábláknál és mezőknél alkalmazott névadási módokat támogató részhalmaza - a következő adatforrásokat érhetjük el: − − − PARADOX és dBASE adattáblákat (elsősorban), az InterBase lokális kiszolgálót, távoli SQL kiszolgálókat (az SQL Links meghajtókon keresztül). Az SQL-utasításokat – felhasználhatóságuk és végrehajtásuk figyelembevételével - két különböző csoportra oszthatjuk. Az első csoporthoz az adatok táblákból való kiválasztását, beillesztését, módosítását, illetve törlését eredményező utasítások tartoznak (az ún. DML - Data Manipulation Language – azaz adatkezelési utasítások). A másik csoport utasításaival pedig az adattáblák és az indexek létrehozását, megszüntetését, illetve az adattáblák szerkezetének

megváltoztatását végezhetjük el. Ezek az ún DDL (Data Definition Language) adatdefiníciós utasítások, amelyek a BDE függvényeinek közvetlen meghívását idézik elő. Általános tudnivalók Az SQL-kulcsszavakban nem különböztetjük meg a kis- és a nagybetűket, így az alábbi nevek ugyanazt az utasítást jelölik: Select, SELECT, select stb. Ha több SQL-utasítást használunk, akkor az utasításokat pontosvesszővel kell elválasztani egymástól (amelyet nem kell kitenni, ha csak egy utasításról van szó) A megjegyzéseket a C nyelvből átvett formában (/*megjegyzés/) adhatjuk meg. Karakteres értékek megadása esetén az egyszeres () és a kettős (") idézőjeleket egyaránt használhatjuk. (Amennyiben nem statikusan, hanem programból adjuk meg az SQL-utasítások, csak a dupla idézőjel jöhet szóba, mivel maga az SQL-utasítás TStrings típusú). F3.1 A DML (Data Manipulation Language) utasítások A Local SQL a következő adatkezelési

utasításokat támogatja: Utasítás SELECT Leírás Létező adatok lekérdezése Az utasítás - Local SQL által támogatott - általános alakja(i) INSERT Új adatok hozzáadása táblához INSERT INTO tábla (mező1[, mező2 ]) VALUES (érték1[, érték2 ]); Létező adatok módosítása Létező adatok törlése a táblából UPDATE tábla SET mező = új érték WHERE mező = régi érték UPDATE DELETE SELECT [DISTINCT] mezőlista FROM tábla [WHERE keresési feltétel] [ORDER BY sorba rendezési lista] [GROUP BY csoportképzési lista] [HAVING feltételek сsoport szinten] [UNION újabb select utasítás] INSERT INTO tábla1 SELECT * FROM tábla2 [WHERE tábla2.mező1 ]; DELETE FROM tábla WHERE mező = érték 1 A Local SQL által támogatott DML utasításokban a következő függvényeket használhatjuk: - Összesítő (csoport-) függvények: sum() - összeg, avg() – átlag, min() – a legkisebb érték, max() – a legnagyobb érték, count() – a

rekordok száma. Például: COUNT(*) SUM(Mező1 * 10) SUM(Mező1) * 10 SUM(Mező1 + Mező2) - Karakterlánc-függvények: upper() - nagybetűssé való alakítás, lower() - kisbetűssé való alakítás, trim() ismétlődő karakterek törlése a sztring elejéről, illetve végéről, substring() – részsztring. Például: SUBSTRING(CUSTNAME FROM 1 FOR 10) FROM CUSTOMER - Dátumfüggvény: extract() - a hónap (MONTH), a nap (DAY), az óra (HOUR), a perc (MINUTE), illetve a másodperc (SECOND) értékének szűrése az időt jelző adatmező értékéből. Például: SELECT EXTRACT(YEAR FROM HIRE DATE) FROM EMPLOYEE A továbbiakban a felsorolt utasítások és függvények alkalmazásokban történő felhasználásával foglalkozunk. F3.11 A SELECT utasítás és a függvények használata A SELECT kiválasztási utasítás leggyakrabban használt alakja a következő: SELECT mezőlista FROM táblalista WHERE feltétel ORDER BY mezők A következő példában az

SQL-paranccsal BCDEMOS logikai nevű adatbázis tábláit kérdezzük le, ahol a COUNTRY adattábla az amerikai földrész országainak adatait, az ANIMALS tábla pedig egy halkatalógust tartalmaz: Query1->Close(); Query1->SQL->Clear(); Query1->SQL->Add("SELECT * FROM Country, Animals WHERE Continent = South America AND Population <5000000 AND Weight < 4"); Query1->Open(); A fenti példában az első adattáblából (Country) a válaszba csak azok a rekordok kerülnek, amelyekben a földrész (Continent) mező értéke a Dél-Amerika, a népesség (Population) mezőé pedig kisebb, mint 5 millió. A második adattábla (Animals) esetén csak azokra a halakra van szükségünk, amelyek súlya (Weight) kisebb, mint 4. A mezőnevek előtt táblanevet is használhatjuk (például: CountryContinent, illetve Animals.Weight), de erre igazából csak akkor van szükség, amikor egy lekérdezésen belül meg kell különböztetni a két vagy több tábla

azonos nevű mezőit. A * jel használatának következtében a kiválogatott rekordok összes mezője jelen lesz az eredménytáblában. Mivel egyszerre két adattáblát kérdezünk le, az eredményben az első adattábla minden egyes megtalált rekordjához hozzáadódik a második adattábla összes, a feltételnek eleget tevő bejegyzése. 2 Megjegyzés: A fenti példa kipróbálásához helyezzünk el a formon egy Query (adatkészletező), egy DataSource (adatforrás vagy adatközvetítő) és egy DBGrid (adatmegjelenítő) vezérlőelemet, és állítsuk be a TQuery típusú objektum DatabaseName tulajdonságának értékét BCDEMOS-ra! Ezek után a TDataSource típusú objektum DataSet tulajdonságában adjuk meg az adatkészletező vezérlőelemünk nevét (a példában Query1), a TDBGrid típusú objektum DataSource tulajdonságában pedig az adatközvetítő objektum nevét (a példában DataSource1). Ahhoz, hogy az adatok szerkesztési időben is láthatók legyenek a

DBGrid vezérlőelemben, állítsuk át a Query1 komponens Active tulajdonságának értékét true-ra, miután megadtunk az SQL tulajdonságában, például a következő sort: SELECT * FROM country, animals Abban az esetben, ha nincs szükségünk az összes mezőre, a lekérdezés eredményeképpen visszaadandó mezőket – egymástól vesszővel elválasztva - a SELECT kulcsszó után kell felsorolnunk: Query1->SQL->Add("SELECT Name AS Ország, Population AS Népesség FROM Country ORDER BY Népesség"); A megjelenítendő mezőkhöz álnevet is rendelhetünk (mezőnév AS álnév, vagy pedig az AS kulcsszó nélkül: mezőnév álnév), amellyel egyrészt a SELECT utasítás további részeiben lehet hivatkozni a mezőre (a fenti példában a sorrend kialakításához használt ORDER BY kulcsszó után: ., Population AS Népesség . ORDER BY Népesség ), másrészt pedig az álnevek a mezők feliratozásánál is megjelennek az adatmező adatbázisbeli neve

helyett Az ORDER BY kulcsszó segítségével megadhatjuk, hogy melyik mező(k) szerint (a SELECT kulcsszó után megadottak közül) történjen a visszaadandó rekordok sorba rendezése. Ha több mezőt jelölünk meg, akkor először az elsőként megadott mező szerint történik a rendezés. A később megadott mezők szerinti rendezés csak akkor valósul meg, ha az előbbi rendezés során kiderül, hogy az adott mező szerint az adatbázisban több azonos értékű rekord található. Ezeket a rekordokat pedig valamilyen más mező szerint is el lehet rendezni. A mezők megadását követően az ASC (alapértelmezés szerinti érték), illetve a DESC kapcsolóval jelezhetjük, hogy az aktuális mező szerinti rendezés növekvő, illetve csökkenő sorrendű legyen-e: Query1->Close(); Query1->SQL->Clear(); Query1->SQL->Add("SELECT * FROM employee WHERE HireDate > 01/02/91 ORDER BY Salary ASC, EmpNo DESC"); Query1->Open(); A mezőnevek helyén a

SELECT utasításban a mezőnevekkel műveleteket végző kifejezések is szerepelhetnek, amelyeket aritmetikai operátorok (+, -, *, /) felhasználásával állítottunk össze. Ha ezeknek a kifejezéseknek álnevet is adunk, akkor az egész egy ún. kiszámított mezőnek számít, így elvégezhető az 3 ilyen mező szerinti sorberendezés is. A következő példában a sorba rendezés mellett felhívjuk a figyelmet az álnévvel rendelkező és az álnév nélküli kiszámított mezők feliratozására is: . Query1->SQL->Add("SELECT PartNo, Description, Cost, Cost*0.25 AS Tax, Cost*0.75 FROM parts ORDER BY Tax"); . A kiválasztási feltétel megadására használt WHERE kulcsszó utáni részben nem csak mezőnevek (kivéve a kiszámított mezőneveket, mint az előző példában az AS kulcsszó után megadott álneveket), hanem állandók (például 2000, 5.02, ”Matyi” stb) is szerepelhetnek A konstans operandusokat logikai kifejezésekbe kell beépíteni,

az aritmetikai (+, -, *, /), a logikai (AND, OR, NOT), illetve a következőkben felsorolt műveleti jelekkel: = > < IS NOT NULL || LIKE BETWEEN.AND IN != egyenlő nem egyenlő >= nagyobb nagyobb vagy egyenlő <= kisebb kisebb vagy egyenlő IS NULL nem nulla értékű nulla értékű két sztring összefűzése a megadott karaktersorozat része-e egy másiknak értéktartomány a megadott érték része-e egy értékhalmaznak A LIKE operatort tartalmazó összehasonlító művelet értéke akkor true, ha a megadott mező értéke megfelel a LIKE kulcsszó után megadott karaktersorozat-maszknak (a maszkban alkalmazható % karakter tetszőleges karaktersorozatot helyettesít): mezőnév LIKE karaktersorozat Például a következő utasítással a parts adattáblából csak azokra a rekordokra vonatkozó PartNo, Description és Cost mező értékeit kérjük, amelyeknél a Description mező értéke tartalmazza a „Knife” szót: SELECT PartNo, Description, Cost FROM

parts WHERE Description LIKE %Knife% A következő példában pedig a visszaadott rekordok Description mezeje egyrészt „S” betűvel kezdődő tetszőleges szöveget tartalmazhat, másrészt pedig az összes olyan kifejezést, amelyben a „System” szó megtalálható: SELECT PartNo, Description, Cost FROM parts WHERE Description LIKE S% OR Description LIKE %System% ORDER BY Cost 4 A BETWEEN AND operator segítségével olyan adatbázis-bejegyzéseket válogathatunk ki, amelyeknél a megadott mező értéke a határértékekkel kijelölt tartományba esik: mezőnév BETWEEN érték1 AND érték2 Az előző példát egy olyan feltétellel bővítjük, hogy a visszaadott bejegyzésekben a Cost mező értéke csak 100 és 200 közötti érték lehet: SELECT PartNo, Description, Cost FROM parts WHERE (Description LIKE S% OR Description LIKE %System%) AND (Cost BETWEEN 100 AND 200) ORDER BY Cost Az IN operátor működése csak annyiban különbözik a BETWEEN AND operator

működésétől, hogy a lehetséges értékeket nem tartományként, hanem halmazként határozzuk meg: mezőnév IN értékhalmaz Például azokra a szállítókra (VendorNo) vagyunk kíváncsiak, akiktől a felsorolt búvárfelszereléseket megvásárolhatjuk: SELECT PartNo, VendorNo, Description FROM parts WHERE Description IN (Underwater Metal Detector, Dive Computer, Navigation Compass) ORDER BY VendorNo Ha a SELECT utasítás által visszaadott szöveges értékeknek csak egy részére van szükségünk (részsztringre), netalántán a szövegeket csupa nagy, illetve kis betűkkel írt karakterláncokká szeretnénk átalakítani, vagy pedig le akarjuk vágni az ismétlődő karaktereket a karakterláncok elejéről, illetve végéről, rendre a substring(), az upper(), a lover(), illetve a trim() függvényeket kell alkalmaznunk. A következő ábra szemlélteti ezen függvények működését, ahol az első adatrácsban az eredeti táblázat látható, a másodikban pedig a

részsztringek lekérdezésének eredménye (az első 5, illetve a 6-tól kezdve összes többi karaktert tartalmazó részsztring): SELECT SUBSTRING(Common Name FROM 1 FOR 5), SUBSTRING(Common Name FROM 6) FROM biolife 5 A harmadik rácsban az átalakított szöveges mezőértékeket láthatjuk (nagybetűs, kisbetűs, illetve az elején és a végén ismétlődő karakterek nélkül): SELECT UPPER(Category), LOWER(Category), TRIM(+ FROM Common Name) FROM biolife Ha a lekérdezett mezők értéke dátumot, illetve időt takar, az érték „alkotóelemeire” való bontását az extract() függvény segítségével végezhetjük el: SELECT ShipDate, EXTRACT(YEAR FROM ShipDate) Év, EXTRACT(MONTH FROM ShipDate) Hónap, EXTRACT(DAY FROM ShipDate) Nap, EXTRACT (Hour FROM ShipDate) Óra, EXTRACT (MINUTE FROM ShipDate) Perc, EXTRACT (MINUTE FROM ShipDate) Másodperc FROM orders A SELECT utasítással nem csak mezőértékek sokaságát tudjuk lekérdezni, hanem némelyik összetett

(több érték alapján kiszámított) jellemzőt is, amelynek számítását kérhetjük akár az összes, akár csak a megadott rekordcsoportra vonatkozóan. Ehhez az SQL ún beépített függvényeit kell használnunk Például a count() („darabszám”) függvény a megadott feltételeknek eleget tevő rekordok számát adja vissza: /* A parts táblázat rekordjainak száma: SELECT count(*) FROM parts */ /* Azon rekordok száma, amelyeknél a */ /* Description mező értéke nem ismétlődik / /* (a DISTINCT módosítószó használata): */ SELECT count(DISTINCT Description) FROM parts /* 100 fontnál olcsóbb termékek száma: / SELECT count(*) AS Olcsó FROM parts WHERE Cost <= 100 A count() függvényen kívül használhatjuk még a min(), a max(), az avg() és a sum() SQL-függvényeket is, amelyek rendre a paraméterként megadott mező szerinti legkisebb, legnagyobb, átlagértéket és az értékek összegét adják vissza (nullával nem egyenlő értékek esetén).

Mivel mind az öt beépített függvény egy 6 adatcsoport értékeiből kiszámított egyetlen összesített jellemzőt ad vissza, a függvényeket összesítő vagy csoport-függvényeknek is nevezzük. A SELECT utasításban nem csak az összesített jellemzők, hanem a belőlük összeállított tetszőleges kifejezések is használhatók, például: SELECT (max(Cost) + min(Cost))/2 AS Median, avg(Cost) AS Átlag1, sum(Cost)/count(Cost) AS Átlag2, sum(Cost) As Összeg FROM parts Mivel az összesített jellemzők értéke mindig egy szám, egy lekérdezésen belül nem keverhetők össze kétdimenziós jellemzőkkel (vagyis a visszaadott rekordok, illetve mezőértékek sokaságával). A dimenziók összeférhetetlensége miatt hibásnak bizonyul például a következő utasítás: SELECT Cost, sum(Cost) As Összeg FROM parts /* hibás! / Ahogy erre a C++ Builder hibaüzenete is utal, az összesített és nem összesített jellemzők együttesen csak akkor fordulhatnak elő

egy SELECT utasításon belül, ha a GROUP BY kulcsszót is használjuk. Ebben az esetben azonban a visszaadott összesített jellemzők az adattábla meghatározott rekordcsoportjaira különkülön kiszámított értékeket jelölnek. A csoportokat úgy képezhetjük, hogy a GROUP BY kulcsszó után megadunk egy mezőnevet. Egy csoportba azon rekordok kerülnek, amelyeknél a csoportosításhoz használt mezőben található értékek megegyeznek. A következő példában minden egyes eladóra (csoportosítás az eladót azonosító kód, azaz a VendorNo mező szerint) vonatkozóan lekérdezzük az eddigi vásárlásaink számát és összegét: SELECT VendorNo AS EladóAzonosító, count(*) AS VásárlásokSzáma, sum(Cost) As VásárlásokÖssege FROM parts GROUP BY VendorNo A GROUP BY után a csoportosított rekordokra vonatkozó szűrési feltételeket a HAVING kulcsszó segítségével adhatjuk meg. Például csak azokat az eladókód szerint csoportosított rekordokat

kérjük, amelyeknél a vásárlások teljes összege meghalad egy bizonyos értéket: SELECT VendorNo AS Vevőazonosító, count(*) AS VásárlásokSzáma, sum(Cost) As VásárlásokÖssege FROM parts GROUP BY VendorNo HAVING sum(Cost)>2000 Ha például az előző lekérdezésből ki szeretnénk iktatni a 2674-es számú eladóra vonatkozó adatokat, ezt még a csoportosítás előtt kell megtennünk, megadva a megfelelő feltételt a WHERE kulcsszó után: 7 SELECT VendorNo AS EladóAzonosító, count(*) AS VásárlásokSzáma, sum(Cost) As VásárlásokÖssege FROM parts WHERE VendorNo<> 2674 GROUP BY VendorNo HAVING sum(Cost)>2000 A SELECT utasítás által visszaadott eredmények egy másik SELECT utasításban is felhasználhatók. Az utasítások egymásba való beágyazásával olyan keresési feltételeket állíthatunk össze, amelyeknél maga a feltétel a táblázat aktuális adataitól függ. Például a halkatalógus legnagyobb, illetve legkisebb súlyú

hala adatai iránt érdeklődve a következő SQL-parancsot kell kiadnunk: SELECT Name, Weight, Area FROM Animals WHERE Weight = (SELECT min(Weight) FROM Animals) OR Weight = (SELECT max(Weight) FROM Animals) ORDER BY Weight A beágyazott lekérdezéseket eltérő táblákat is érinthet. Például a következő lekérdezésben azon ügyfelek adataira vagyunk kíváncsiak (Customer tábla), akik országára vonatkozó érték egy másik táblában (Country tábla) is szerepel: SELECT CustNo, Company, Country FROM Customer WHERE Country IN (SELECT Name FROM Country) A WHERE kulcsszóval megadott feltétel összeállításánál használhatjuk az ALL, az ANY és az EXISTS módosítószót is. Az ALL és az ANY azt jelzik, hogy a feltételnek valamennyi, illetve valamelyik rekordra kell teljesülnie, az EXISTS pedig azt, hogy egyáltalán létezik a feltételnek eleget tevő rekord. Például a következő utasítással a Customer táblából csak azokat a rekordokat keressük,

amelyekben a Country mezőbe írt érték nagyobb a Country tábla rekordjai Name mezőjében található valamennyi értéknél. Karakterláncok betűnkénti összehasonlításánál ez azt jelenti, hogy például a „West Indies” nagyobb lesz, mint a „British West Indies”: SELECT CustNo, Company, Country FROM Customer WHERE Country > ALL (SELECT Name FROM Country) A következő utasítással a rendezvények táblából csak azokat a rekordokat (helyiségeket) kérdezzük le, amelyekbe a jegyekért jelentkezett csoportok valamelyikét teljes egészében beültethetjük (feltételezve, hogy a jegyirodánk mindegyik rendezvényhelyiség befogadóképességének csak egy ezredét tudja lefoglalni): 8 SELECT * FROM venues WHERE (Capacity/1000) > ANY (SELECT NumTickets FROM reservat) Az EXIST módosító működését szemléltető példában az orders táblázat lekérdezésének csak akkor lesz visszaadott eredménye (a példában az összes rekord, az egyes mezők

értékétől függetlenül), ha a vásárlók közül valaki Visa kártyával is fizetett: SELECT * FROM orders WHERE EXISTS (SELECT PaymentMethod FROM orders WHERE PaymentMethod = VISA) Ahogy erről korábban már szóltunk, több tábla adatait úgy tudjuk lekérdezni, ha felsoroljuk a táblák nevét a FROM kulcsszó után. A táblák mezőire pedig abban az esetben, ha a mezőnevek megegyeznek, a táblánév.mezőnév formában kell hivatkozni (eltérő mezőnevek esetén a táblanév rész elhagyható): SELECT Last Name, custoly.first name AS Custoly Name, custoly.phone AS Custoly Phone, clients.first name AS Client Name, clients.telephone As Client Phone FROM custoly, clients WHERE (custoly.last name = clientslast name) Több táblával dolgozó operatorokban általában mindegyik táblának egy belső rövidített nevet szokás adni, melynek használata átláthatóbbá teszi az utasítást: SELECT S.* FROM custoly S, clients C WHERE (S.Last Name = CLast Name) Egy táblát

saját magával is lehet összekapcsolni úgy, hogy két (vagy több) rövid nevet adunk neki. Például, ha egy megrendeléseket összesítő táblán belül azon vásárlók azonosítóit keressük, akik egy napon vásároltak valamit, akkor ezt következőképpen tehetjük meg: SELECT SaleDate, Or1.CustNo, Or2CustNo FROM orders Or1, orders Or2 WHERE (Or1.SaleDate = Or2SaleDate) AND (Or1.CustNo < Or2CustNo) A fenti példában azért van szükség az (Or1.CustNo < Or2CustNo) feltételre, hogy kiküszöböljük a „tükrözött” értékpárokat tartalmazó rekordok (x:y, y:x, illetve x:x alakú) előfordulását. E nélkül a válasz a következőképpen nézne ki: 9 Az egynél több táblából származó rekordokat a mezőértékek teljes egybeesése nélkül is össze lehet kapcsolni egy válaszban. Ezeknek az ún külső kapcsolatoknak (outer join) három változata létezik A LEFT OUTER JOIN ON (külső kapcsolat balról) esetén a SELECT utasításban a FROM

kulcsszó után megadott tábla összes rekordja szerepelni fog a válaszban, függetlenül attól, hogy létezik-e a megfelelője a LEFT OUTER JOIN és az ON között megadott másik táblában. Az ON után pedig az összekapcsolás feltételét kell megadni. Például a custoly adattábla adatain kívül a clients tábla azon rekordjait is szeretnénk megkapni, amelyek az első táblában is előforduló családnévvel (last name) rendelkező személyekre vonatkoznak: SELECT custoly.last name+ +custolyfirst name AS Custoly Name, custoly.phone AS Custoly Phone, clients.last name+ +clientsfirst name AS Client Name, clients.telephone AS Client Phone FROM custoly LEFT OUTER JOIN clients ON custoly.last name=clientslast name Ha a fenti példában a LEFT OUTER JOIN ON helyett a RIGHT OUTER JOIN ON (külső kapcsolat jobbról) formát használjuk, az alaptábla szerepét a később (JOIN után) megadott tábla játssza: A külső kapcsolatok harmadik formája, a FULL OUTER JOIN ON

teljes hozzákapcsolást jelent, amelynél a két adattábla összes rekordja hozzáadódik a válaszhoz, az azonossági feltételeknek eleget tevő rekordok „párosításával”: SELECT custoly.last name+ +custolyfirst name AS Custoly Name, custoly.phone AS Custoly Phone, clients.last name+ +clientsfirst name AS Client Name, clients.telephone As Client Phone FROM custoly FULL OUTER JOIN clients ON custoly.last name=clientslast name ORDER BY clients.telephone 10 Ha a két táblázat azonos struktúrával rendelkezik (például az A és a B osztály tanulóinak azonos módon tárolt adatai), a két vagy több táblára vonatkozó SELECT utasítás UNION kulcsszóval kapcsolható össze, így a lekérdezések eredménye egy táblában jelenik meg. Ilyenkor a lekérdezett mezők számának, sorrendjének, illetve típusának az összes kapcsolt SELECT utasításban meg kell egyeznie. Ha azonban csak egy mezőt kérdezünk le, akkor az értékek típusazonossága elegendő

feltétel. Így születhetett például a következő furcsa eredménylista: SELECT First Name FROM clients /* ügyfelek / UNION SELECT Common Name FROM biolife /* halak / F3.12 Az INSERT, az UPDATE és a DELETE utasítások Az INSERT utasítás segítségével újabb rekordokat adhatunk hozzá az adattáblához: INSERT INTO tábla (mező1[, mező2 ]) VALUES (érték1[, érték2 ]); Például egy program.dbf nevű táblába egy új rekordot illesztünk be, megadva a folder, filename, filesize, filedate és notes mezőkre vonatkozó értékeket: INSERT INTO program (folder, filename, filesize, filedate, notes) VALUES (CppBuilder, sqlprog.exe, 635948, Cast(2001.0503 AS Date), Hello) Tetszőleges rekordok beszúrásán kívül a Local SQL az INSERT utasításnak olyan alakját is támogatja, amely segítségével egy adattáblából a SELECT utasítással lekérdezett rekordokat egy másik táblázatba másolhatjuk: INSERT INTO tábla1 SELECT * FROM tábla2 [WHERE tábla2.mező1 ];

Például a fenti példában is szereplő program táblába az azonos struktúrával rendelkező prog1.dbf táblából az összes olyan rekordot átmásoljuk, melyek filename mezője tartalmazza az „sql” karaktersorozatot: INSERT INTO program SELECT * FROM prog1 WHERE prog1.filename LIKE sql%exe); Az adattábla már létező bejegyzéseinek módosítására az UPDATE utasítás szolgál: UPDATE tábla SET mező = új érték WHERE mező = régi érték 11 Például olyan bejegyzések esetén, amelyek filename mezőjének értéke sqlprog.exe, módosítjuk a dátumot (filedate mező) 2000. szeptember 10-ére: UPDATE program SET filesize=1111, filedate = Cast(2000.0911 AS Date) WHERE filename = sqlprog.exe A DELETE utasítással pedig rekordokat törölhetünk adattáblából: DELETE FROM tábla WHERE mező = érték Például: DELETE FROM program WHERE filename=sqlprog.exe 12 F3.2 A DDL (Data Definition Language) utasítások A Local SQL a következő adatdefiníciós

utasításokat támogatja: Utasítás CREATE TABLE ALTER TABLE DROP TABLE CREATE INDEX DROP INDEX CREATE VIEW Leírás Adattábla létrehozása Létező adattábla átstrukturálása Adattábla törlése Index létrehozása Index törlése Virtuális tábla létrehozása F3.21 A CREATE TABLE utasítás A CREATE TABLE utasítással egy új (üres) táblát hozhatunk létre, felsorolva zárójelek között a tábla mezőneveit, illetve a mezők típusát: CREATE TABLE tábla név (mező1 típus1, [mező2 típus2 ]); Az alábbi példában egy Paradox (.DB) adattáblát hozunk létre, elsődleges kulcsként (PRIMARY KEY) deklarálva a LAST NAME és FIRST NAME mezőket: CREATE TABLE employee.db (LAST NAME CHAR(20), FIRST NAME CHAR(15), SALARY NUMERIC(10,2), DEPT NO SMALLINT, PRIMARY KEY(LAST NAME, FIRST NAME) ) A dBASE táblák (.DBF) létrehozása a PRIMARY KEY megadása nélkül történik: CREATE TABLE employee.dbf ( LAST NAME CHAR(20), FIRST NAME CHAR(15), SALARY NUMERIC(10,2), DEPT

NO SMALLINT ) A következő táblázat az CREATE TABLE SQL-utasításban megadható, illetve az ennek megfelelő BDE, Paradox, és dBASE mezőtípusokat tartalmazza. A táblában az x paraméter a pontosságot (alapértelmezés szerinti értéke függ az használt adatbázis-meghajtótól), az y a tizedes jegyek számát (alapértelmezés szerint 0), az n pedig a mező bájtban kifejezett méretét (alapértelmezés szerint 0) jelöli. Az 1-től 5-ig terjedő érékek pedig a BLOB (Binary large object) altípusokat jelölik (feljegyzés, bináris, formázott feljegyzés, OLE és grafika - alapértelmezés szerinti érték 1). 13 SQL szintaxis BDE megfelelő Paradox dBASE SMALLINT fldINT16 Short Number (6,10) INTEGER fldINT32 Long Integer Number (20,4) DECIMAL(x,y) fldBCD BCD − NUMERIC(x,y) fldFLOAT Number Number (x,y) FLOAT(x,y) fldFLOAT Number Float (x,y) CHARACTER(n) fldZSTRING Alpha Character VARCHAR(n) fldZSTRING Alpha Character DATE fldDATE

Date Date BOOLEAN fldBOOL Logical Logical BLOB(n,1) fldstMEMO Memo Memo BLOB(n,2) fldstBINARY Binary Binary BLOB(n,3) fldstFMTMEMO Formatted memo − BLOB(n,4) fldstOLEOBJ OLE OLE BLOB(n,5) fldstGRAPHIC Graphic − TIME fldTIME Time − TIMESTAMP fldTIMESTAMP Timestamp − MONEY fldFLOAT, fldstMONEY Money Number (20,4) AUTOINC fldINT32, fldstAUTOINC Autoincrement − BYTES(n) fldBYTES(n) Bytes − F3.22 Az ALTER TABLE és a DROP TABLE utasítások Az ALTER TABLE utasításnak, amellyel egy létező adattáblát átstrukturálhatunk, a Local SQL a következő változatait támogatja: ADD - új oszlopok (mezők) hozzáadása, DROP - létező oszlopok törlése, illetve a kettőnek egy utasításban való egyidejű használata. Az új oszlopok hozzáadásához használható ALTER TABLE utasítás általános alakja: ALTER TABLE táblanév ADD oszlopnév1 adattípus1 [, ADD oszlopnév2 adattípus2 .] Például: ALTER TABLE employee.dbf ADD

BUILDING NO SMALLINT A létező mező törléséhez használható ALTER TABLE utasítás általános alakja: ALTER TABLE táblanév DROP oszlopnév1 [, DROP oszlopnév2.] Például: ALTER TABLE employee.db DROP LAST NAME, DROP FIRST NAME 14 A következő példában az ADD és a DROP együttes használatával átstrukturáljuk a CREATE TABLE utasítással létrehozott adattáblát: CREATE TABLE empl.dbf (LAST NAME CHAR(20), FIRST NAME CHAR(15), SALARY NUMERIC(10,2), DEPT NO SMALLINT) ALTER TABLE empl.dbf DROP LAST NAME, DROP FIRST NAME, ADD FULL NAME CHAR[30] Létező adattáblák törlésére a DROP TABLE utasítást használhatjuk: DROP TABLE empl.db F3.23 A CREATE INDEX és a DROP INDEX utasítások A CREATE INDEX utasítás segítségével indexeket hozhatunk létre egy adattáblához: CREATE INDEX indexnév ON táblanév(mező1 [, mező2 .]) A dBASE táblák esetén az indexeket kizárólag csak a CREATE INDEX utasítással hozhatjuk létre, például: CREATE INDEX NAME

X ON empl.dbf (LAST NAME) Paradox táblák esetén a CREATE INDEX utasítással csak akkor hozhatunk létre egy elsődleges indexet, ha a tábla létrehozásakor (CREATE TABLE) az adott mezőt elsődleges kulcsként (PRIMARY KEY) deklaráltunk. A többi mező esetén a CREATE INDEX utasítás eredménye másodlagos index lesz 15 Az indexek törléséhez a DROP INDEX utasításnak a Local SQL által támogatott változatát kell használnunk: DROP INDEX táblanév.indexnév vagy DROP INDEX táblanév.PRIMARY A PRIMARY kulcsszót a Paradox adattáblák elsődleges indexeinek törléséhez használjuk, például: DROP INDEX employee.dbPRIMARY A dBASE indexek, illetve a Paradox táblák másodlagos indexeinek törlésekor az index nevét kell megadnunk táblanevet követően: DROP INDEX empl.dbfNAME X 16