The Matthias Knecht Tae Kwon Do Case Study BHAMBRA Manjyot KOHLI Garima MANGAL Storay TAWHEED Zureen Distinction Assignment, Autumn 2007

The Matthias Knecht Tae Kwon Do Case Study

BHAMBRA ManjyotKOHLI GarimaMANGAL StorayTAWHEED Zureen

Distinction Assignment, Autumn 2007

2

Introduction to the The Matthias Knecht Tae Kwon Do Case Study

This database is reflective of a Tae Kwon Do challenge and introduces us to all the entities that are involved in such a challenge and the relationships existing between them.

In a typical tournament fighters engage in a challenge and are both judged on their performance.

Competitors choosing to undergo training receive adequate preparation from professional club members. Alternatively competitors can still compete possessing private skills.

3

The ERD for Matthias Knecht Tae Kwon Do

KnFighter

KnFighterID

KnFighterName

KnFighterBirth

KnFighterGender

KnFighterWeightclass

KnFederation

KnRules

KnTrainer

KnTrainerID

KnTrainerName

KnTrainerBirth

KnTrainerGender

KnClubID *

KnFederationName *

KnRing

KnRingID

KnSize

KnRing

KnSize

KnJudge

KnJudgeID

KnJudgeName

KnJudgeBirth

KnFederationName *

KnTraining

KnFighterID *

KnTrainerID *

KnChallenge

KnFigherID1*

KnFigherID2*

KnFighterGender1

KnFighterGender2

KnFighterWeightclass1


KnRingID *

KnJudgeID *

KnWinner

KnLoser

KnFighterGender1

KnFighterGender2



KnRingID *

KnJudgeID *

KnWinner

KnLoser

KnClub

KnClubID

KnClubName

KnFederationName

SQL Queries on a Single Entity/ Table

5

Project [using “select”]

This SELECT query reports the fighters ID number, the fighters name

and his/her weight class.

KnFighter!D KnFighterName KnFighterWeightClass

200001 Karl Dall 5

200002 Martin Knecht 5

200003 Liz Taylor 5

200004 Young Parawan 3

200005 Bruce Lee 3

200006 Elisabeth Brown 3

200007 Christoph Knecht 3

200008 Lars Augenstein 4

200009 Lisa Mueller 4

200010 Larry Wahnhold 4

200011 Chin Moban 4

200012 Chels McGyvan 4

200013 Nathan Johhns 3

200014 Karl Mueller 2

200015 Linda Sureban 2

200016 Isidor Kraus 4

200017 Jet Lee 2

200018 Ling Suk Pran 2

200019 Janina Federholzer 3

200020 Mario Kleinschmid 4

200021 Jana Kralle 5

200022 Ingwan Young Kam 5

The columns listed after SELECT are the ones that are displayed in the table

SELECT

KnFighterID, KnFighterName, KnFighterWeightclass FROM KnFighter;

6

Restrict [using “where”]Allows the selection of the specific rows of interest from the table


200001 Karl Dall 5


200003 Liz Taylor 5



Using the same sql as the previous slide; the output can be further restricted by simply adding an extra line:

SELECT KnFighterID, KnFighterName, KnFighterWeightclass

FROM KnFighter

WHERE KnFighterWeightClass = 5;

This will restrict the output to showing only those fighters who are categorised as being in the fifth weight class

7


200001 Karl Dall 5


200003 Liz Taylor 5


200005 Bruce Lee 3



200008 Lars Augenstein 4

200009 Lisa Mueller 4

200010 Larry Wahnhold 4

200011 Chin Moban 4

200012 Chels McGyvan 4




200016 Isidor Kraus 4

200017 Jet Lee 2



200020 Mario Kleinschmid 4



Restrict [using “where”]

Rows highlighted here from the

original table are the ones that

match the criteria in the ‘restrict’

query using ‘where’.

In each of the matching records, the fighter weight

class is equal to 5.

8

Allows specification of any combination of columns and rows for instance:

The following sql would be used to restrict the output to showing fighter names and weight classes of those fighters who have a weight class [knfighterweightclass] of no more than 3 [<= 3]:

SELECT knFighterName, knFighterWeightClass

FROM knFighter

WHERE KnFighterWeightClass <= 3;

Project and Restrict Combo

9



200005 Bruce Lee 3






200017 Jet Lee 2



Project and Restrict Combo

The result of the previous query would be as seen below:

Here, only those fighters with a weight class of 3 or less are listed

10

IS NULLUsing the IS NULL restriction, the result shows a record with a field where no value has

been inserted.

For instance; to display all the challenges where there was no winner as the match may have been a tie or it may have been uncompleted; the winner field [knwinner] would be null and the query would be written as follows:

SELECT knfighterid1, knfighterid2, knwinner, knloser FROM knchallengeWHERE knwinner IS NULL;

This query would display the following result:

Knfighterid1 Knfighterid2 Knwinner Knloser

200020 200010 200010

11

Using the IS NOT NULL restriction, the result ensures that the field has a value inserted.

For instance; to display all the judges and the birth year where their birth year is known [i.e. IS NOT NULL], the query would be written as follows:

SELECT knjudgename, knjudgebirth FROM knjudgeWHERE knjudgebirth IS NOT NULL

This query would display the following result:

IS NOT NULL

Knjudgename knjudgebirth

Young Sik Park 1963

Kwung Do Den 1944

Hannes Maurer 1969

Dolo Dobendan 1983

Nunzio Caico 1954

Hung Kwan Do 1931

Klaus Meier 1977

Raymond Lister 1961

Boris Becker 1955

Karl Heinz Hannebu1/4her 1933

12

INUsed on data to generate required results – works similarly to a ‘where’ function as seen below:

A query using IN looks like:SELECT * FROM KnTrainerWHERE KnClubID IN (‘3',‘10');

This is the same as writing:SELECT * FROM KnTrainerWHERE KnClubID = ‘3' OR KnClubID = ‘10';

Either way; the output will be:

KnTrainerID KnTrainerName KnTrainerBirth KnTrainerGender KnClubID KnFederationName

100003 Lizz Tough 1946 F 3 ITF

100010 Chelsea Lai 1983 F 10 WTF

100011 Matthias Sammer 1963 M 10 WTF

100012 Kim Kwak 1967 M 10 WTF

100014 Susi Ingelheimer 1947 F 3 ITF

13

NOT INUsed to eliminate some records that match the specified criteria – also works similarly to a ‘where’ function as seen below:

A query using NOT IN would look like:SELECT * FROM KnTrainer WHERE KnTrainerGender NOT IN (‘M');

This is the same as writing: SELECT * FROM KnTrainer WHERE KnTrainerGender <> ‘M‘;

Either way; the output will be:

KnTrainerID KnTrainerName KnTrainerBirth KnTrainerGender KnClubID KnFederationName

100003 Lizz Tough 1946 F 3 ITF

100004 Lollo Ingenheim 1975 F 4 ITF

100007 Claudia Schiffer 1953 F 7 WTF

100009 Lara Croft 1975 F 9 WTF



14

Ordering columns

For instance:

SELECT KnTrainerID, KnTrainerName FROM KnTrainer WHERE KnTrainerBirth > 1980;

The order in which the columns appear in the table is dependent on the order the columns placed in the SQL following “SELECT”

KnTrainerID KnTrainerName

100010 Chelsea Lai

100013 Kwak Kum Sik

100015 Andre Agassi

15

Ordering rows using “order by”

This command is used where the results need to be ordered in a specific way – i.e. ascending or descending. For instance:

SELECT KnTrainerName, KnTrainerBirth

FROM KnTrainer

WHERE KnTrainerBirth > 1980

ORDER BY KnTrainerBirth;

KnTrainerName KnTrainerBirth

Chelsea Lai 1983

Andre Agassi 1985

Kwak Kum Sik 1985

Note: the same result would be generated for:SELECT KnTrainerName, KnTrainerBirth FROM KnTrainer WHERE KnTrainerBirth > 1980 ORDER BY KnTrainerBirth ASC;

16

Calculating – with the use of ‘AS’Using the “AS” function allows the count column to be renamed

For instance, for such a query:

SELECT knwinner, count (*) as number_of_wins FROM knchallengeWHERE knwinner = 200020GROUP BY knwinner;

The count column counting the number of wins by this fighter will be renamed as number_of_wins as seen below:

Knwinner number_of_wins

200020 3

Or even for something simpler; could have SELECT knwinner as WINNER

FROM knchallenge

17

Built-in functions – Count(*)COUNT(*) – a function that counts all the rows in a table you specify

For instance:

SELECT knWinner, count (*) as number_of_wins FROM knChallengeWHERE knWinner = 200020GROUP BY knWinner;

Note: always requires a group by function when counting all – specifies what is being used to group and count

Knwinner number_of_wins

200020 3 This result shows how many times this fighter has won a challenge

18

COUNT(X) – a function that counts all the rows in that column (“X”)

For instance; the following will count the number of entries made for ‘knWinner’

SELECT count (knWinner) FROM knChallenge

Furthermore;

SELECT count (distinct knWinner) FROM knChallenge

would count all the ‘distinct’ values in that column – i.e. values that occur only once. So here, it would count each time a fighter wins a fight their first time

Built-in functions – Count(X)

count

20

count

14

19

Built-in functions [Sum/Avg]

SUM – gives the total for a specified column

SELECT sum (knSize) FROM knRing

AVERAGE

SELECT avg (knSize) FROM knRing

This could be renamed using the AS function by doing:

SELECT avg (knSize) as Average_Ring_Size FROM knRing

avg

11.8

Average_Ring_Size

11.8

Sum

59

20

Built-in functions [Min/Max]

MIN – gives the minimum value for that column

So the smallest ring where a challenge can be held is:

SELECT min (knSize) FROM knRing

MAX – returns the maximum input for that column

So the highest weight class a fighter can belong to is:

SELECT max (knFighterWeightClass) FROM knFighter

Min

9

Max

5

21

LIKE – and its operators

KnFighterName

Martin Knecht

Mario Kleinschmid

The LIKE function allows the query to be more specified by either specifying what the entries must start with [using the %] operator or indicating, for instance, a letter that must be present in the result.

The following will return results for names that start with the letter ‘M’

SELECT KnFighterName

FROM KnFighter

WHERE KnFighterName LIKE ‘M%’

Alternatively; a query can be used to return results with a name containing ‘er’ :

SELECT KnFighterName

FROM KnFighter

WHERE KnFighterName LIKE ‘%er%’

KnFighterName

Lisa Mueller

Karl Mueller

Janina Federholzer

22

LIKE – and its operatorsFor instance, to find a name containing the letter ‘l’ but the it being the

2nd letter in the name:

SELECT knFighterName

FROM knFighter

WHERE knFighterName LIKE ‘_l%’

knFighterName

Elisabeth Brown

KnFighterName

Bruce Lee

Christoph Knecht

Jet Lee

The NOT LIKE function can also be used to do the opposite:

For Instance – names that DO NOT contain the letter ‘a’

SELECT knFighterName

FROM knFighter

WHERE knFighterName NOT LIKE ‘%a%’

23

DISTINCTThis function works to eliminate any duplicate rows For instance, to view how many different weight classes there are, use:

SELECT DISTINCT KnFighterWeightClass FROM KnFighter;

Furthermore; the total different weight classes are:

SELECT Count (DISTINCT KnFighterWeightClass) FROM KnFighter;

KnFighterWeightClass

2

3

4

5

Count

4

24

Inserting rows

INSERT INTO KnFighter VALUES (200001,'Karl Dall',1981,'M',5);

This is representative of the fields:

INSERT INTO KnFighter VALUES (KnFighterID,KnFighterName,KnFighterBirth,KnFighterGender,KnFighterWeightclass);

so here: KnFighterID = 200001KnFighterName = Karl Dall

KnFighterBirth = 1981 KnFighterGender = M KnFighterWeightClass = 5

The following insert statement can be used to insert statements into the KnFighter table:

Foreign Keys and Natural Joins

26

Club ID and TrainerKnClubid KnClubname

1 Black Tiger Tae-Kwon-Do

2 Sydney Fight Club

3 Do-Kwon-Dan

4 Budo Club Toronto

5 TKD e.V. Freiburg

6 Hiko-Dotan

Primary keys

Foreign keys

KnTrainerid KnTrainername KnTrainerbirth KnTrainergender KnClubid KnFederationname

100001 Hannes Mariz 1977 M 1 ITF

100002 Young Kawan 1967 M 2 ITF

100015 Andre Agassi 1985 M 2 ITF

This illustrates that the primary keys of one table can be foreign keys in another table

27

The Natural JoinThis function, using existing tables, creates a new table by matching

columns and adding those that are not common

So to join the table KnTrainer and the table KnClub the following query would be used to display this new table where all columns from both tables are displayed:

SELECT * FROM KnTrainer natural join KnClub;

KnTrainerid KnTrainername KnTrainerbirth KnTrainergender KnClubid KnFederationname KnClubname

100001 Hannes Mariz 1977 M 1 ITF Black Tiger Tae-Kwon-Do

100002 Young Kawan 1967 M 2 ITF Sydney Fight Club

100015 Andre Agassi 1985 M 2 ITF Sydney Fight Club

28

The Cross product function is simple another method of joining two tables (as opposed to the “natural join” on the previous

So once again, to join the tables KnTrainer and KnClub using the cross product, the query would be:

SELECT * FROM KnTrainer, KnClubWHERE KnClub.KnClubid = KnTrainer.KnClubid;

The sql is written as table name followed by the DOT followed by column name and then the name of the other table with the same column separated by ‘=’. This clarifies that the two columns which appear in different tables are actually the same. Thus disambiguating the columns.

• NOTE: If you don’t use a * after SELECT, and you specify “KnClubid”, you will need a to use a dot.

Cross Product

The two columns that are the same

29

Cross Product

As we can see, the result from both the Natural Join and the Cross Product is the same, the only difference is the cross product defines the common columns and which table they are extracted from

KnTrainerID KnTraineNname KnTrainerBirth KnTrainerGender KnClubID KnFederationName KnClubname

100001 Hannes Mariz 1977 M 1 ITF Black Tiger Tae-Kwon-Do

100002 Young Kawan 1967 M 2 ITF Sydney Fight Club

100015 Andre Agassi 1985 M 2 ITF Sydney Fight Club

30

More Cross ProductThe Cross Product function can also like other functions be restricted to

displaying certain columns and rows in addition to select data fulfilling certain conditions placed by the sql

For instance, to view the birth, and federation name of judges beginning with ‘K’ the insert statement would be:

Select KnJudgeName, KnJudgeBirth, KnJudge.KnFederationNameFROM KnFederation, KnJudge WHERE KnFederation.KnFederationName = KnJudge.KnFederationName

AND KnJudgeName LIKE ‘K%’;

The KnFederation needs to be assigned a table from which it will be extracted since it exists in two tables and although it is the same, the program does not recognise this and thus it must be pointed out [which is where the Cross Product comes in]

31

Cross Product

The output of the query from the previous slide would be:

KnJudgeName KnJudgeBirth KnFederationName

Kwung Do Dan 1944 WTF

Klaus Meier 1977 ITF

Karl Heinz Hannebucher 1933 ITF

As we can see, only the columns specified are shown as compared with the KnTrainer and KnClub tables where all the columns from the two tables were shown

32

More cross Product

KnTrainerID KnTrainerName KnClubID

100001 Hannes Mariz 1

100002 Young Kawan 2

100003 Lizz Tough 3

100004 Lollo Ingenheim 4

Similarly a query where we want to the find the trainer ID, name and which club they belong to would look like :

Where the KnClubID has been extracted from the KnClub table to the KnTrainer table

Entities and Relationships

34

KnTraining − KnTrainer1:m relationship

The ERD on slide 3, shows a one to many relationship, like this one

The Actual Tables …

KnTrainerID other columns

100016 …

… etc … …

KnTrainerID KnFighterID

100016 200004

100016 200005

Foreign Key

35

KnChallenge − KnJudge 1:m relationship

The ERD on slide 3, shows a one to many relationship, like this one

Actual Tables …

KnJudgeID other columns

30006 …

… etc … …

Foreign Key

KnJudgeID KnFighterID1 KnFighterID2

30006 200004 200005

30006 200003 200021

36

The ERD on slide 3, shows a many to many relationship, like this one

KnFighter − KnTrainer m:m relationship

KnFighterID KnTrainerID

200001 100016

200001 100012

200002 100015

200002 100011

The table “Training”

37

• These are the different tables associated with this relationship


KnTrainerID KnTrainerName …

100016 Bruce Perrot …

100012 Kim Kwak …

100015 Andre Agassi …

100011 Matthias Sammer …

KnFighterID KnFighterName …

200001 Karl Dall …

200002 Martin Knecht …

The table “KnTraining”

The table “KnFighter”

The table “KnTrainer”

38

• These are the different tables associated with this relationship



200001 100016

200001 100012

200002 100015

200002 100011

The table “KnTraining”

The table “KnFighter”

The table “KnTrainer”

KnTrainerID KnTrainerName …

100016 Bruce Perrot …

100012 Kim Kwak …

100015 Andre Agassi …

100011 Matthias Sammer …

KnFighterID KnFighterName …

200001 Karl Dall …

200002 Martin Knecht …

Group by, sub-queries and complex joins

40

GROUP BYReporting the number of fighters within each fighter weight class

SELECT count(knfightername) as fighters, knfighterweightclass)

FROM knfighterGROUP BY knfighterweightclass;

fighters knfighterweightclass

5 5

7 4

6 3

4 2

(4 rows)

41

HAVING – like WHERE, but after the grouping

Report the number of fighters in each class below weight-class 5

count(knfightername) as fighters, knfighterweightclass)

FROM knfighterGROUP BY knfighterweightclass;

HAVING COUNT knfighterweightclass <5;

fighters knfighterweightclass

7 4

6 3

4 2

(4 rows)

42

Sub Queries• A query within a query

Report all females with a birth year greater than the average birth year of females in weight-class 3.

SELECT knfighterbirth, knfightergender FROM knfighter WHERE knfightergender ='F‘

and knfighterweightclass =3 and knfighterbirth >= (select avg (knfighterbirth)

from knfighter);

AVG

1995 F 3

knfighterbirth knfightergender

knfighterweightclass

1976 F 3

1995 F 3

(2 rows)

43

Using subqueries to find the maximum (or minimum)

Find the highest weight-class of female competitors. • SELECT distinct knfightergender,


FROM knfighter WHERE knfightergender ='F' and knfighterweightclass >= (select

max(knfighterweightclass) from knfighter where knfightergender ='F');

knfightergender knfighterweightclass

F 5

(1 rows)

44

Alternate way to find the maximum (or minimum): “ALL”

Give pizza and prices for pizzas that are more expensive than all Italian pizzas.select knfightergender,


from knfighter

where knfightergender ='F' and knfighterweightclass >= ALL ( select knfighterweightclass from knfighter

where knfightergender ='F');

knfightergender knfighterweightclass

F 5

F 5

(1 rows)

45

Another ALL example

select distinct knfightergender, knfighterweightclass

from knfighterwhere knfightergender ='F' and knfighterweightclass <= ALL ( select knfighterweightclass from knfighter where knfightergender ='F');

this is equivalent to …

WHERE knfightergender = (select min(knfighterweightclass);

46

ANY operator

List federation names with at least ‘one’ female trainer

Select distinct knfederationname From kntrainerWhere knfederationname = ANY (select knfederationname from kntrainer where kntrainergender ='F');

knfederationname

ITF

WTF

47

In: an Alternate to ANY

List federation names with at least ‘one’ female trainer

Select distinct knfederationname From kntrainer

Where knfederationname IN (select knfederationname from kntrainer where

kntrainergender ='F');

knfederationname

ITF

WTF

48

Left Outer Join

KnClubid KnTrainerid KnTrainername knTrainerbirth KnTrainergender KnFederationname KnClubname

1 100001 Hannes Mariz 1977 M ITF Black Tiger Tae-Kwon-Do

2 100002 Young Kawan 1967 M ITF Sydney Fight Club

2 100006 Bruce Perrot 1945 M ITF Sydney Fight Club

Where the table will always contain all the records of the left table regardless of whether matching records of the right table exist or not. In the case where there is no data in that particular field of the right table, null placed in the table.

The query for a left outer join where the table KnTrainer is the left table and KnClub is the right, i.e. KnCub is being joined to the KnTrainer using a common table i.e. KnClubid, would be as follows:

Select * from KnTrainer left join KnClub using (KnClubid);

49

Right outer Join

A right outer join works in exactly the same way as a left outer join however the tables will be reversed.

In that, it will be the right table that is the “main” table or the table where every record will be joined at least once and where, in the left table there are no matching rows, a null will be placed in the left table for those rows.

In the case of this database, there are no null values and thus the two tables will be exactly the same.

50

Self-Join

• Join a table to itself• Usually involve a self-referencing

relationship• Useful to find relationships among rows of the same table emp

supervises

51

Querying a recursive relationship

SELECT distinct t1.kntrainername, t2.kntrainername AS trainername, t1.knclubID, t2.knclubID AS ClubID

FROM kntrainer t1, kntrainer t2WHERE t1.kntrainername = t2.kntrainernameAND t1.knclubID = t2. knClubID;

kntrainername Trianername KnclubID ClubID

Andre Aggassi Andre Aggassi 2 2

Bruce Perrot Bruce Perrot 2 2

Chelsea Lai Chelsea Lai 10 10

Claudia Schiffer Claudia Schiffer 7 7

Hannes Mariz Hannes Mariz 1 1

Ken Ferret Ken Ferret 6 6

Kim Kwak Kim Kwak 10 10

Matthias Sammer Matthias Sammer 10 10

Data Integrity with SQL

53

Foreign Keys KnClubID KnClubName

1 Black Tiger Tae-Kwon-Do

2 Sydney Fight Club

3 Do-Kwan-Dan

4 Budo Club Toronto

5 1. TKD e.V. Freiburg

6 Hiko-Dotan

7 Wollongong Crows

8 Korean National Team

9 Dobok-Hin-Dokan

10 Matthias Knecht TKD Team

KnTrainerID KnTrainerName KnTrainerBirth KnTrainerGender KnClubID KnTrainerID

100001 Hannes Mariz 1977 M 1 ITF

100002 Young Kawan 1967 M 2 ITF

100003 Liz Tough 1946 F 3 ITF

100004 Lollo Ingenheim 1975 F 4 ITF

100005 Kwan Do Inkuban 1934 M 5 ITF

100006 Ken Ferret 1963 M 6 WTF

100007 Claudia Schiffer 1953 F 7 WTF

100008 Mr. Pink 1966 M 8 WTF

100009 Lara Croft 1975 F 9 WTF


100011 Matthias Sammer 1963 M 10 WTF

100012 Kim Kwak 1967 M 10 WTF

100013 Kwak Kum Sik 1985 M 6 WTF


100015 Andre Agassi 1985 M 2 ITF

100016 Bruce Perrot 1945 M 2 ITF

Foreign Key

KnTrainer Table

KnClub Table

from KnClub Table

Primary Key

54

Creating the linked tables-----------------------------------------------------------------------------------------------------------------CREATE TABLE KnClub (

KnClubID INTEGER NOT NULL,KnClubName VARCHAR(30),

CONSTRAINT PKKnClub PRIMARY KEY (KnClubID));

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

CREATE TABLE KnTrainer (KnTrainerID INTEGER NOT NULL,KnTrainerName CHAR(30),KnTrainerBirth INTEGER,KnTrainerGender CHAR(1),KnClubID INTEGER NOT NULL,KnFederationName CHAR(3) NOT NULL,

CONSTRAINT PKKnTrainer PRIMARY KEY (KnTrainerID),CONSTRAINT FKKnClubID FOREIGN KEY (KnClubID) REFERENCES KnClub

ON UPDATE CASCADE,

As well as other constraints that are needed…[excluded here]);

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

55

CREATE TABLE KnFighter

( KnFighterID, KnFighterName, KnFighterBirth, KnFighterGender, KnFighterWeightclass

CONSTRAINT PKKnFighter PRIMARY KEY (KnFighterID),

CONSTRAINT ValidKnFighterGender CHECK (KnFighterGender IN ('M', 'F')),

CONSTRAINT ValidKnFighterBirth CHECK (KnFighterBirth BETWEEN 1900 AND 2007),

CONSTRAINT ValidKnFighterWeightclass CHECK (KnFighterWeightclass BETWEEN 1 AND 7),

CONSTRAINT ValidFighterID CHECK (KnFighterID LIKE '2%')

);

CHECK Statements

56

SQL Syntax for ActionsCREATE TABLE KnTraining

( KnFighterID INTEGERNOT NULL,

KnTrainerID INTEGERNOT NULL,

CONSTRAINT PKKnTraining PRIMARY KEY(KnFighterID, KnTrainerID),

CONSTRAINT FKKnFighterID FOREIGN KEY (KnFighterID) REFERENCES KnFighter

ON DELETE RESTRICT

ON UPDATE CASCADE,

CONSTRAINT FKKnTrainerID FOREIGN KEY (KnTrainerID) REFERENCES KnTrainer

ON DELETE RESTRICT

ON UPDATE CASCADE,

CONSTRAINT ValidTraining CHECK (KnFighterID <> KnTrainerID)

);

So here, a deletion of a KnFighterID entry in the KnFighter table WONT affect this table – i.e. the fighter will still be displayed in the KnTraining Table

An update to an entry in KnTrainer ID in the tabe KnTrainer, will be followed through to this table too. i..e changes made in that table are also reflected here.

Normalization

58

An example of 1st normal form

KnFighterID

KnTrainerID

KnFightername

KnFighterweightclass

KnClubID

KnTrainerName KnTrainerBirth

200006 100009 Elisabeth Brown 3 9 Lara Croft 1975

200012 100008 Chels McGyvan 4 8 Claudia Schiffer 1953

200006 100015 Elisabeth Brown 3 2 Andre Agassi 1985

200012 100009 Chels McGyvan 4 9 Lara Croft 1975

The primary key

KnFighterID KnFighterName, KnFighterGender, KnFighterWeightclass

KnTrainerID KnTrainerName, KnTrainerBirth

KnTrainerID, KnFighterID KnClubID

key

Solution: split into two or more Tables.

This is basically where redundancies and more than one primary key exist in the table

59

Solution to 1st normal form: Second Normal Form

KnFighterID KnFightername KnFighterGender KnFighterweightclass

200006 Elisabeth Brown F 3

200012 Chels McGyvan F 4

200006 Elisabeth Brown F 3

200012 Chels McGyvan F 4


200006 100009

200012 100008

200006 100015

200012 100009

KnTrainerID KnTrainerName KnTrainerBirth

100009 Lara Croft 1975

100008 Claudia Schiffer 1953

100015 Andre Agassi 1985

100009 Lara Croft 1975

The respective primary keys of each table

Different tables have been created to reduce redundancies in the table itself. Creating a table which joins the KnFighter Table to the KnTrainer table allows respective information of each table to be stored in it only.

60

An example of 2nd normal form

The primary key

KnTrainerID KnTrainerName, KnTrainerBirth

KnClubID KnClubName key

Solution: split into two or more Tables.

KnTrainerID KnTrainerName KnTrainerBirth KnClubID KnClubName

100009 Lara Croft 1975 9 Dobok-Hin-Doken

100008 Claudia Schiffer 1953 8 Korean National Team

100015 Andre Agassi 1985 2 Sydney Fight Club

100009 Lara Croft 1975 9 Dobok-Hin-Doken

Is where redundancies in the form of extra information about the foreign keys exist

61

Solution to 2nd normal form: Third Normal Form

KnClubID KnClubName

9 Dobok-Hin-Doken

8 Korean National Team

2 Sydney Fight Club

9 Dobok-Hin-Doken

The respective primary keys of each table

Leaving only the KnClubID in the KnTrainer table removes also having the names of those trainers in that table. This makes it efficient as there is only one ID to a trainer therefore removing redundant data. In other words only information strictly related to the respective table apart from the foreign keys is left.

KnTrainerID KnTrainerName KnTrainerBirth KnClubID

100009 Lara Croft 1975 9

100008 Claudia Schiffer 1953 8

100015 Andre Agassi 1985 2

100009 Lara Croft 1975 9

62

Boyce-Codd normal form (BCNF)The basic principle of BCNF is that it does not allow multiple primary keys to

exist in an entity when only one is needed to identify the relation. As this creates multiple dependencies for an entity for one relation and thus creating redundant data.

The Mattias Knect Tae Kwon Do database is in the 3NF, however since there are no functional dependencies it also complies with BCNF.

An example of where the database would not comply with BCNF is when for example:If the Training table also included KnTrainerName and KnFighterName in addition to the IDs of each and these two were also the primary keys.

Basically making it so that the primary key is related to each attributive keys

Key

63

An Example of Creating a View

CREATE VIEW fighterweight AS SELECT knFighterID, knFighterName, knFighterWeightClass FROM knFighterWHERE knFighterWeightClass >3;

64

An Example of Querying a View• Query exactly as if a

table SELECT knFighterName,

knfighterWeightClass

FROM fighterweight;

Knfightername knfighterweightclass

Karl Dall 5

Martin Knecht 5

Liz Taylor 5

Lars Augenstein 4

Lisa Mueller 4

Larry Wahnhold 4

Chin Moban 4

Chels McGyvan 4

Isidor Kraus 4

Mario Kleinschmid 4

Jana Kralle 5

Ingwan Young Kam 5

Documents

The Matthias Knecht Tae Kwon Do Case Study BHAMBRA Manjyot KOHLI Garima MANGAL Storay TAWHEED Zureen Distinction Assignment, Autumn 2007