„Informatika 2 - Adatbázisok használata labor” változatai közötti eltérés

A VIK Wikiből
← Régebbi szerkesztés
VizuálisWikiszöveges
David14 (vitalap | szerkesztései)
4 081 szerkesztés
a David14 átnevezte a(z) LaborBeugro20080326 lapot a következő névre: Informatika 2 - SQL nyelv labor: Értelmes cím
Diesel94 (vitalap | szerkesztései)
4 szerkesztés
aNincs szerkesztési összefoglaló
 
(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,&#8230;
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 &#8217;%er%&#8217;
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]]

A lap jelenlegi, 2014. április 3., 18:49-kori változata


Ez az oldal az Informatika 2 című tárgy - Adatbázisok használata labor beugrókérdéseinek kidolgozását tartalmazza.
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 4. gyakorlat segédlet címen (2013 tavasz).

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.

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.

Kérlek szerkesszétek, aktualizáljátok!

Hogyan lehet vizsgálni egy kifejezés nullitását?

A where feltételben lehet egyedül vizsgálni, a következő módon:

WHERE pelda IS NULL

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:

_: Pontosan EGY tetszőleges karakter helyettesítése
%: Tetszőleges hosszúságú karaktersorozat helyettesítése
": 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

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 (megszámolja, hogy hány rekordja van az adott relációnak).

Mire szolgál a having kulcsszó?

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.

Írja fel a select utasítás általános szintaktikáját!

SELECT [DISTINCT] oszloplista
FROM táblalista
[WHERE logikai kifejezés]
[GROUP BY oszloplista]
[HAVING logikai kifejezés]
[ORDER BY oszloplista]

Mire szolgál az ifnull függvény MySQL Serveren?

IFNULL(kifejezés1,kifejezés2)

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.

Miképp lehet megadni két tábla outer joinjá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. 

SELECT *
FROM termek RIGHT OUTER JOIN gyarto ON gyartoid=gyarto.id


SELECT *
FROM gyarto LEFT OUTER JOIN termek ON gyartoid=gyarto.id

Mit értünk az alatt, hogy egy tranzakció atomi?

Oszthatatlan, azaz vagy teljes egészében végrehajtódik, vagy teljes egészében elvetésre kerül. Köztes állapot nincs!

Mit jelent a tranzakciók konzisztencia tulajdonsága?

Az adatbázist konzisztens állapotból konzisztens állapotba viszi.

Mit jelent a tranzakciók tartósság tulajdonsága?

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.

Mit jelent a tranzakciók izolációs tulajdonsága?

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.

Mit értünk elveszett módosítás problémája alatt?

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.

Mit értünk fantom rekordok problémája alatt?

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.

Mit jelent a read committed izolációs szint?

Az egyes tranzakciók a rekordoknak csak a commitált képét láthatják.

Mit jelent a serializable izolációs szint?

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.

Mi a holtpont?

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.

Ismertesse az erőforrás foglaltsági gráf működését!

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.
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.

A lap eredeti címe: „https://vik.wiki/index.php?title=Informatika_2_-_Adatbázisok_használata_labor&oldid=180208”