EXPERIMENT NO 1 A
Aim of the experiment :- To construct ER Model for Real life problems.
Conclusion: Successfully constructed EER Model for Real life problems
EXPERIMENT NO 1 B
Aim of the experiment :- To construct EER Model for Real life problems.
Conclusion: Successfully constructed EER Model for Real life problems
EXPERIMENT NO: 2 (A)
Aim of the experiment :- To study and implement commands under Data
Definition
CREATE-
CREATE TABLE mn (
id int,
name varchar(100),
address varchar(100),
city varchar(100)
);
OUTPUT-
INSERT-
insert into mn values(1,'SHUBHAM','kopri','thane');
OUTPUT-
SELECT-
select * from mn;
OUTPUT-
ALTER:
(a)ALTER TABLE ...ADD...:
alter table mn add (email varchar(40));
OUTPUT–
(b)ALTER TABLE...MODIFY...:
alter table mn modify(email char(50));
OUTPUT–
c)ALTER TABLE..RENAME...:
alter table mn rename column address to location;
OUTPUT-
d)ALTER TABLE..DROP...:
alter table mn drop column email;
OUTPUT–
DESCRIBE–
describe mn;
OUTPUT–
RENAME–
rename mn to op;
OUTPUT–
TRUNCATE-
truncate table op;
OUTPUT–
DROP TABLE–
Conclusion: Successfully studied and implemented commands under Data Definition
Language and Implemented different types of constraints in sql.
EXPERIMENT NO :2(B)
AIM: To study and implement commands under Data Manipulation Language.
CREATE :
CREATE TABLE mn (
id int,
name varchar(100),
address varchar(100),
city varchar(100)
);
OUTPUT :
Data Manipulation Language:
a) Insert :
insert into mn values(1,'SHUBHAM','kopri','thane');
insert into mn values(2,'Nitesh','Majiwada','thane');
insert into mn values(3,'Ayush','kalyan','gaav');
insert into mn values(4,'Faiz','mumbra','hingoli');
select*from mn
OUTPUT :
b) Update :UPDATE mn SET address = 'Ghodbunder' WHERE id = 2;
Output:
c) Delete : DELETE FROM mn WHERE name = 'Nitesh’;
Output:
d)Select: SELECT * FROM mn;
Output :
Conclusion: Successfully studied and implemented sql commands under Data
Manipulation language
EXPERIMENT NO: 3
AIM: To study and implement Set Operations, string function and operators.
SET OPERATORS
CODE:
create table d(
id int,
name varchar(100)
);
OUTPUT:
CODE: insert into d values(1,'abhi');
OUTPUT :
CODE : insert into d values(2,'cheester');
OUTPUT :
CODE : select * from d;
OUTPUT–
CODE :
create table e(
id int,
name varchar(100)
);
OUTPUT :
CODE : insert into e values(3,'raj');
OUTPUT :
CODE : insert into e values(2,'cheester');
OUTPUT :
CODE : select * from e;
OUTPUT :
MINUS : select * from e minus select * from d;
OUTPUT :
UNION : select * from e UNION select * from d;
OUTPUT :
UNION ALL : select * from e union all select * from d;
OUTPUT :
INTERSECT : select * from e intersect select * from d;
OUTPUT :
OPERATORS
CODE :
create table employee (
empid int,
empname varchar(100),
email varchar(100),
address varchar(100)
);
OUTPUT :
CODE: insert into employee values(1,'sai','abc','mumbai');
insert into employee values(2,'nitesh','def','thane');
insert into employee values(3,'kartik','ghi','pune');
insert into employee values(4,'yash','jkl','thane');
insert into employee values(5,'abhi','xyz','mumbai');
OUTPUT:
CODE : select * from employee;
COMPARISON OPERATORS
EQUAL OPERATOR : select * from employee where empid = 4;
OUTPUT :
NOT OPERATOR : select * from employee where empid != 2;
OUTPUT :
NOT EQUAL TO OPERATOR : select * from employee where empid <> 3;
OUTPUT :
GREATER THAN OR EQUAL TO OPERATOR : select * from employee where empid >= 2;
OUTPUT :
LESS THAN OR EQUAL TO OPERATOR : select * from employee where empid <= 3;
OUTPUT:
LOGICAL OPERATORS
AND OPERATOR : select * from employee where empid = 1 and address='mumbai' ;
OUTPUT :
OR OPERATOR : select * from employee where empid = 1 or address='mumbai';
OUTPUT :
NOT OPERATOR : select * from employee where not empid = 1;
OUTPUT :
SPECIAL OPERATORS
BETWEEN OPERATOR : select * from employee where empid between 1 and 3;
OUTPUT :
NOT BETWEEN OPERATOR :select * from employee where empid not between 1 and 3;
OUTPUT :
IS NULL OPERATOR : select empid,address from employee where address is null;
OUTPUT :
IS NOT NULL : select empid,address from employee where address is not null;
OUTPUT :
ALL :
select * from employee where empid > all (select empid from employee where empid = 2);
OUTPUT:
IN : select * from employee where empid in (1,2,4);
OUTPUT:
ANY:
select * from employee where empid > any (select empid from employee where empid = 1);
OUTPUT :
EXISTS :
select * from employee where exists (select * from employee where empid >= 2);
OUTPUT :
LIKE OPERATORS
CODE- Create the Table and Insert Data
create table employee1(
empid int,
empname varchar(100),
custname varchar(100),
contact int,
address varchar(100)
);
insert into employee1 values(1,'ram','nitesh',123,'thane');
insert into employee1 values(2,'ramm','faiz',456,'pune');
insert into employee1 values(3,'rram','vinit',789,'mumbai');
insert into employee1 values(4,'shyam','prathmesh',012,'gujrat');
insert into employee1 values(5,'shhyam','soham',345,'kalva');
insert into employee1 values(6,'gita','shubham',678,'kalyan');
select * from employee1;
OUTPUT :
LIKE : 1. select * from employee1 where empname like 'r%';
OUTPUT :
2. select * from employee1 where empname like '%m';
OUTPUT :
3. select * from employee1 where empname like '%h%';
OUTPUT :
4 . select * from employee1 where empname like 'r_m';
OUTPUT :
5. select * from employee1 where empname like 'r_m_';
OUTPUT :
6. select * from employee1 where empname like 'r%' or empname like 's%';
OUTPUT :
select * from employee1 where empname like 'r%m';
OUTPUT :
Conclusion: Successfully implemented Set Operations, string function and operators.
EXPERIMENT NO: 4(A)
Aim of the experiment :- To implement Join Queries
Create the Table 1 and Insert Data :
create table suppliers(
supplierid int,
suppliername varchar(100)
);
insert into suppliers values(10000,'ibm');
insert into suppliers values(10001,'hp');
insert into suppliers values(10002,'microsoft');
insert into suppliers values(10003,'google');
select * from suppliers;
OUTPUT :
Create the Table 2 and Insert Data
create table orders(
orderid int,
supplierid int,
orderdate int
);
insert into orders values(500125,10000,200305);
insert into orders values(500126,10001,200313);
insert into orders values(500127,10004,200314);
select * from orders;
OUTPUT :
INNER JOIN OPERATION :
SELECT * FROM suppliers s INNER JOIN orders o ON s.supplierid = o.supplierid;
OUTPUT :
LEFT JOIN OPERATION :
SELECT *FROM suppliers s LEFT JOIN orders o ON s.supplierid = o.supplierid;
OUTPUT :
RIGHT JOIN OPERATION :
SELECT *FROM suppliers s RIGHT JOIN orders o ON s.supplierid = o.supplierid;
OUTPUT :
FULL OUTER JOIN OPERATION :
SELECT * FROM suppliers s
FULL OUTER JOIN
orders o ON s.supplierid = o.supplierid;
OUTPUT :
Conclusion: Successfully implemented Join Queries.
EXPERIMENT NO – 4(B)
Aim of the experiment :- To Implement Basic and Nested complex SQL queries.
CREATE TABLE student (StudentID Varchar(10),Name char(20));
CREATE TABLE marks (StudentID Varchar(10),Total_marks number(20));
INSERT INTO student VALUES('V001','Abe');
INSERT INTO student VALUES('V002','Abhay');
INSERT INTO student VALUES('V003','Acelin');
INSERT INTO student VALUES('V004','Adelphos');
INSERT INTO marks VALUES ('V001',95);
INSERT INTO marks VALUES ('V002',80);
INSERT INTO marks VALUES ('V003',74);
INSERT INTO marks VALUES ('V004',81);
SELECT a.studentid, a.name, b.total_marks
FROM student a, marks b
WHERE a.studentid = b.studentid AND b.total_marks >
(SELECT total_marks
FROM marks
WHERE studentid = 'V002');
OUTPUT :
Conclusion: Successfully Implemented Nested & Complex Queries
EXPERIMENT NO: 5
Aim of the experiment :- Implementation of different types of Aggregation Functions,
Group by, Order by & Having Clause.
Create the Table and Insert Data
create table student(
name varchar(100),
subject varchar(100),
marks int
);
insert into student values('nitesh','hindi',78);
insert into student values('vinit','marathi',45);
insert into student values('faiz','java',99);
insert into student values('soham','sql',57);
insert into student values('rohit','sql',68);
select * from student;
OUTPUT :
COUNT OPERATION : 1. select count(subject) from student where subject = 'sql';
OUTPUT :
2. select count(subject) from student;
OUTPUT :
MIN OPERATION : select min(marks) from student;
OUTPUT :
MAX OPERATION : select max(marks) from student;
OUTPUT :
AVERAGE OPERATION : select avg(marks) from student;
OUTPUT :
GROUP BY CLAUSE :
SELECT subject, AVG(marks) AS average_marks FROM student GROUP BY subject;
OUTPUT :
ORDER BY CLAUSE : SELECT * FROM student ORDER BY marks DESC;
OUTPUT :
HAVING CLAUSE :
SELECT subject, AVG(marks) AS average_marks FROM student GROUP BY subject
HAVING AVG(marks) > 60;
OUTPUT :
Conclusion:
Successfully Implemented different types of Aggregation Functions,
Group by, Order by & Having Clause.
EXPERIMENT NO : 6
Aim of the experiment :- To Study & Implements The View & Trigger
Create the Table and Insert Data
create table customer18 (
id int,
name varchar(90),
age int,
address varchar(90),
salary varchar(90));
);
insert into customer18 values(1,'ramesh',32,'amehdabad',200);
insert into customer18 values(2,'khilan',25,'delhi',1500);
insert into customer18 values(3,'kaushikh',23,'kota',2000);
insert into customer18 values(4,'chaitali',25,'mumbai',6500);
insert into customer18 values(5,'hardik',27,'bhopal',8500);
insert into customer18 values(6,'komal',22,'hyderabad',4500);
select * from customer18;
OUTPUT :
VIEW OPERATION : create view customer18v as select name, age from customer18;
OUTPUT :
select * from customer18v;
UPDATE VIEW : update customer18 set age=19 where name='ramesh';
OUTPUT :
DELETE FROM VIEW : delete from customer18v where age=22;
OUTPUT :
CREATE A TRIGGER :
CREATE OR REPLACE TRIGGER display_salary_changes
BEFORE DELETE OR INSERT OR UPDATE ON customer18
FOR EACH ROW
WHEN (NEW.ID > 0)
DECLARE
sal_diff number;
BEGIN
sal_diff :=:NEW.salary - :OLD.salary;
dbms_output.put_line('OLD salary: '|| :OLD.salary);
dbms_output.put_line('NEW salary: '|| :NEW.salary);
dbms_output.put_line('Salary difference: ' || sal_diff);
END;
OUTPUT :
TRIGGERING A TRIGGER :
INSERT INTO customer18 VALUES (9,'kritiI',226,'HP',7500.00);
OUTPUT :
UPDATE customer18 SET salary = salary + 500 WHERE ID = 2;
OUTPUT :
Conclusion: Successfully Studied and Implemented View & Trigger.
EXPERIMENT NO – 7(A)
Aim of the experiment :- To implement Database Connectivity
JDBC Connection
Conclusion: Successfully Implemented
EXPERIMENT NO – 7(B)
Aim of the experiment :- To demonstrate cursor
Create the Table and Insert Data
create table cust18 (
id int,
name varchar(90),
age int,
address varchar(90),
salary varchar(90));
insert into cust18 values(1,'ramesh',32,'amehdabad',200);
insert into cust18 values(2,'khilan',25,'delhi',1500);
insert into cust18 values(3,'kaushikh',23,'kota',2000);
insert into cust18 values(4,'chaitali',25,'mumbai',6500);
insert into cust18 values(5,'hardik',27,'bhopal',8500);
insert into cust18 values(6,'komal',22,'hyderabad',4500);
select * from cust18;
OUTPUT :
IMPLICIT :
DECLARE total_rows number;
BEGIN UPDATE cust18 SET salary =salary + 1500;
total_rows := SQL%ROWCOUNT;
dbms_output.put_line(total_rows || ' rows updated.');
END;
OUTPUT :
EXPLICIT :
DECLARE
cid cust18.id%type;
cname cust18.name%type;
caddr cust18.address%type;
CURSOR c_cust18 is
SELECT id, name, address FROM cust18;
BEGIN
OPEN c_cust18;
LOOP
FETCH c_cust18 into cid, cname, caddr;
EXIT WHEN c_cust18%notfound;
dbms_output.put_line(cid || ' ' || cname || ' ' || caddr);
END LOOP;
CLOSE c_cust18;
END;
OUTPUT :
Conclusion: Successfully Demonstrated Cursor
EXPERIMENT NO – 8
Aim of the experiment :- To Study & implement TCL & DCL commands
-- Create the table
CREATE TABLE class (
id NUMBER(10),
name CHAR(13)
);
INSERT INTO class VALUES (1, 'Abhi');
INSERT INTO class VALUES (2, 'Adam');
INSERT INTO class VALUES (4, 'Alex');
INSERT INTO class VALUES (5, 'Rahul');
COMMIT;
UPDATE class SET name = 'Abhijit' WHERE id = 5;
ROLLBACK;
UPDATE class SET name = 'Abh' WHERE id = 5;
SAVEPOINT A;
COMMIT;
Conclusion: Successfully studied and Implemented TCL and DCL commands
EXPERIMENT NO: 9
AIM: Implement functions and procedures in SQL.
Create the Table and Insert Data
create table client (
id int,
name varchar(90),
age int,
address varchar(90),
salary varchar(90));
insert into client values(1,'ramesh',32,'amehdabad',2000);
insert into client values(2,'khilan',25,'delhi',1500);
insert into client values(3,'kaushikh',23,'kota',2000);
insert into client values(4,'chaitali',25,'mumbai',6500);
insert into client values(5,'hardik',27,'bhopal',8500);
insert into client values(6,'komal',22,'hyderabad',4500);
select * from client;
OUTPUT :
FUNCTION :
CREATE OR REPLACE FUNCTION totalcostumers RETURN number IS total number(2) := 0;
BEGIN
SELECT count(*) into total
FROM client;
RETURN total;
END;
OUTPUT :
DECLARE c number(2);
BEGIN
c := totalcostumers();
dbms_output.put_line('Total no. of Customers: ' || c);
END;
/
OUTPUT :
Conclusion: Successfully Implemented procedures & functions concepts.
EXPERIMENT NO – 10
Aim of the experiment: - Install oracle SQL developer tool and perform various
operations on a populated database.
Conclusion: Successfully Install oracle SQL developer tool and performed various
operations on a populated database
