CPS 352 Database Systems Design Project

Purpose: 

To give you experience with designing and implementing a database to model a real domain
Due: Various milestones due as shown in the syllabus

Requirements

This project is deliberately open-ended. It consists of the following three milestones. 

1. Choose a domain that you are familiar with and/or interested in. Identify a set of requirements for a fictitious software system pertinent to this domain. 

If you wish, you may choose an appropriate subset of a larger domain, but your domain must not be those we are using as examples in class specifically the university (from the Database Systems Concepts book) and the library (from lectures) domains. See the “Choosing an Appropriate Domain” discussion below for further guidance. 

2. Develop an E-R diagram for a database that models your domain. 
3. Turn your E-R diagram into a normalized relational database design for the domain that is, a set of tables, each with pertinent attributes, a primary key, and appropriate constraints and foreign keys.

 Your relational database must be in fourth normal form. Implement your design as follows:
a. Create a file of SQL create statements to build your database schema. These statements should not only facilitate the creation of tables, but also creation of named constraints, triggers, and/or views as appropriate. 
b. Create your database under your username as a schema in the design database on the server. (You won’t actually create the database itself, just the tables and other objects within its schema.)
c. Populate your database with sample data to facilitate testing of the schema and the various transactions supported by your hypothetical software system. Each table must contain a minimum of five rows.
 d. Create SQL select, insert, update, and delete statements that correspond to the functionality of your software system’s requirements. 
e. Thoroughly test your SQL statements and constraints using your sample data. Your tests should not only exercise the expected behavior for “good” data, but they should also ensure that your constraints correctly catch various kinds of invalid insert, update, and delete operations caused by “bad” data. 

Note that the comprehensiveness of your tests will be a factor in your grade for this part of the project.

Milestones

Your project will be submitted in three separate milestones. After turning in a milestone, you have the option to modify your approach and/or design for the remainder of the project as necessary based on feedback you receive. If you choose to do this, you do not need to redo the previous milestone(s) unless you totally change your project domain. 

Once your final milestone is turned in, your project will be graded based on all three milestones together, but with special emphasis given to the third one.

 2 On the due date of each of milestone, you will present your work orally to your classmates. For the first milestone, we will also spend time as a class discussing the next part of the project  e.g. what might be appropriate entities and relationships for modeling your domain. We may also have a similar, but briefer, class discussion when second milestones are presented. To facilitate oral presentation and discussion, you should prepare appropriate material for projection and/or handouts.

Specific Milestone Requirements 

You will need to turn in the following for each milestone:
         

         Milestone I Domain and System Requirements 

• A description of the problem domain (written using terminology that a user of the system would use, not technical database terminology). 
• A statement of requirements. This should take the form of an overall use case diagram, with explanation in “requirements language” as needed.

Milestone II - E-R Diagram

• An E-R diagram for your database, including attributes for entities and relationships.
Milestone III

Relational Database Design, Implementation, Sample Data, and Tests

• A list of the functional and multi-valued dependencies for your scheme. 

• A schema diagram for your database, with primary and foreign keys specified appropriately. 

• A file containing working SQL statements to create the objects in your database. 

• A file containing working SQL statements corresponding to each of your requirements. (If your requirements call for more than a dozen or so statements, you can do a subset.) Your SQL statements should require a variety of SQL capabilities, such as various kinds of join, aggregate functions, etc. (This presupposes a good initial domain choice.)

• Documentation of testing 

• You must exercise each of your SQL statements. Your testing should be related to your original requirements - that is, you should include tests that address each of the original requirements (or a subset if there are many). 

• You must also exercise each of your triggers.

 • You must also exercise each of your constraints, being sure it correctly catches errors while allowing legitimate data. (Note: you do not need to test not null constraints.)

 • You must turn in one or more files containing the results of these tests. Be sure to include (SQL) comments in these files indicating the requirement each test is exercising, and the expected result. (i.e. good data or a specific problem you are catching with bad data). Email your work for each milestone to the professor by its due date listed in the course syllabus. Be sure to bring appropriate print-outs of your work to class on the due date to facilitate class discussion. 

An Example :

Note that this example is much simpler than what you will do for the actual project; it is only meant to illustrate the various milestone requirements.

Milestone 1 Suppose you chose a subset of the university organization domain, as used for examples in the Database
Systems Concepts book. (As noted above, you can’t actually choose this domain.) Section 1.6.2 on pages 16- 17 of the book describes this system. In addition, you would need to spell out the requirements, perhaps by using a use case diagram like the one below. (Many possible cases are omitted, including those involved in managing departments, buildings, and classroom space, as well as managing the college catalog and historical information; this diagram is for illustration purposes only.) Since the nature of each requirement is clear from the use case name, no further specification is needed.
A set of descriptions like the one in section 1.6.2 in the book plus the use case diagram below is what you
might turn in for Milestone 1.

Milestone II

Your design might be based on an E-R diagram like figure 7.15 on page 282 of the Database System
Concepts book.
A diagram like the one in figure 7.15 in the book is what you should turn in for Milestone II.

Milestone III

a. The following functional and multivalued dependencies hold on the E-R diagram. (The names of ID attributes have been modified to indicate more explicitly the tables to which they belong.)
course_id → title, credits, dept_name
dept_name → building, budget
instructor_id → name, salary, dept_name
student_id → name, tot_cred, dept_name, instructor_id (advisor)
section_id, semester, year, course_id → building, room_number, time_slot_id
building, room_number → capacity
time_slot_id → day, start_time, end_time
student_id, section_id, semester, years, course_id → grade
course_id ->> course_id (prereq)
instructor_id ->> section_id, semester, year, course_id
section_id, semester, year, course_id ->> instructor_id
student_id ->> section_id, semester, year, course_id
section_id, semester, year, course_id ->> student_id b. A database schema based on these dependencies might look like figure 2.8 on page 47 of the Database
System Concepts book. No tables are needed corresponding to the relationships course_dept,
inst_dept, stud_dept, sec_class, sec_time_slot in the E-R diagram. These relationships are folded into the course, instructor, student and section tables because each relationship is one-to-many with total participation required. There is no table corresponding to sec_course because section is a weak entity dependent on course, so its primary key is needed in the table for section. 

c. This database could be created with SQL statements like those in Figure 4.8 on page 132 of the Database
System Concepts book (though more are needed to create the complete schema). 
• Notice how appropriate primary key, foreign key and check constraints have been specified. 
• Notice how cascading delete and update can be specified for course. (See page 133.) 
• Triggers might be used as shown in Figures 5.8 (page 182) and 5.9 (page 183).
• Note that DB2 automatically creates indexes for each primary key, but on other systems it might be necessary to explicitly do so. 

However, it might be desirable to create an index on name for student if we expect to frequently have to do name lookups. 
• A view could be created to allow each student to look at his/her course enrollments. 5 d. This example does not include test data for all requirements and constraint. The tests below are given to illustrate the point.
The following SQL statements test the primary key and foreign key constraints on student 

(assuming that the CS department was already created).
insert into student (student_id, name, dept_name, tot_cred)
values (12345, 'Anthony Aardvark', 'CS', 0);
insert into student (student_id, name, dept_name, tot_cred)
values (12345, 'Zelda Zebra', 'CS', 0); (fails PK)
insert into student (student_id, name, dept_name, tot_cred)
values (98765, 'No such', 'ZZ', 0); (fails FK) 

Documentation for this test would consist of a screen shot or "cut-and-paste" command line output showing DB2 accepting the first insert and giving an error message for each of the two invalid inserts, along with suitable comments. The trigger shown in figure 5.9 of the Database Systems Concepts book could be tested with the following SQL statement (assuming the appropriate student and section records already exist):
update takes
set grade = 'A'

where student_id = 12345 and course_id = 'CPS352' and sec_id = 'GS'
and semester = 'SP' and year = '2010'; This would result in an increase of 4 in the tot_cred attribute for student 12345. Documentation for this test would consist of a screen shot showing two select statements, with the update statement between them.
Something that looks like all of the above is what you should submit for Milestone III.

Choosing an Appropriate Domain

The domain (or subset of a domain) that you choose for your project should have the following characteristics: 
1. An appropriately sized domain will result in a database having about a dozen tables (more or less). 
2. The entities comprising your domain should be interrelated. 
3. Your schema should include attributes that make it possible to include some transactions that involve aggregate functions. (For example, the schema developed above would allow for queries to calculate the enrollment in each section, the average enrollment in courses for a given department, the total number of courses being taught by each instructor, etc.). Your schema should also make interesting constraints and triggers possible.

Important:

 Keep the requirements of all milestones in mind when selecting your domain. You want a domain that will lend itself to interesting requirements and tests, as well as a suitable E-R diagram, schema, and set of dependencies.