BACHELORS OF SCIENCE IN COMPUTER SCIENCE AND
INFORMATION TECHNOLOGY
IOST, TRIBHUVAN UNIVERSITY
Chardobato, Bhaktapur
Affiliated to Tribhuvan University
Lab Report
Advanced Database
SUBMITTED BY SUBMITTED TO
NAME: Bismita Shrestha. Sumit Bidari
SYMBOL NO/ROLL NO: 24369
PROGRAM: CSIT
8th Semester
Table of Contents
Conver'ng EER model to Rela'onal Model ............................................................................. 3
Object Oriented Database Management System ..................................................................... 6
Map Reduce ............................................................................................................................ 8
Ac've Database Concept ...................................................................................................... 11
Deduc've Database Concepts ............................................................................................... 14
LAB 1
Converting EER model to Relational Model
QUESTION:
Consider the following EER.
Now, write the SQL code to convert EMPLOYEE, DEPARTMENT and PROJECT into
relational model. (Just use CREATE statement)
SOURCE QUERIES FOR EACH TABLE:
1) Employee:
CREATE TABLE EMPLOYEE (
Ssn CHAR(9) PRIMARY KEY,
Fname VARCHAR(50),
Minit CHAR(1),
Lname VARCHAR(50),
Bdate DATE,
Address VARCHAR(100),
Salary DECIMAL(10, 2),
Sex CHAR(1)
);
2) Department:
CREATE TABLE DEPARTMENT (
Number INT PRIMARY KEY,
Name VARCHAR(50),
Locations VARCHAR(100) -- Assuming a single string to store multiple
locations. Alternatively, a separate table could be used for multiple
locations.
);
3) Project:
CREATE TABLE PROJECT (
Number INT PRIMARY KEY,
Name VARCHAR(50),
Location VARCHAR(100)
);
4) Dependant:
CREATE TABLE DEPENDENT (
Dependent_Name VARCHAR(50),
Ssn CHAR(9),
Sex CHAR(1),
Birth_date DATE,
Relationship VARCHAR(25),
PRIMARY KEY (Dependent_Name, Ssn),
FOREIGN KEY (Ssn) REFERENCES EMPLOYEE(Ssn)
);
OUTPUT:
LAB 2
Object Oriented Database Management System
SOURCE CODE
from ZODB import DB, FileStorage
import transaction
from persistent import Persistent
# Define the Student class
class Student(Persistent):
def __init__(self, sid, name):
self.sid = sid
self.name = name
def __str__(self):
return f"{self.sid}, {self.name}"
# Function to create a few students
def create_few_students(root):
student1 = Student(1, "Bismita")
student2 = Student(2, "Bismita Shrestha")
root['students'] = [student1, student2]
transaction.commit()
# Function to print students
def print_students(root):
if 'students' in root:
students = root['students']
print(f"Number of students = {len(students)}\n")
for student in students:
print(student)
else:
print("No students found.")
# Set up the database
storage = FileStorage.FileStorage('student.fs')
db = DB(storage)
connection = db.open()
root = connection.root()
# Create and print students
create_few_students(root)
print_students(root)
# Close the connection
connection.close()
db.close()
OUTPUT
LAB 3
Map Reduce
QUESTION:
In the MapReduce framework, a job reads the text from a set of text files
distributed across a cluster's nodes via the distributed file system. A "mapper"
process converts the input to a set of <key, value> pairs. A "shuffle/sorter"
process sorts these pairs by their key values. A "reducer" process then combines
these sorted pairs in a way that solves a problem, and typically produces a
different set of <key, value> pairs, which is the output of the job.
Create a class MapReduce and perform all the tasks as described above for the
corpus you will be provided by the instructor.
SOURCE CODE:
class MapReduce:
def __init__(self, input_content):
self.input_content = input_content
def split_and_map(self):
# Split input content into lines and words
lines = self.input_content.split("\n")
word_pairs = []
for line in lines:
words = line.split()
for word in words:
word_pairs.append((word, 1))
return word_pairs
def shuffle_and_reduce(self, word_pairs):
# Sort pairs by word (key)
word_pairs.sort(key=lambda x: x[0])
# Reduce: combine counts for each word
result = {}
current_word = None
current_count = 0
for word, count in word_pairs:
if word == current_word:
current_count += count
else:
if current_word:
result[current_word] = current_count
current_word = word
current_count = count
if current_word:
result[current_word] = current_count
return result
if __name__ == "__main__":
input_content = """Deer Bear River
Car Car River
Deer Car Bear"""
mr = MapReduce(input_content)
word_pairs = mr.split_and_map()
word_counts = mr.shuffle_and_reduce(word_pairs)
# Print the final word counts
for word, count in word_counts.items():
print(f"{word}: {count}")
print("interpreted by Bismita Shrestha 24369")
OUTPUT:
LAB 4
Active Database Concept
QUESTION:
• Assume the following tables
Product (BarCode, PName, Price, QuantityInStock)
Sale (SaleID, DeliveryAddress, CreditCard)
SaleItem (SaleID, BarCode, Quantity)
• Create a trigger called updateAvailableQuantity that updates the quantity
in stock in the Product table, for every product sold. The trigger should be
executed after each insert operation on the SaleItem table: for the product
with the given barcode (the one inserted into SaleItem), update the
available quantity in Product table to be the old quantity minus the sold
quantity.
SOURCE QUERY:
create database s_d;
use -- Create the Product table
CREATE TABLE Product (
BarCode VARCHAR(50) PRIMARY KEY,
PName VARCHAR(100),
Price DECIMAL(10, 2),
QuanotyInStock INT
);
-- Create the Sale table
CREATE TABLE Sale (
SaleID INT PRIMARY KEY,
DeliveryAddress VARCHAR(255),
CreditCard VARCHAR(50)
);
-- Create the SaleItem table
CREATE TABLE SaleItem (
SaleID INT,
BarCode VARCHAR(50),
Quanoty INT,
FOREIGN KEY (SaleID) REFERENCES Sale(SaleID),
FOREIGN KEY (BarCode) REFERENCES Product(BarCode)
);
-- Create the trigger to update available quanoty
DELIMITER //
CREATE TRIGGER updateAvailableQuanoty
AFTER INSERT ON SaleItem
FOR EACH ROW
BEGIN
UPDATE Product
SET QuanotyInStock = QuanotyInStock - NEW.Quanoty
WHERE BarCode = NEW.BarCode;
END;
//
DELIMITER ;
-- Insert sample data into Product table
INSERT INTO Product (BarCode, PName, Price, QuanotyInStock)
VALUES ('123', 'Product1', 10.00, 100),
('124', 'Product2', 20.00, 200);
-- Insert sample data into Sale table
INSERT INTO Sale (SaleID, DeliveryAddress, CreditCard)
VALUES (1, '123 Main St', '1234-5678-9012-3456');
-- Select query to check the inioal state of Product table
SELECT * FROM Product;
-- Insert data into SaleItem table to trigger the update
INSERT INTO SaleItem (SaleID, BarCode, Quanoty)
VALUES (1, '123', 5);
-- Select query to check the state of Product table auer sale
SELECT * FROM Product;
OUTPUT:
Before >gger
A@er the update Trigger
LAB 5
Deductive Database Concepts
QUESTION:
Given the following premises find the goal using Prolog
§ Premises
o All oversmart are stupid.
o Children of stupid are naughty.
o Hari is over smart.
o Ram is children of Hari.
§ Goal
o Is Ram naughty?
SOURCE CODE:
# Facts
oversmart_people = ["hari"]
# Stupid individuals are oversmart
def is_stupid(person):
return person in oversmart_people
# Naughty individuals are stupid
def is_naughty(person):
return is_stupid(person)
# Rules
child_of = {"ram": "hari"}
# Query
def is_ram_naughty():
ram = "ram"
return is_naughty(ram)
# Check if Ram is naughty
if is_ram_naughty():
print("Ram is naughty!")
else:
print("Ram is not naughty.")
print("Interpreted / Executed by Bismita Shrestha 24369")
OUTPUT:
