|
|
| (13 közbenső módosítás, amit 2 másik szerkesztő végzett, nincs mutatva) |
| 1. sor: |
1. sor: |
| {{GlobalTemplate|Villanyalap|LaborBeugro20080326}} | | {{Vissza|Informatika 2}} |
|
| |
|
| Ha valaki kedvet érez megformázni, nyugodtan...
| | Ez az oldal az [[Informatika 2]] című tárgy - '''Adatbázisok használata labor''' beugrókérdéseinek kidolgozását tartalmazza.<br>Az aktuális segédlet az aktuális (ajánlott) beugrókérdésekkel bejelentkezés után megtalálható a tanszéki honlapon a [https://www.aut.bme.hu/Upload/Course/VIAUA203/hallgatoi_segedletek/4.%20gyakorlat%20seg%C3%A9dlet_120316195751.pdf 4. gyakorlat segédlet címen] (2013 tavasz). |
|
| |
|
| <pre>
| | Jelenleg még elég hiányos a kidolgozás, továbbá évről évre kismértékben változhatnak beugrókérdések. A tanszéki honlapról mindig elérhető az aktuális mérési útmutató, mely az aktuális beugrókérdéseket tartalmazza. |
| Pár megjegyzés, amiben ez a nyelv különbözik az eddigiektől:
| |
|
| |
|
| - itt szimpla egyenlőségjel az egyenlőségvizsgálat, nem dupla, mint a C-ben;
| | '''''FONTOS: Ezektől eltérő kérdések is előfordulhatnak a beugrókban! Ezek csak irányadó kérdések, így ajánlott a segédlet alapos áttanulmányozása is.''''' |
| - a sztringeket nem idézőjel ("), hanem aposztróf (') határolja;
| |
| - a WHERE-en belüli logikai kifejezésben nem && jelöli az és műveletet, hanem AND, és nem || a vagy, hanem OR;
| |
|
| |
|
| | '''Kérlek szerkesszétek, aktualizáljátok!''' |
|
| |
|
| 1. Milyen szintaktikájú SQL utasítással lehet létrehozni egy rekordot egy táblában?
| | __TOC__ |
|
| |
|
| CREATE TABLE létrehozandó_tábla_neve
| | == Hogyan lehet vizsgálni egy kifejezés nullitását? == |
| (
| |
| első_oszlop_neve első_oszlopban_lévő_adatok_típusa,
| |
| ...
| |
| )
| |
|
| |
|
| Példa:
| | A where feltételben lehet egyedül vizsgálni, a következő módon: |
|
| |
|
| CREATE TABLE tanszekek
| | '''WHERE''' ''pelda'' '''IS NULL''' |
| (
| |
| id int primary key,
| |
| shortname varchar(5),
| |
| longname varchar(40),
| |
| teachers int
| |
| )
| |
|
| |
|
| Ez létrehoz egy táblát a tanszékeknek, amiben mindegyiknek van egy egyedi azonosítószáma (id, ez a tábla elsődleges kulcsa),
| | == Miképp működik a like operátor? Milyen joker karaktereket lehet használni? == |
|
| |
|
| tároljuk a legfeljebb 5 karakteres rövid nevét, és a legfeljebb 40 karakteres teljes nevét.
| | ''kifejezés'' '''LIKE''' ''string minta'' |
|
| |
|
| 2. Milyen szintaktikájú SQL utasítással lehet módosítani rekordokat?
| | String összehasonlító operátor, a kifejezésben keres a mintának megfelelően, és ha a minta illeszthető a kifejezésre, akkor az operátor igaz értékkel tér vissza. A mintaillesztés case sensitive, a használható joker karakterek: |
|
| |
|
| UPDATE módosítandó_tábla_neve
| | _: Pontosan EGY tetszőleges karakter helyettesítése<br>%: Tetszőleges hosszúságú karaktersorozat helyettesítése<br>": szimpla aposztróf, mivel, a szimpla aposztróf jel önmagában a stringhatároló karakter |
| SET első_módosítandó_oszlop_neve = első_módosítandó_oszlopba_rakandó_érték,
| |
| ...
| |
| WHERE logikai_kifejezés_ami_azokra_a_sorokra_igaz_amiket_módosítani_akarunk
| |
|
| |
|
| Példa:
| | Pl.: '''SELECT''' * '''FROM''' ''termek'' '''WHERE''' ''nev'' '''LIKE''' '%er%' |
|
| |
|
| UPDATE tanszekek
| | Azon termékek listája, amelyek neve tartalmazza az ''er'' karaktersorozatot |
| SET longname = 'Iszonyatos Info2 Tanszék'
| |
| WHERE shortname = 'IIT'
| |
|
| |
|
| Ez módosítja az IIT teljes nevét, már amennyiben szerepelt a táblában. Ha nem szerepelt, nem hozza létre (!).
| | == Hogyan működnek az oszlopfüggvények? == |
|
| |
|
| 3. Milyen szintaktikájú SQL utasítással lehet törölni rekordokat?
| | A lekérdezés eredményeként kapott rekordhalmazon lehet utólagos kalkulációt végezni velük: |
| | | *'''SUM''': Értékek összegzése |
| DELETE FROM tábla_amiből_néhány_sort_törölni_akarunk
| | *'''MIN''': Legkisebb érték megkeresése |
| WHERE logikai_kifejezés_ami_azokra_a_sorokra_igaz_amiket_törölni_akarunk
| | *'''MAX''': Legnagyobb érték |
| | | *'''AVG''': Átlag számítása |
| vagy:
| | *'''COUNT''': Rekordok megszámolása |
| | |
| DELETE tábla_amiből_minden_sort_törölni_akarunk
| |
| | |
| Példa:
| |
| | |
| DELETE FROM tanszekek WHERE shortname = 'IIT'
| |
| | |
| Ez törli a tanszékek közül az IIT-t (bár ilyen egyszerű lenne...).
| |
| | |
| 4. Hogyan lehet vizsgálni egy kifejezés nullitását?
| |
| | |
| Rossz:
| |
| SELECT FROM tanszekek WHERE shortname = null
| |
| | |
| Ez azért rossz, mert ha valamit null-lal hasonlítunk össze, az összehasonlítás eredménye mindig false, még akkor is, ha
| |
| | |
| mindkettő null (hasonlít a lebegőpontos számításoknál a NaN-nal való összehasonlításhoz), mert a null az semmivel nem egyenlő
| |
| | |
| (még önmagával se).
| |
| | |
| Jó:
| |
| SELECT FROM tanszekek WHERE shortname is null
| |
| | |
| Ezt a külön nyelvi konstrukciót lehet a null-ság vizsgálatára használni.
| |
| | |
| 5. Miképp mőködik a like operátor? Milyen joker karaktereket lehet használni?
| |
| | |
| Valami reguláris kifejezés-szerű (de nem azonos vele! annak külön szintaxisa van) dolog, ami lehetőséget ad arra, hogy
| |
| | |
| stringek egy csoportját kijelöljük, hogy megadjunk egy mintát, ami több sztringre is illeszkedhet. Pl. ha egy százalékjel (%)
| |
| | |
| van benne, az tetszőleges (akár nulla hosszú) karaktersorozatot jelenthet, az aláhúzásjel egy akármilyen karaktert jelenthet,
| |
| | |
| a dupla aposztróf pedig egy szimpla aposztrófot jelent, és csak azért kell, mert egy szimpla aposztrófot leírva vége lenne a
| |
| | |
| sztringnek.
| |
| | |
| Példa:
| |
| | |
| SELECT FROM tanszekek WHERE longname like '%barack_''alma'
| |
| | |
| Ez azokat a tanszékeket fogja visszaadni, amiknek a neve tartalmazza a barack karaktersorozatot, utána valamilyen karakter
| |
| | |
| jön, utána egy idézőjel, és végül 'alma' a vége (nincs % a végén, ezért nem lehet az 'alma' után már semmi).
| |
| | |
| 6. Hogyan működnek az oszlopfüggvények?
| |
| | |
| Előfordul, hogy nem a konkrét értékek érdekelnek, amik egy táblából kinyerhetőek, hanem pl. azok átlaga, vagy csak az, hogy
| |
| | |
| hány, a feltételnek megfelelő sor volt a táblában (pl. bejelentkezés: csak az az érdekes, hogy volt-e megadott nevet és
| |
| | |
| jelszót tartalmazó felhasználó a táblában, vagy nem). Ezeket a dolgokat el lehetne úgy is végezni a legtöbb esetben, hogy
| |
| | |
| lekérjük az összes lényeges sort a táblából, majd az adatbázison kívül kiszámítjuk, ami érdekel. Viszont ez azért nem a
| |
| | |
| legjobb, mert általában sok fölösleges pluszmunka ezt a rengeteg adatot az adatbázis és a külső feldolgozó közt átvinni - pl.
| |
| | |
| az átlagszámításhoz a legtöbb nyelvben külön ciklus kéne, lefoglalni az adatoknak sok memóriát, stb. Ezért a legtöbb
| |
| | |
| adatbázisengine képes pár ilyen dolgot maga is elvégezni. Pl. ha szeretnénk a tanárok átlagos számát kiszámítani azon
| |
| | |
| tanszékek közt, amiknek a nevében van 'SZ' (EVTSZ, SZIT, stb.), elküldhetjük a következő lekérést:
| |
| | |
| SELECT teachers FROM tanszekek WHERE longname like '%SZ%'
| |
| | |
| amivel lekérjük a megfelelő tanszékeken dolgozó tanárok számát, majd az adatbáziskezelőn kívül végigfuthatunk a kapott
| |
| | |
| sorokon, és kiszámíthatjuk az átlagot, de ez nem valami hatékony. Helyette az alábbi lekéréssel megmondhatjuk az engine-nek,
| |
| | |
| hogy ne a tanárok számát adja vissza, minden sorból egyet, hanem csak az összes sorban lévő teacher mező átlagát kérjük, és
| |
| | |
| nevezze ezt mondjuk average_teachers-nek:
| |
| | |
| SELECT avg(teachers) as average_teachers FROM tanszekek WHERE longnamelike '%SZ%'
| |
| | |
| Így az engine-től egyetlen sort kapunk majd vissza, és annak egyetlen, average_teachers mezője lesz, pont a kívánt értékkel.
| |
| | |
| A többi oszlopfüggvény, értelemszerű funkcióval, hasonló használattal és működéssel: max, min, sum, count.
| |
| | |
| 7. Mire szolgál a having kulcsszó?
| |
| | |
| Előfordul, hogy két táblából van szükségünk egyszerre adatra, és a két tábla közt valamiféle kapcsolat van. Pl. az elsőben
| |
| | |
| cégek adatai vannak, a másodikban pedig dolgozók adatai, és a második tábla egyik mezője azt tartalmazza, hogy melyik cégnél
| |
| | |
| dolgozik az adott ember (méghozzá a hellyel való spórolás miatt csak a cég azonosítószámát, nincs benne a teljes cégnév).
| |
| | |
| Tegyük fel, hogy statisztikai célokra szükségünk lenne az összes olyan cég nevére, ahol dolgozik Smith nevű alkalmazott. Ezt
| |
| | |
| megoldhatjuk úgy, hogy először lekérjük az összes Smith vezetéknevű emberhez tartozó sort a dolgozók táblából, majd ezekből
| |
| | |
| mind kivesszük a cégazonosítót, és egy ciklussal mindegyikhez lekérjük a hozzá tartozó nevet az első táblából. Ez, az előző
| |
| | |
| pontban leírtakhoz hasonló okok miatt nem hatékony. Helyette erre is van egy eszköz magában az engine-ben, és ez a JOIN.
| |
| | |
| Megtehetjük, hogy egy ilyen lekérést intézünk az engine-hez:
| |
| | |
| SELECT DISTINCT ceg_neve FROM cegek JOIN dolgozok ON dolgozok.ceg_azonosito = cegek.ceg_azonosito WHERE dolgozok.nev LIKE
| |
| | |
| '%Smith%' | |
| | |
| Ez arra utasítja az engine-t, hogy fogja meg mindkét táblát, és kapcsolja össze őket. Konkrétan a két tábla
| |
| | |
| Descartes-szorzatát hozza létre; ez az összes lehetséges pár halmaza. Vagyis, ha az első táblában volt 5 elem, a másodikban
| |
| | |
| pedig 10, akkor a Descartes-szorzatnak 50 eleme lesz, lesz egy olyan, ahol a dolgozok első sora van párban a cegek első
| |
| | |
| sorával, egy olyan, ahol a dolgozok első sora van párban a cegek második sorával, stb. Ezek közül aztán kiválasztja azokat,
| |
| | |
| amikre az ON utáni kifejezés igaz, vagyis csak azokkal a cég-dolgó párosokkal dolgozik tovább, ahol a cég alkalmazottja a
| |
| | |
| dolgozó. Ezekből aztán kiválasztja azokat, ahol a dolgozó neve tartalmazza a 'Smith' szöveget, végül a maradék sorokból csak
| |
| | |
| a cégnevet szedi ki, azok közül is kiszórja azokat, amik kétszer vannak (DISTINCT ceg_neve), és végül a kívánt listával térr
| |
| | |
| vissza.
| |
| | |
| Ez egészen addig jó is, amíg a kiválasztási feltétel csak egyes sorokkal dolgozik, de ha pl. azok a cégek kellenének, ahol az
| |
| | |
| összes dolgozó átlagfizetése 200 ezer fölött van, azt nem lenne ilyen egyszerű. Ugyanis, használva az oszlopfüggvényeket, le
| |
| | |
| akarhatnánk írni valami ilyesmit:
| |
|
| |
|
| Rossz:
| | A kiszámítandó oszlopfüggvényeket a select listában kell megadni. Az adatbázis-kezelő szerver először lefuttatja a lekérdezést az oszlopfüggvények nélkül, majd az egyes rekordokat átadja az oszlopfüggvényeknek, az értékek kiszámítására. Az oszlopfüggvények a null értéket nem veszik figyelembe, kivéve a count(*) függvény (megszámolja, hogy hány rekordja van az adott relációnak). |
| SELECT ceg_neve FROM cegek JOIN dolgozok ON dolgozok.ceg_azonosito = cegek.ceg_azonosito WHERE avg(dolgozok.fizetes)>200000
| |
|
| |
|
| Ez viszont nem működne, mert az avg() oszlopfüggvény csak a már elvégzett lekérésekből számít ki valamit, amíg még a
| | == Mire szolgál a having kulcsszó? == |
|
| |
|
| feltételek kiértékelése és a sorok kiválogatása zajlik, addig nem is létezik, és nem használható. Ezért ezt a feltételt nem a
| | Ha az oszlopfüggvény eredményére teszünk megkötést, akkor ezt a where részben nem adhatjuk meg, mivel az kiértékelődik még az oszlopfüggvények kiszámítása előtt. Ezért ha az oszlopfüggvények kimenetére szeretnénk szűrni, akkor azt külön a having kulcsszó után lehet megadni. |
|
| |
|
| WHERE után kell írni, hanem van egy külön kulcsszó, a HAVING:
| | == Írja fel a select utasítás általános szintaktikáját! == |
|
| |
|
| Jó:
| | '''SELECT''' ['''DISTINCT'''] ''oszloplista'' |
| | '''FROM''' ''táblalista'' |
| | ['''WHERE''' ''logikai kifejezés''] |
| | ['''GROUP BY''' ''oszloplista''] |
| | ['''HAVING''' ''logikai kifejezés''] |
| | ['''ORDER BY''' ''oszloplista''] |
|
| |
|
| SELECT ceg_neve FROM cegek JOIN dolgozok ON dolgozok.ceg_azonosito = cegek.ceg_azonosito HAVING avg(dolgozok.fizetes)>200000
| | == Mire szolgál az ifnull függvény MySQL Serveren? == |
|
| |
|
| És ez már a kívánt dolgot csinálja.
| | '''IFNULL'''(''kifejezés1'',''kifejezés2'') |
|
| |
|
| Megjegyzés: bizonyos esetekben a JOIN-t nem kell kiírni, és a lekérés mégis azt csinálja, mintha írtunk volna bele (implicit
| | Ha ''kifejezés1'' értéke nem NULL, akkor ''kifejezés1'' értéke kerül kiírásra. Ha ''kifejezés1'' értéke NULL, akkor kifejezés2 értéke kerül kiírásra. |
|
| |
|
| JOIN).
| | == Miképp lehet megadni két tábla outer joinját? == |
|
| |
|
| 8. Írja fel a select utasítás általános szintaktikáját!
| | A join művelet tulajdonsága, hogy a nem párosítható rekordokat nem tartalmazza az eredményhalmaz. A left outer join abban tér el ettől, hogy ha mondjuk az első táblának volt olyan sora, ami semmilyen módon nem került be a kiválasztott sorok közé, akkor nem kerül be, itt viszont bekerül, és a hozzá tartozó második táblabeli oszlopok értékei mind null-ok lesznek. A right outer join ugyanez, csak a két tábla szerepe felcserélve. |
|
| |
|
| A szögletes zárójelbeliek nem kötelezőek:
| | '''SELECT''' * |
| | '''FROM''' ''termek'' '''RIGHT OUTER JOIN''' ''gyarto'' '''ON''' ''gyartoid=gyarto.id |
| | '' |
| | '''SELECT''' * |
| | '''FROM''' ''gyarto'' '''LEFT OUTER JOIN''' ''termek'' '''ON''' ''gyartoid=gyarto.id'' |
|
| |
|
| SELECT [DISTINCT] oszlopok_amiknek_az_értéke_kell
| | == Mit értünk az alatt, hogy egy tranzakció atomi? == |
| FROM táblák_amikből_adat_kell
| |
| [where logikai_kifejezés_ami_igaz_a_sorokra_amiket_ki_akarunk_választani]
| |
| [group by mi_szerint_akarjuk_csoportosítani_a_visszaadott_sorokat]
| |
| [having logikai_kifejezés_ami_JOINnál_használatos]
| |
| [order by mi_szerint_akarjuk_rendezni_a_visszaadott_sorokat]
| |
|
| |
|
| 9. Mire szolgál az isnull függvény MS SQL Serveren?
| | Oszthatatlan, azaz vagy teljes egészében végrehajtódik, vagy teljes egészében elvetésre kerül. Köztes állapot nincs! |
|
| |
|
| Arra jó, hogy ilyen "elromlás-biztos" módon szedjem le egy változó értékét: sokszor van olyan, hogy egy változó (táblamező,
| | == Mit jelent a tranzakciók konzisztencia tulajdonsága? == |
|
| |
|
| számított kifejezés) lehet, hogy null, és ha null, akkor helyette valami mással (pl. "üres mező" stringgel) akarok dolgozni.
| | Az adatbázist konzisztens állapotból konzisztens állapotba viszi. |
|
| |
|
| Ezt az isnull(p1, p2) függvény teszi lehetővé: ha p1 nem null, akkor annak az értékét adja vissza, de ha null, akkor p2
| | == Mit jelent a tranzakciók tartósság tulajdonsága? == |
|
| |
|
| értékét, ami lehet pl. ilyen helyettesítő érték, hibaüzenet, stb.
| | Ha egy tranzakció lefutott akkor annak hatása tartósan megmarad. Azaz az adatmódosítás nemcsak a memóriában történik meg, hanem háttértárolón is rögzítésre kerül. |
|
| |
|
| 10. Miképp lehet megadni két tábla outer joinját MS SQL Serveren?
| | == Mit jelent a tranzakciók izolációs tulajdonsága? == |
|
| |
|
| A LEFT OUTER JOIN abban tér el a már leírt INNER JOIN-tól, hogy az INNER JOIN, ha mondjuk az első táblának volt olyan sora, | | A párhuzamosan futó tranzakciók egymástól függetlenül hajtódnak végre úgy, mintha egymás után hajtódnának végre. |
|
| |
|
| ami semmilyen módon nem került be a kiválasztott sorok közé (vagyis nem volt olyan második táblabeli sor, amivel
| | == Mit értünk elveszett módosítás problémája alatt? == |
|
| |
|
| összepárosítva az ON-beli kifejezés igazzá vált volna), akkor egyszerűen nem kerül be. Itt viszont bekerül, és a hozzá
| | Ha két vagy több tranzakció ugyanazon az adatelemen dolgozik, akkor a tranzakciók felül tudják írni egymás módosításait és csak annak a tranzakciónak marad meg a hatása, mely utolsónak adta ki a commit utasítást. |
|
| |
|
| tartozó második táblabeli oszlopok értékei mind NULL-ok lesznek. A RIGHT OUTER JOIN ugyanez, csak a két tábla szerepe
| | == Mit értünk fantom rekordok problémája alatt? == |
|
| |
|
| felcserélve. A szintaktika pedig:
| | A fantom rekordok olyan rekordok, melyek "megjelenhetnek" illetve "eltűnhetnek" egy táblából egy tranzakció élete során. Mivel egy párhuzamosan futó tranzakció vihet fel új rekordokat egy táblába, illetve törölhet meglévőket. |
|
| |
|
| SELECT gyarto.*
| | == Mit jelent a read committed izolációs szint? == |
| FROM gyarto left OUTER JOIN termek ON gyartoid=gyarto.id
| |
|
| |
|
| </pre>
| | Az egyes tranzakciók a rekordoknak csak a commitált képét láthatják. |
| -- [[KisGergelyG|G]] - 2008.03.25.
| |
| * {{InLineFileLink|Villanyalap|LaborBeugro20080326|SQL20nyelv.pdf|SQL20nyelv.pdf}}: A beugró maga
| |
| | |
| | |
| | |
| | |
| <pre>
| |
| Itt van egy tömörebb változat, amit én csináltam, tényleg csak a kérdésre a válasz, semmi plusz rizsa.
| |
| Az első kérdésre a válasz az enyémben jobb szerintem, de az utolsóban nagyon nem vagyok biztos. | |
| -szerkesztve: 10-es kérdést kaptam, és megkaptam rá a max pontot. - 2009.03.23.
| |
| Szóval itt van:
| |
| | |
| 1. Milyen szintaktikájú SQL utasítással lehet létrehozni egy rekordot egy táblában?
| |
| a, insert into táblanév (oszlopok listája)
| |
| values (értékek listája)
| |
| b, insert into táblanév (oszlopok listája)
| |
| select...
| |
| oszlopok listája elhagyható, select rész lekérdezést csinál, a visszaadott sorok kerülnek be
| |
| | |
| 2. Milyen szintaktikájú SQL utasítással lehet módosítani rekordokat?
| |
| update táblanév
| |
| set oszlopnév1=érték1, oszlopnév2=érték2,…
| |
| where logikai feltétel //where elhagyható
| |
| | |
| 3. Milyen szintaktikájú SQL utasítással lehet törölni rekordokat?
| |
| delete from táblanév where logikai felétel
| |
| vagy
| |
| delete táblanév <- így minden sort törlünk a táblából
| |
| | |
| 4. Hogyan lehet vizsgálni egy kifejezés nullitását?
| |
| kifejezés is null <- csak így lehet, a kifejezés = null értéke akkor sem lesz igaz, ha a
| |
| kifejezés értéke egyébként null, mivel ha valamit null-al hasonlítunk össze, az mindig false
| |
| | |
| 5. Miképp működik a like operátor? Milyen joker karaktereket lehet használni?
| |
| kifejezés like string minta
| |
| String összehasonlító operátor, a kifejezésben keres a mintának megfelelően, és ha a minta
| |
| illeszthető a kifejezésre, akkor az operátor igaz értékkel tér vissza. A mintaillesztés
| |
| case sensitive, a használható joker karakterek:
| |
| _: egy betű helyettesítése
| |
| %: tetszőleges hosszúságú szöveg helyettesítése
| |
| dupla aposztróf: szimpla aposztróf, mivel, a szimpla aposztróf jel önmagában a stringhatároló
| |
| karakter
| |
| pl.: select * from termek where nev like ’%er%’
| |
| azon termékek listája, amelyek neve tartalmazza az er karaktersorozatot
| |
| | |
| | |
| | |
| 6. Hogyan működnek az oszlopfüggvények?
| |
| A lekérdezés eredményeként kapott rekordhalmazon lehet utólagos kalkulációt végezni velük:
| |
| sum: értékek összegzése
| |
| min: legkisebb érték megkeresése
| |
| max: legnagyobb érték
| |
| avg: átlag számítása
| |
| count: rekordok megszámolása
| |
| A kiszámítandó oszlopfüggvényeket a select listában kell megadni. Az adatbázis-kezelő szerver
| |
| először lefuttatja a lekérdezést az oszlopfüggvények nélkül, majd az egyes rekordokat átadja
| |
| az oszlopfüggvényeknek, az értékek kiszámítására. Az oszlopfüggvények a null értéket nem
| |
| veszik figyelembe, kivéve a count(*) függvény.
| |
|
| |
|
| 7. Mire szolgál a having kulcsszó?
| | == Mit jelent a serializable izolációs szint? == |
| Ha az oszlopfüggvény eredményére teszünk megkötést, akkor ezt a where részben nem adhatjuk meg,
| |
| mivel az kiértékelődik még az oszlopfüggvények kiszámítása előtt. Ezért ha az oszlopfüggvények
| |
| kimenetére szeretnénk szűrni, akkor azt külön a having kulcsszó után lehet megadni.
| |
|
| |
|
| 8. Írja fel a select utasítás általános szintaktikáját!
| | A tranzakciók ütemezése konfliktus ekvivalens egy soros ütemezéssel. Azaz a tranzakciók úgy ütemeződnek, mintha egymás után futnának le. |
| select [discint] oszloplista
| |
| from táblalista
| |
| [where logikai kifejezés]
| |
| [group by oszloplista]
| |
| [having logikai kifejezés]
| |
| [order by oszloplista]
| |
|
| |
|
| 9. Mire szolgál az isnull függvény MS SQL Serveren?
| | == Mi a holtpont? == |
| isnull(kifejezés1,kifejezés2) Ha a kifejezés1 értéke nem null, akkor a kifejezés1-et adja
| |
| vissza, ha null, akkor a kifejezés2-t. Néha van olyan, hogy egy változó értéke lehet, hogy
| |
| null, és ha null, akkor lehet, hogy helyette valami mással szeretnék dolgozni.
| |
|
| |
|
| 10. Miképp lehet megadni két tábla outer joinját MS SQL Serveren?
| | Előfordulhat olyan szituáció, hogy két vagy több a párhuzamosan futó tranzakció egymásra vár, és egyik sem tudja folytatni futását. Mivel olyan erőforrásra vár amit a másik tranzakció birtokol, viszont a másik olyan erőforrásra vár, melyet az egyik birtokol. Ezt a szituációt nevezik holtpontnak. |
| A join művelet tulajdonsága, hogy a nem párosítható rekordokat nem tartalmazza az
| |
| eredményhalmaz. A left outer join abban tér el ettől, hogy ha mondjuk az első táblának volt
| |
| olyan sora, ami semmilyen módon nem került be a kiválasztott sorok közé, akkor nem kerül be, | |
| itt viszont bekerül, és a hozzá tartozó második táblabeli oszlopok értékei mind null-ok
| |
| lesznek. A right outer join ugyanez, csak a két tábla szerepe felcserélve.
| |
| select *
| |
| from termek right outer join gyarto on gyartoid=gyarto.id
| |
| select *
| |
| from gyarto left outer join termek on gyartoid=gyarto.id
| |
|
| |
|
| -- Main.meilinger - Meilinger Ákos - 2009.03.22.
| | == Ismertesse az erőforrás foglaltsági gráf működését! == |
| </pre>
| |
|
| |
|
| | Holtponti helyzetet erőforrás foglaltsági gráffal lehet szemléltetni és felismerni. Az erőforrás foglaltsági gráf olyan irányított páros gráf, melynek a csomópontjai: az erőforrások és folyamatok.<br>Az élek jelentése (iránytól függően): |
| | *Az adott erőforrást az adott tranzakció birtokol (erőforrás -> tranzakció). |
| | *Egy adott erőforrásra vár az adott tranzakció (tranzakció -> erőforrás). |
| | Holtponti helyzet akkor és csak akkor van, ha az erőforrás foglaltsági gráfban irányított kör van. |
|
| |
|
| [[Category:Villanyalap]] | | [[Kategória:Villamosmérnök]] |