MAHARASHTRA STATE BOARD TECHNICAL
EDUCATION, MUMBAI.
Designing a Normalized Database for a College
ON
Guided By
PROF: Firoz Pathan Khan
Submitted by
Raza Khan
Aymaan Madakia
Rehan Makwana
Yusuf Siddiqui
Department of Computer Engineering
JAMIA POLYTECHNIC
AKKALKUWA DIST.NANDURBAR
Akkalkuwa(425415)
ANNEXURE 2
EVALUATION SHEET FOR THE MICROPROJECT
ACADEMIC YEAR: 2023-24 NAME OF FACULTY: Firoz Pathan Khan
COURSE: DBMS
SEMESTER:3rd DEPARTMENT: COMPUTER ENGG
TITTLE OF PROJECT: Designing a Normalized Database for a College
CO’S ADDRESSED BY THE MICROPROJECT:
Roll Student Name Marks Out Marks Out Of Total Out Of
No. Of 6 4 10
(Name & Signature of faculty)
Jamia Polytechnic Akkalkuwa
CERTIFICATE
This Is To Certify That Mr./Ms. Of
Branch
Enrolment No.
Has Completed His
Micro Project Enitled
Of Subject as per
Requirment Of( Semester)
MSBTE I Scheme Curriculum Under The
Guidence Of Satisfactorily
During Academic Year 202324.
Micro project Guide Head of Dept Principal
Designing a Normalized Database for a College
Table of Contents
1. Introduction
Background
Objectives
2. Database Design for a College
Understanding the College Environment
Information to be Managed
Data Normalization
Entity-Relationship Diagram
3. Database Schema
Entities and Their Attributes
Relationships
Primary and Foreign Keys
4. Data Normalization
First Normal Form (1NF)
Second Normal Form (2NF)
Third Normal Form (3NF)
Boyce-Codd Normal Form (BCNF)
5. Creating Database Tables
SQL Statements
Table Creation and Data Insertion
6. Queries and Reports
Sample SQL Queries
Generating Student Reports
Faculty Schedules
7. Database Security and Integrity
User Access Control
Data Validation and Constraints
8. Optimizing Database Performance
Indexing
Query Optimization
Data Backup and Recovery
9. Integration with College Systems
Connecting with Attendance Systems
Library Management Integration
10. Expanding the Database for Future Needs
Adding New Functionalities
Incorporating Online Learning Systems
11. Conclusion
Summary of Achievements
Benefits of a Normalized College Database
Future Prospects and Continuous Improvement
12. References
13. Appendices
SQL Queries for Database Creation
Sample Student and Faculty Records
ER Diagram and Schema Diagram
1. Introduction
In today's digital age, educational institutions, like colleges, generate
and handle vast amounts of data. This data includes student records,
faculty information, course details, financial transactions, and much
more. To efficiently manage this information, designing a normalized
database is paramount. This micro project focuses on the design and
implementation of a normalized database for a college, covering
database schema, data normalization, SQL queries, and integrating it
with various college systems.
The ever-evolving landscape of higher education, efficient data
management is paramount. Educational institutions, particularly
colleges and universities, handle a vast array of data daily, including
student information, course details, faculty records, and
administrative data. To ensure the smooth operation of various
departments and the delivery of quality education, an organized and
optimized database system is imperative.
2. Database Design for a College
Understanding the College Environment:
Designing a database for a college requires a profound understanding
of the educational ecosystem. The database should cater to student
enrollment, faculty management, course registration, fee collection,
academic records, and many other aspects.
Information to be Managed:
The information that the database manages encompasses student
details (e.g., name, roll number, contact information), faculty records
(e.g., name, designation), course information (e.g., course code, title,
credits), financial transactions (e.g., fees, scholarships), and
attendance records, among others.
Data Normalization:
A well-designed database should follow the principles of data
normalization to minimize data redundancy and ensure data
integrity. Data normalization involves organizing data into structured
tables with minimal duplication.
Entity-Relationship Diagram:
The Entity-Relationship Diagram (ERD) provides a visual
representation of the database's structure, including entities (e.g.,
students, courses), attributes (e.g., name, roll number), and the
relationships between them (e.g., a student enrolls in courses).
3. Database Schema
Entities and Their Attributes:
The database schema defines the entities (tables) and their attributes
(columns). For example, the "Students" table includes attributes such
as "StudentID," "FirstName," "LastName," and "DateOfBirth."
Relationships:
Relationships between tables are established through keys. For
instance, the "Courses" table might relate to the "Students" table
through a "StudentID" foreign key.
Primary and Foreign Keys:
To maintain data integrity, primary keys uniquely identify each
record, while foreign keys establish relationships with other tables.
4. Data Normalization
Data normalization involves organizing data into different forms, each
with specific rules, to ensure minimal redundancy and efficient data
manipulation.
First Normal Form (1NF):
In 1NF, tables have distinct rows, and each column contains only
atomic values.
Second Normal Form (2NF):
2NF ensures that there is no partial dependency on the primary key.
All non-key attributes should depend on the entire primary key.
Third Normal Form (3NF):
3NF further eliminates transitive dependencies, ensuring that non-
key attributes depend only on the primary key.
Boyce-Codd Normal Form (BCNF):
BCNF is the highest level of normalization, dealing with situations
where there can be multiple candidate keys in a table.
5. Creating Database Tables
Creating a complete program for designing a normalized database for
a college is beyond the scope of a single response. However, I can
provide you with an outline of the steps and an example SQL code
snippet for creating a "Students" table to get you started.
Outline of Steps for Building a College Database:
Define the requirements and objectives of the college database.
Identify the entities, attributes, and relationships.
Design the Entity-Relationship Diagram (ERD).
Normalize the data to 3NF or BCNF.
Create the database schema and tables using SQL.
Implement database constraints, such as primary keys and foreign
keys.
Develop SQL queries for data retrieval and manipulation.
Implement security measures.
Optimize database performance.
Integrate with other college systems.
Here's an example SQL code snippet for creating a "Students" table:
sqlCopy code
CREATE TABLE Students ( StudentID INT PRIMARY KEY, FirstName
VARCHAR(50) NOT NULL, LastName VARCHAR(50) NOT NULL,
DateOfBirth DATE, Email VARCHAR(100), Phone VARCHAR(15),
Address VARCHAR(255) );
In this example, we create a "Students" table with the following
attributes:
StudentID: A unique identifier for each student.
FirstName and LastName: Student's first and last names.
DateOfBirth: Student's date of birth.
Email: Student's email address (optional).
Phone: Student's contact number (optional).
Address: Student's residential address (optional).
You would repeat similar steps to create tables for other entities,
such as "Courses," "Faculty," and "Enrollments," and establish
relationships between them using foreign keys. Additionally, you
would develop SQL queries to insert, update, and retrieve data.
Keep in mind that the actual database design and implementation
can be quite complex, and you may need to use a database
management system like MySQL, PostgreSQL, or Oracle to execute
these SQL commands.
If you have specific questions or need further assistance with a
particular aspect of the database design or SQL queries, please let
me know, and I'd be happy to provide more guidance.
```sql
CREATE TABLE Students (
StudentID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
DateOfBirth DATE
);
```
PROGRAM
Designing a normalized database for a college involves creating a
structured system for managing various aspects of the educational
institution, including students, courses, faculty, and more. Below,
you'll find SQL code to design and create the essential tables for
such a database.
```sql
-- Create a database for the college
CREATE DATABASE CollegeDB;
USE CollegeDB;
-- Create a table to store student information
CREATE TABLE Students (
StudentID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
DateOfBirth DATE,
Gender VARCHAR(10),
Address VARCHAR(100),
PhoneNumber VARCHAR(15)
);
-- Create a table to store course information
CREATE TABLE Courses (
CourseID INT PRIMARY KEY,
CourseName VARCHAR(100),
Department VARCHAR(50),
Credits INT,
InstructorID INT,
FOREIGN KEY (InstructorID) REFERENCES Faculty(FacultyID)
);
-- Create a table to store faculty information
CREATE TABLE Faculty (
FacultyID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
DateOfBirth DATE,
Gender VARCHAR(10),
Department VARCHAR(50),
Position VARCHAR(50),
PhoneNumber VARCHAR(15)
);
-- Create a table to store student-course enrollments
CREATE TABLE Enrollments (
EnrollmentID INT PRIMARY KEY,
StudentID INT,
CourseID INT,
EnrollmentDate DATE,
FOREIGN KEY (StudentID) REFERENCES Students(StudentID),
FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);
-- Create a table to store administrative staff information
CREATE TABLE Staff (
StaffID INT PRIMARY KEY,
FirstName VARCHAR(50),
LastName VARCHAR(50),
DateOfBirth DATE,
Gender VARCHAR(10),
Department VARCHAR(50),
Position VARCHAR(50),
PhoneNumber VARCHAR(15)
);
-- Create a table to store events and activities
CREATE TABLE Events (
EventID INT PRIMARY KEY,
EventName VARCHAR(100),
EventDate DATE,
Organizer VARCHAR(50)
);
-- Create a table to store event registrations
CREATE TABLE EventRegistrations (
RegistrationID INT PRIMARY KEY,
StudentID INT,
EventID INT,
RegistrationDate DATE,
FOREIGN KEY (StudentID) REFERENCES Students(StudentID),
FOREIGN KEY (EventID) REFERENCES Events(EventID)
);
```
In this SQL code:
- We create a database called `CollegeDB` and specify that we will
use it.
- We create tables to store information about students, courses,
faculty, enrollments, administrative staff, events, and event
registrations. These tables are structured with primary keys and
foreign keys to establish relationships between entities.
- Each table includes fields relevant to the type of information being
stored, such as student names, course details, faculty information,
and more.
This is a simplified database design for a college, and you can
expand it further based on your specific requirements. The use of
primary and foreign keys helps maintain data integrity, and
normalization techniques can be applied to reduce data redundancy
and improve database efficiency.
You can also create additional tables, views, and stored procedures
as needed to support various functionalities within the college
database, such as grading systems, library management, and
financial transactions.
6. Queries and Reports
SQL queries are used to retrieve and manipulate data within the
database. Sample queries include selecting all students or courses.
Reports can be generated for student profiles or faculty schedules.
7. Database Security and Integrity
Security measures, such as user access control, ensure that only
authorized individuals can access and modify the database. Data
validation and constraints maintain data accuracy.
8. Optimizing Database Performance
To enhance performance, indexing is employed, and queries are
optimized. Data backup and recovery mechanisms are put in place to
prevent data loss.
9. Integration with College Systems
The college database can be integrated with attendance systems,
ensuring real-time attendance tracking. It can also be linked with the
library management system to manage book records and checkouts
efficiently.
10. Expanding the Database for Future Needs
The database can be expanded by adding new functionalities, such as
integrating online learning systems, enabling remote learning, and
monitoring student progress.
11. Conclusion
In conclusion, the process of designing a normalized database for a
college is a critical step in the efficient management and organization
of data related to students, courses, faculty, staff, and various
activities within the institution. The structure of the database we
have created is just the foundation for a robust information system
that can support a wide range of administrative and educational
functions.
By breaking down the database into different tables, each with
specific attributes and relationships, we establish a well-structured
system that minimizes data redundancy and ensures data integrity.
This design approach adheres to the principles of database
normalization, which help maintain consistency and reliability of the
data.
The Students table holds information about the student body,
including their personal details, contact information, and a unique
StudentID to serve as a primary key. The Courses table manages
course-related information, with references to the Faculty table
through the InstructorID. Faculty details are stored in a dedicated
Faculty table. Enrollments capture the associations between students
and courses, while Staff and Events tables cater to administrative
staff details and event management, respectively.
This database design allows for effective data retrieval, modification,
and analysis, enabling the college to streamline operations such as
