anteckningar lek 4

F4

Triggers
●
Är aktiva regler som anger villkor och åtgärd.
●
Vilkoret kollas och åtgärden utförs.
●
Ågärd kan vara
–
Avbryta transaktion.
–
Ändringar i databasens data.
–
Anropande av lagrade procedurer.
–
Eventuellt anropa externa program.

ECA regler för triggers
●
Event – Händelse
●
Condition – Villkor
●
Action – Åtgärd/Aktion
●
Det är svårt att göra utan Event då databasen
hela tiden måste kolla om ett villkor är uppfyllt.
●

Exempel trigger
När vi tar bort en student vill vi automatiskt att denna tupel läggs in OldStudent

create trigger
after delete on Student
referencing old table as old
for each statement
begin atomic
insert into OldStudent
Select personummer, namn from old;
end

Ändrarar vi betyg på en student så vill vi ändra snittbetyget.

create trigger check after update on T_STUDENT_COURSE
referencing new row as n old row as o
for each row
begin atomic
declare oldgrade integer;
declare newgrade intger;
declare studentid integer;
declare courseid integer;

select grade into oldgrade from o;
select grade inte newgrade from n;
select student_id into studentid from n;
select course_id into courseid from n;
if (oldgrade > newgrade) then
update T_STUDENT_COURSE set grade = oldgrade
where student_id = studentid and course_id =
course_id;
end if;
end

Index
●
Ett index fungerar som ett register.
●
Tabellerna 'sorteras' efter ett index.
●
Create index namn on Student(namn) – Skapar
ett index på tabellen Student med avseende på attributet namn.
●
En primärnyckel är alltid ett index.

Index
●
Att ha index gör att sökning går snabbare
●
Det gör dock att uppdateringar av tabellerna går lite långsammare eftersom indexet måste byggas om vid ändringar.
●
Vad ska göras till index ?
–
Sökningar som görs ofta, dess where villkor kan vara aktuella.
–
Sökningar som det är viktigt att de går snabbt.
–
Framförallt på stora tabeller.


Fysisk lagringsstruktur
●
En databas lagras på hårddisken
●
Man kan använda filer och då antingen
–
Updelat t.ex. En fil/tabell
–
En stor fil som innehåller allt (vanligast)
●
Ett annat alternativ är att man implementerar
egen filhantering. Då allokeras en egen
partiotion av hårddisken.

●
Man har oftast en huvudfil som inehåller allt
data (en/tabell eller en stor)
●
Den kan antingen vara
–
Osorterad , läs igenom allt för att hitta
–
Sorterad, snabbare sök längre tid att lägga till.
–
Som en hashtabell, varje block motsvarar ett fack
–
Indexerat, ett index skillt från huvudfilen pekar ut
blocken I filen
●

Hashfiler
●
Fördel
–
Snabb sökning, går inte få snabbare.
–
Enkelt att lägga till/ta bort/ändra.
●
Nackdel
–
Däremot inte bra på att plocka ut range, typ alla
med skostorlek 43-47

Index
●
Tre typer
–
Primär index, sorterad som primärnyckeln
–
Grupperade index, sorterad som huvudfilen men på
annat sätt än som primärnyckel
–
Sekundär index, Sorterad på annat sätt än
huvudfilen.

Sekundär index
●
Är ett index som sorterar efter annan ordning
än huvudfilen (och dess primörindex)


Transaktioner inuti databasen
●
Bufferten mellan databasen och den fysiska
Hd:n måste hanteras.
●
Du måste hålla koll på hur bufferingen mot
filsystemet sker. Elliminera bufferingen eller
kontrollera innan 'riktig' commit;
●
A och D går ganska lätt om det inte krashar. A
rulla tillbaka I loggfilen operationer vid rollback.
D skrivs till disken punkt-slut.

Vid crash
●
Så får vi detta
–
Halvfärdiga transaktioner
–
Comittade trans där data han skrivas
–
Commitade trans där data INTE han skrivas
–
Rollade trans där ändringarna hann ändras tillbaka
–
Rollade trans där ändringarna INTE hann ändras
tillbaka

●
Återmhämntningsprocessen måste alltså gå
igenom loggfilen och behandla alla
transaktioner
●
Commitade transar Gå igenom och gör igen.
Behövs för A o D.
●
Icke commitade går man igenom och ändrar
tillbaka.
●
Operationerna är idempotenta. De kan göras
flera gånger och ge samma resultat.

Isolering
●
Allt data som används I en transaktion kopieras
in I minnet och manipuleras där, när den sedan
är klar skrivs den in I databasen.
●
Därigenom ser ingen annan ändringen förrän
den är klar.
●
Det finns vissa synkroniserings problem vis
skrivning till databasen.