General information
In the project, you will have to design and develop a relational database for an imaginary user. You can choose the topic yourself, for example sales database, sports database, music database, or anything you want. The database should be operateable with Python console that demonstrates five different database queries, one update, one insert and one visualization. Project is individual work. If there are any questions, contact the teacher or teacher assistant.
Parts of the project:
- Theoretical, design documentation.
- Design (description of the topic and limitations; ER-model)
- Transformation to a relational model (and integrity constraints)
- Description of the program
- Practical implementation with SQLite and Python
- Video demonstration of the Python interface
Theoretical part:
Use the given report template. The template has the recommended structure and some examples for the content. The template should work with Word and OpenOffice.
Structure of the document
- Introduction
- ER model and transformation to relational model
- Database implementation. First create the SQLite database and then the required parts with Python. Design where you should use indices to speed up queries.
- Discussion, reflection and conclusion.
Design requirements:
- ER model should have at least 6 entities and the database should have at least as many tables. Relational model can be larger (because of M:N transformation) but not smaller.
- ER-model should have at least one M:N relationship
- Design part needs to have an ER model as well as a relational model
- Define minimum and maximum cardinalities and integrity constraints
- At least five different queries or views need to be developed for the database. The queries/views need to provide useful information for the imagined end user. Two JOIN-clauses need to be used in at least one query (M:N-relationship) (query = SELECT query)
- Design the use of indices and provide justification for them
- There should not be any data structures that go against relational model
Practical part
In the practical part, you have to do a SQLite-database (an actual .sqlite file, not a sequence of SQL commands) and an interactive Python user interface that demonstrates one aspect of the database functionalities. For example, sports-database could print the information of old matches and then ask if you want to update an old score or add a new match result. The whole database is not required to be usable through the Python user interface. It is enough that you do a linear program that demonstrates five queries, one update, one insert and one visualization (done with bokeh-library). More information regarding bokeh-library is in the Python topic and assignment. Bokeh-visualization could be a bar chart for example.
Requirements of the practical part
- Database can be tested and used through SQLite and Python user interface
- Python program demonstrates how to read data, update existing or insert new data. Additionally, one visualization demonstration
- Python program has at least 5 queries, 1 insert, 1 update and 1 bokeh-visualization
- Database implements integrity constraints with CASCADE and similar commands
- Database has indices that are reasonable
Returnables for the practical part
- Python program
- SQLite database that is used by the Python program
- Separate text file that includes the necessary SQL commands to create tables for the database
- Preferably the HTML file created by bokeh (if generated)
Video demonstration
The video demonstration is to show the functionality of the Python interface. You should show all the functionalities of your Python interface (the queries you have implemented and the results). No need to show the document, database, source code, nor anything else than the Python interface. The video length will probably be less than 2 minutes and no audio is required.
Instructions for returning the project
The project should be returned to the correct Moodle activity.
The returnables include:
- Report in PDF format (Theoretical part)
- SQL commands required for creating the designed database that can be executed using SQLite .read -command as well as the SELECT-queries (Practial part - database)
- Python implementation that includes the SQLite database as well as the user interface that accesses the database (Practical part - Python)
Returnable file structure
- One compressed (ZIP or TAR) file that includes all the material for the project.
- The compressed file includes ONE FOLDER. If you want to be anonymous during peer-review, remove all identifying information from the files. The folder includes the following:
- Report.pdf
- SQL queries.sql (textfile that includes all necesasry commands for creating SQLite database and can be run with SQLite .read-command)
- Subfolder that is called "PythonDBProgram." The folder includes all files that are necessary to run the Python program and preferably the bokeh HTML file. Remember to add a ready-made SQLite database to the folder so that the program can be immediately tested. The built database can include test data.
Evaluation criteria
In general, if the project fulfills all the requirements given above on an adequate level, you will receive maximum points from the project. The following things are emphasized in the evaluation:
- ER-model, understanding how they work and demonstrating your understanding
- Reasonable model of the real world situation
- Transforming a conceptual model to a relational database
- Understanding relationships (1:1, 1:N, M:N) and cardinalities and demonstrating your understanding
- SQL database design based on a model
- Integrity constraints, primary- and foreign keys
- Demonstrating M:N relationship on theoretical and practical level
- Flawless Python program that demonstrates the usage of a database (the program is expected to be simple and run without crashes)
- Participating or not participating in peer-review
Peer-review does not directly determine the grade of the project and it is only a verbal review. However, a good peer-review or not doing the peer-review will affect the grade of the reviewer.
Possible problem areas in the project
- Problems in the modeling and using wrong models in the wrong phases
- Not having cardinalities in the model
- Not using integrity constraints (CASCADE, CHECK, etc.)
- Not using M:N relationship (or missing the query demonstrating it)
- Python program crashes during runtime
- Missing the SQL commands for creating the tables or they do not work when using .read-command