WebToolkit Automata

Amikor elmesélték nekem, hogy van ez a kettő, akkor nem igazán értettem, hogy mi a különbség. A tapasztalat mondta meg, hogy végül is mire használjam őket.

Először egy gyors áttekintés:

Tárolt eljárások (Stored Procedure) alatt önálló függvényhívásokat értünk, mint pl.:

MS SQL:

exec mySP

-----------------------

ORACLE:
call mySP();

A neve után vagy adunk neki zárójelet, vagy nem. Elvileg működnie kell.

Tárolt függvények külsőre nagyon hasonlóak, DE:

1. Nem állhatnak önállóan!

Helytelen(A példa):

mySF()

Helyes(B példa):

select * from mySF()

vagy

MS SQL:

set @myvaltozo = mySF()

-----------------------------

ORACLE

myvaltozo := mySF();

2. Csak egy meghatározott értékkel térhetnek vissza!

Ez alatt azt kell érteni, hogy ha táblát is adnak vissza, akkor is tudni kell előre a tábla pontos szerkezetét mezőszámmal, típusokkal, szabályokkal/constraintekkel/ együtt. Az létrehozáskor beégetődik. "select * from tabla" esetén is figyelni kell, mert ott pontos mezőket ad vissza, és nem érzékeli, ha változott a tábla struktúrája. Ez utóbbi információ csak MS SQL alatt van számomra bizonyítva, ORACLE alatt nincs ilyen mély tapasztalatom.

Tárolt eljárásokban meghatározhatunk ki és bemenő paramétereket, de ezek nem lehetnek táblaváltozók, vagy egyéb komplex változók. Ha ilyen tábla változók visszaadására van szükség, akkor ideiglenes táblákat kell használni(temporary table). Ilyen táblák trükkjeiről majd egy másik posztban mesélek.

MS SQL alatt nem lehet tárolt eljárásokból a temptáblákhoz hozzáférni valamilyen mágikus okból... talán biztonsági probléma? Nem tudom. Oracle alatt ilyenről még nem hallottam.

  Summárium 

Szóval az én szájízem szerint a két dolgot a következőképpen használom.

Tárolt eljárásokat a programlogika első lépcsőjeként használom, tehát az adatbázishívásoknál tárolt eljárásokat hívok, emiatt

• nehezebbé válik az SQL injection típusú támadás a website ellen
• a mechanika szinte tiszta SQL alapon megy, szóval a webprogramozásban szinte csak megjelenítenem kell a kapott adatokat, mert
• a visszakapott táblákat program oldalon el tudom kapni, és ki tudom szedni, hogy melyik kell nekem (többnyire a legutolsó).

Tárolt függvényeket a select/update/delete kifejezéseimben szoktam használni, ezek

• sokszor segítenek egyszerűsíteni egy-egy kifejezést(kevesebb join, kevesebb szűrés a where-ben, és közérthetőbb, hogy mit csinál a kifejezés)
• ilyen esetekben azonban megfontolandó, hogy a kiszámolt értéket(függvény visszatérési értéke) nem célszerűbb -e előre kiszámoltatni, és feltüntetni mint mezőt

Remélem sikerült pár gondolatot felébreszteni a kedves olvasóban. Szívesen válaszolok minden felmerülő kérdésre.

Úgy hallottam, sokan nem szeretik: vagy félnek tőle vagy utálkoznak.

Szerintem ennél tömörebben, egyszerűbben nem lehet megfogalmazni, hogy mit szeretnénk egy adathalomból kinyerni. Például:

select * from dolgozo where vezeteknev = 'Kiss'

vagyis: "azokat a dolgozókat szeretném megjeleníteni, akiknek Kiss a vezetékneve". A kutya ott van elásva, hogy kicsit meg kell fordítanunk a gondolkodásmódunkat.

A legtöbb általam látott programozói logika eddig mindig azt csinálta, hogy először megmondtam, milyen halmazon végezzen műveleteket a program, és csak aztán mondtam meg, hogy mit is kéne vele csinálni. 

Ezzel szemben itt az van, hogy először megmondom, hogy mi legyen a kimenet, és aztán mondom meg, hogy miből hámozza ezt ki. Valójában viszont az egész a halmazműveletekről szól, hogy mennyire tudom pontosan behatárolni az adott halmazt, mert ha már az megvan, a művelet többnyire egyszerű: hozzáadni, kivonni, szorozni, osztani, értéket adni, stb.

Az SQL segít, hogy a programlogika már csak azokkal az elemekkel foglalkozhasson, amivel ténylegesen dolga van, és ne kelljen feleslegesen végigiterálni olyan elemeken, amik egyébként is fenn akadnak a rostán.

Ha elkezdünk egy egyszerű select-et írni, nem probléma, ha nincs meg rögtön, hogy egy adott mezőt melyik táblából és hogyan érünk el. Először mindig a from-ban meghatározott táblákra koncentráljunk, azok kapcsolataira, mert ott dől el, hogy a felvázolt struktúra jó-e, vagy több sebből vérzik. Utána a where-ben leszűrhetjük a táblánk sorait, és utána kényelmesen kiválasztjuk, hogy mely adatokra lesz szükségünk.

Ez a logika érvényes mind a 4 alapműveletre, és ha sikerül elsajátítani, akkor egyel közelebb vagyunk egy gördülékeny SQL használathoz.

Hali! :)

Én vagyok a legó-ember. Hogy miért legó? Mert bármi lehet belőle! :) Legalábbis ezt mondják rám egyesek...

A lényegre térve csak pár éve csinálom ezt a webprogramozás-dolgot, és itt talán felmerülhet a kérdés, hogy akkor minek "osztom az észt"?

Nos, ez nem észosztó hely, inkább az eddigi tapasztalataim gyűjtőhelye lenne. Gyors lista, hogy mire is gondolok itt(időrendi sorrend, hogy mivel kezdtem, és hol tartok most): standard ANSI SQL, PHP, MySQL, Java(Java SE, EE; utóbbin belül is JSP és Servlet), Oracle, MS SQL Server, ASP.NET(C#), C#, CSS, HTML/XML/XSD és társaik...

Huhh, ennek is a végére értem. :) A lényeg tömören, hogy most asp.net -et programozok legtöbbet, és jött az ötlet, hogy jó lenne felfrissíteni a Java-s tudásomat, azon belül is az Enterprise Edition -belieket. Gondoltam ha már ebbe belekezdek, akkor jó lenne feljegyezni ezeket, meg motiválva is lennék, meg egyébként is nem kis tapasztalatra tettem szert SQL megoldások terén, és ezért szerettem volna megosztani ezeket a dolgokat, szóval szerintem ezzel is fogom kezdeni, aztán jöhet a többi...