Scribd
Upload
23 views8 pages

T01 L05 1a

The document describes a task to create a SQL database to store movie information. The student designed tables to store data on movies, actors, directors, ratings and reviews. SQL queries were written to insert, update, retrieve and manipulate movie data. Some challenges encountered were data validation, complex queries, consistency during updates and optimizing performance for large datasets.

Uploaded by

nazmussadiq
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
23 views8 pages

T01 L05 1a

The document describes a task to create a SQL database to store movie information. The student designed tables to store data on movies, actors, directors, ratings and reviews. SQL queries were written to insert, update, retrieve and manipulate movie data. Some challenges encountered were data validation, complex queries, consistency during updates and optimizing performance for large datasets.

Uploaded by

nazmussadiq
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

Lab 5

Advanced Data Manipulation

CSE 4308

DATABASE MANAGEMENT SYSTEMS LAB

SUBMITTED BY: MD. NAZMUS SADIQ


STUDENT ID: 210041139
SECTION: 1(A) CSE
### Task Description
The task was to create a SQL database and write SQL queries for managing a collection of movies. The
database should be capable of storing information about movies, including their titles, release years,
genres, directors, and ratings. Additionally, we needed to implement SQL queries to perform various
operations on the movie data, such as adding new movies, updating movie details, and retrieving
specific movie information.

### Solution Approach

#### Database Schema


I dropped following tables to avoid duplicate tables.

DROP TABLE RATING CASCADE CONSTRAINTS;


DROP TABLE DIRECTION CASCADE CONSTRAINTS;
DROP TABLE CASTS CASCADE CONSTRAINTS;
DROP TABLE MOVIE CASCADE CONSTRAINTS;
DROP TABLE REVIEWER CASCADE CONSTRAINTS;
DROP TABLE DIRECTOR CASCADE CONSTRAINTS;
DROP TABLE ACTOR CASCADE CONSTRAINTS;

To solve this task, I designed a relational database schema with the following tables:

CREATE TABLE ACTOR


(
ACT_ID NUMBER,
ACT_FIRSTNAME VARCHAR2(20),
ACT_LASTNAME VARCHAR2(20),
ACT_GENDER VARCHAR2(1),
CONSTRAINT PK_ACTOR PRIMARY KEY(ACT_ID)
);
CREATE TABLE DIRECTOR
(
DIR_ID NUMBER,
DIR_FIRSTNAME VARCHAR2(20),
DIR_LASTNAME VARCHAR2(20),
CONSTRAINT PK_DIRECTOR PRIMARY KEY(DIR_ID)
);

CREATE TABLE REVIEWER


(
REV_ID NUMBER,
REV_NAME VARCHAR2(30),
CONSTRAINT PK_REVIEWER PRIMARY KEY(REV_ID)
);

CREATE TABLE MOVIE


(
MOV_ID NUMBER,
MOV_TITLE VARCHAR2(50),
MOV_YEAR NUMBER,
MOV_TIME NUMBER,
MOV_LANGUAGE VARCHAR2(30),
MOV_RELEASEDATE DATE,
MOV_COUNTRY VARCHAR2(30),
CONSTRAINT PK_MOVIE PRIMARY KEY(MOV_ID)
);

CREATE TABLE CASTS


(
ACT_ID NUMBER,
MOV_ID NUMBER,
ROLE VARCHAR2(30),
CONSTRAINT PK_CASTS PRIMARY KEY(ACT_ID, MOV_ID),
CONSTRAINT FK_CASTS_ACTOR FOREIGN KEY(ACT_ID) REFERENCES ACTOR(ACT_ID),
CONSTRAINT FK_CASTS_MOVIE FOREIGN KEY(MOV_ID) REFERENCES MOVIE(MOV_ID)
);

CREATE TABLE DIRECTION


(
DIR_ID NUMBER,
MOV_ID NUMBER,
CONSTRAINT PK_DIRECTIONS PRIMARY KEY(DIR_ID, MOV_ID),
CONSTRAINT FK_DIRECTION_DIRECTOR FOREIGN KEY(DIR_ID) REFERENCES
DIRECTOR(DIR_ID),
CONSTRAINT FK_DIRECTION_MOVIE FOREIGN KEY(MOV_ID) REFERENCES MOVIE(MOV_ID)
);

CREATE TABLE RATING


(
MOV_ID NUMBER,
REV_ID NUMBER,
REV_STARS NUMBER,
CONSTRAINT PK_RATING PRIMARY KEY(MOV_ID, REV_ID),
CONSTRAINT FK_RATING_MOVIE FOREIGN KEY(MOV_ID) REFERENCES MOVIE(MOV_ID),
CONSTRAINT FK_RATING_REVIEWER FOREIGN KEY(REV_ID) REFERENCES REVIEWER(REV_ID)
);

#### SQL Commands

A. **Inserting a New entry in tables**

INSERT INTO DIRECTOR VALUES(201, 'Alfred', 'Hitchcock');


INSERT INTO ACTOR VALUES(106, 'Harrison' , 'Ford' , 'M');
INSERT INTO MOVIE VALUES(912 , 'Princess Mononoke', 1997, 134,'Japanese',
TO_DATE('2001-10-19', 'YYYY-MM-DD'), 'UK');
INSERT INTO REVIEWER VALUES(9002, 'Jack Malvern');

B. **Queries**
The queries were following:

1. Find the actresses with the same first name.

2. Find the movie titles that did not receive any ratings.

3. Show the count of movies that got released in each month along with the month.

4. Find the months between the release date of the first movie and the last movie directed by

‘James Cameron’.

5. Find the reviewer who gives the highest number of lowest rev_star.

6. Show the movie title and its average rating for each of the movies (if there is no rating then it
will show 0 in that place).

7. Show all the mov_id and mov_title with suffix (’old gold’ if the mov_year is less than 1980,

’trendy 90’s’ if the movie was from 1980 to 2000, and ’weird 20’s’ if the movie was from after

2000).

8. Find all the movies and the names of actors who acted in the movies and directors of movies

(no matter whether the name of the actor or director exists or not).

Their solutions are as follows:

SELECT A1.ACT_FIRSTNAME, A1.ACT_LASTNAME FROM ACTOR A1 JOIN ACTOR A2 ON


A1.ACT_FIRSTNAME=A2.ACT_FIRSTNAME
WHERE A1.ACT_GENDER='F' AND A2.ACT_GENDER = 'F' AND A1.ACT_ID != A2.ACT_ID;

SELECT M1.MOV_TITLE FROM MOVIE M1 LEFT JOIN RATING R1 ON M1.MOV_ID=R1.MOV_ID


WHERE R1.REV_STARS IS NULL;

SELECT TO_CHAR(MOV_RELEASEDATE,'MM') AS MONTH, COUNT(*) AS NUM_OF_MOVIES


FROM MOVIE GROUP BY TO_CHAR(MOV_RELEASEDATE,'MM') ORDER BY MONTH;

SELECT (MONTHS_BETWEEN(MIN(MOV_RELEASEDATE),MAX(MOV_RELEASEDATE))) AS
MONTHS_DIFFERENCE
FROM DIRECTOR D,MOVIE M,DIRECTION DN WHERE D.DIR_ID=DN.DIR_ID
AND M.MOV_ID=DN.MOV_ID AND D.DIR_FIRSTNAME='James' AND D.DIR_LASTNAME='Cameron';

WITH LowestRating AS (
SELECT MOV_ID, MIN(REV_STARS) AS LowestRating
FROM RATING
GROUP BY MOV_ID
)

SELECT REV_ID, COUNT(*) AS CountLowestRating


FROM RATING
WHERE (MOV_ID, REV_STARS) IN (
SELECT MOV_ID, LowestRating
FROM LowestRating
)
SELECT REV_ID, MinStars
FROM (
SELECT REV_ID, MIN(REV_STARS) AS MinStars
FROM RATING
GROUP BY REV_ID
ORDER BY MinStars
) WHERE ROWNUM = 1;

SELECT M.MOV_TITLE, NVL(AVG(R.REV_STARS), 0) AS Average_Rating


FROM MOVIE M
LEFT JOIN RATING R ON M.MOV_ID = R.MOV_ID
GROUP BY M.MOV_TITLE ORDER BY Average_Rating DESC;

SELECT MOV_ID,
MOV_TITLE,
CASE
WHEN MOV_YEAR < 1980 THEN ' (old gold)'
WHEN MOV_YEAR > 1980 AND MOV_YEAR<2000 THEN ' (trendy 90s)'
WHEN MOV_YEAR > 2000 THEN ' (weird 20s)'
ELSE ''
END AS MOVIE_TITLE_WITH_SUFFIX
FROM MOVIE;

SELECT M.MOV_TITLE AS MOVIE, A.ACT_FIRSTNAME || ' ' || A.ACT_LASTNAME AS ACTOR,


D.DIR_FIRSTNAME || ' ' || D.DIR_LASTNAME AS DIRECTOR
FROM MOVIE M
LEFT JOIN CASTS C ON M.MOV_ID = C.MOV_ID
LEFT JOIN ACTOR A ON C.ACT_ID = A.ACT_ID
LEFT JOIN DIRECTION R ON M.MOV_ID = R.MOV_ID
LEFT JOIN DIRECTOR D ON R.DIR_ID = D.DIR_ID;

C. ** Creating a new table named Rating_directed_movie **


9. Create a new Rating_directed_movie table using a similar structure to the Rating table.

CREATE TABLE Rating_directed_movie


(
MOV_ID NUMBER,
DIR_ID NUMBER,
REV_ID NUMBER,
REV_STARS NUMBER,
CONSTRAINT PK_rd_movie PRIMARY KEY(MOV_ID, DIR_ID, REV_ID),
CONSTRAINT FK_rd_movie FOREIGN KEY(MOV_ID) REFERENCES MOVIE(MOV_ID),
CONSTRAINT FK_rd_director FOREIGN KEY(DIR_ID) REFERENCES DIRECTOR(DIR_ID),
CONSTRAINT FK_rd_reviewer FOREIGN KEY(REV_ID) REFERENCES REVIEWER(REV_ID)
);

D. **Continuing my queries**
10. In the Rating_directed_movie table insert only the rating of those movies that have director

information available.

11. Add a new column Status in Rating_directed_movie table of varchar2(10) type.

12. For each rating if it is greater than the overall rating average+2 then set the Status ’Better’, if

less than the overall rating average-2 then set the Status ’Bad’ else ’So So’

Solution of these are as follows:

INSERT INTO Rating_directed_movie (MOV_ID, DIR_ID, REV_ID, REV_STARS)


SELECT R.MOV_ID, D.DIR_ID, R.REV_ID, R.REV_STARS
FROM RATING R
INNER JOIN MOVIE M ON R.MOV_ID = M.MOV_ID
INNER JOIN DIRECTION D ON R.MOV_ID = D.MOV_ID;

ALTER TABLE Rating_directed_movie


ADD Status VARCHAR2(10);

UPDATE Rating_directed_movie
SET Status = CASE
WHEN REV_STARS > (SELECT AVG(REV_STARS) FROM Rating_directed_movie) + 2 THEN
'Better'
WHEN REV_STARS < (SELECT AVG(REV_STARS) FROM Rating_directed_movie) - 2 THEN
'Bad'
ELSE 'So So'
END;

5. Finally I commit so that the changes I made are saved.

COMMIT;
### Problems Faced

While completing the SQL task, I encountered a few challenges:

1. **Data Validation**: Ensuring data integrity and validation for input data to prevent incorrect or
invalid data from being added to the database.

2. **Query Complexity**: Designing SQL queries that efficiently retrieve and manipulate data from the
database while handling various search and update scenarios.

3. **Data Consistency**: Ensuring that data remains consistent and accurate, especially when
performing updates or deletions.

4. **Performance**: Optimizing the database schema and queries for improved performance, especially
when dealing with a large number of movie records.

5. **Security**: Implementing proper security measures to protect the database from unauthorized
access or SQL injection attacks.

Overall, these challenges were addressed through careful design of the database schema, validation
checks in the application layer, and by writing efficient SQL queries.

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy