CREATE TABLE <table-name>
( <attr-name1> <datatype>[(<size>],
<attr-name2> <datatype>[(<size>],
-- ---,
<attr-nameN> <datatype>[(<size>]
);
eg.
CREATE TABLE employee
( empID CHAR,
empName VARCHAR2(50),
empAge INTEGER,
empSalary DECIMAL(10,2)
);
DESCRIBE <table-name>;
eg. DESCRIBE employee;
INSERT COMMAND:
Syntax:
INSERT INTO <table-name>
VALUES ( <val1>, <val2>, --- <valN>);
INSERT INTO <table-name> (<attribute-list>)
VALUES ( <val1>, <val2>, --- <valN>);
eg.
INSERT INTO employee
VALUES ( 'E1', 'Ram', 21, 10000);
INSERT INTO employee (empName, empID, empSalary, empAge)
VALUES ( 'ajay', 'E5', 8000, 23);
INSERT INTO employee (empID, empAge)
VALUES ( 'E6', 25)
INSERT INTO EMPLOYEE11 (empname, empid)
VALUES('Vikas', 'E11')
SELECT COMMAND:
Syntax:
SELECT <attr-name1>, <attr-name2>, --- <attr-nameN> FROM <table-name>
[WHERE <condition>]
[ORDER BY <attr-name1>];
SELECT * FROM <table-name>;
eg.
SELECT * FROM employee;
SELECT empName, empID, empSalary FROM employee;
SELECT * FROM employee
WHERE empAge > 20;
SELECT * FROM employee
WHERE empAge > 20
ORDER BY empName ASC, empID DESC;
SELECT * FROM employee
WHERE (NOT ((empAge > 21) AND (empSalary > 8000)));
BETWEEN---AND OPERATOR
For range of values
lower and upper values are inclusive
SELECT * FROM employee
WHERE empSalary NOT BETWEEN 9000 AND 12000;
IN OPERATOR
For list of values
SELECT * FROM employee
WHERE empID NOT IN ('E1', 'E3', E5');
DISTINCT Keyword:
SELECT DISTINCT firstName FROM employee1;
ALL Keyword:
SELECT ALL firstName FROM employee1;
IS NULL operator
SELECT * FROM employee
WHERE empName IS NULL;
IS NOT NULL operator
SELECT * FROM employee
WHERE empName IS NOT NULL;
CREATING A TABLE FROM ANOTHER TABLE:
CREATE TABLE <target-table>
AS SELECT <col-list> FROM <source-table>
[WHERE <condition>];
eg.
CREATE TABLE newEmployee1
AS SELECT * FROM employee;
CREATE TABLE newEmployee2
AS SELECT * FROM employee WHERE empSalary > 10000;
DELETE COMMAND:
Syntax:
DELETE FROM <table-name>
[ WHERE <cond> ];
eg1.
DELETE FROM employee;
DELETE FROM employee
WHERE empSalary > 15000;
UPDATE COMMAND:
UPDATE <table-name>
SET <attr-name1> = <val-1>,
<attr-name2> = <val-2>
... ...
<attr-nameN> = <val-N>
[WHERE <condition>];
EG.
UPDATE employee
SET empSalary = empSalary+1000;
UPDATE employee
SET empSalary = empSalary+1000
WHERE empID IN ('E1', 'E5', 'E7');
UPDATE employee
SET empSalary = empSalary+1000,
empAge = 15
WHERE empID IN ('E1', 'E5', 'E7');
COLUMN LEVEL
SYNTAX:
CREATE TABLE <table-name>
(
<attr-name1> <datatype> <col-constraint>,
<attr-name2> <datatype> <col-constraint>,
-- --- ---,
<attr-nameN> <datatype> <col-constraint>
);
1. NOT NULL
2. PRIMARY KEY
3. UNIQUE
CREATE TABLE employee
(
empID VARCHAR(10) PRIMARY KEY,
empName VARCHAR2(50) NOT NULL UNIQUE,
empAge INTEGER ,
empSalary DECIMAL(10,2)
);
4. CHECK
CREATE TABLE employee1
(
empID VARCHAR(10) PRIMARY KEY,
empName VARCHAR2(50) NOT NULL UNIQUE,
empAge INTEGER CHECK (empAge <=60),
empSalary DECIMAL(10,2)
);
5. DEFAULT
CREATE TABLE employee2
(
empID VARCHAR(10) PRIMARY KEY,
empName VARCHAR2(50) DEFAULT 'RAM',
empAge INTEGER CHECK (empAge <=60),
empSalary DECIMAL(10,2)
);
CREATE TABLE <table-name>
(
<attr-name1> <datatype> CONSTRAINT <constraint-name1> <constraint-type>,
<attr-name2> <datatype> CONSTRAINT <constraint-name2> <constraint-type>,
-- --- -- -- ---,
<attr-nameN> <datatype> CONSTRAINT <constraint-nameN> <constraint-type>
);
CREATE TABLE employee
(
empID VARCHAR(10) CONSTRAINT pk_empID_employee PRIMARY KEY,
empName VARCHAR2(50) CONSTRAINT nn_empName_employee NOT NULL,
empCity varchar(20) CONSTRAINT un_empCity_employee UNIQUE,
empAge INTEGER CHECK (empAge <=60),
empSalary DECIMAL(10,2)
);
TO see the listing of all constraints:
SELECT * FROM USER_CONSTRAINTS;
SELECT TABLE_NAME, CONSTRAINT_NAME FROM USER_CONSTRAINTS;
SELECT TABLE_NAME, CONSTRAINT_NAME FROM USER_CONSTRAINTS
WHERE TABLE_NAME = 'EMPLOYEE';
CREATE TABLE employee1
(
empID VARCHAR(10) PRIMARY KEY,
empName VARCHAR2(50) ,
empAge INTEGER ,
empSalary DECIMAL(10,2),
empDept VARCHAR2(10) CONSTRAINT fk_empDept_employee1 REFERENCES
department1(deptID)
);
CREATE TABLE department1
(
deptID VARCHAR(10) CONSTRAINT pk_deptID_department1 PRIMARY KEY,
deptName VARCHAR2(50),
deptBudget DECIMAL(10,2)
);
ALTER TABLE <table-name>
ADD (<column-definiton1>, <column-definiton2>,
----
<column-definitonN>
);
ALTER TABLE employee2
ADD empSalary DECIMAL(10,2);
ALTER TABLE employee2
ADD (empSample3 VARCHAR2(10));
ALTER TABLE <table-name>
DROP COLUMN (<col1>, <col2>, ...);
ALTER TABLE employee2
DROP COLUMN empSample3;
ALTER TABLE <table-name>
MODIFY (<modification>); #TO DO MODIFICATION
ALTER TABLE employee2
MODIFY (empName VARCHAR(100)); #TO MODIFY COLUMN SIZE
ALTER TABLE <table-name>
RENAME COLUMN <oldname> TO <newname>; #TO RENAME A COLUMN
ALTER TABLE employee2
RENAME COLUMN empName TO empName1;
ALTER TABLE <table-name>
ADD <constraint-definition>; # TO ADD CONSTRAINT TO COLUMN
ALTER TABLE employee2
ADD UNIQUE (empName1);
ALTER TABLE employee2
ADD CONSTRAINT ch_empAge_employee2 CHECK (empAge <= 60);
AGGREGATE FUNCTIONS:
* USED FOR SUMMRIZATION
SUM(); AVG(); MIN();
MAX() ; COUNT(); COUNT(*)
SELECT COUNT(*) FROM EMPLOYEE11;
SELECT SUM(empSalary), AVG(empSalary),
MAX(empAge), MIN(empAge) FROM employee12; #aggregate functions(attribute name)
WILD CARD CHARACTERS:
_ 1 CHARACTER
% 0 OR MORE CHARACTERS
SELECT * FROM EMPLOYEE12
WHERE EMPNAME LIKE '_A%';
TABLE LEVEL CONSTRAINTS:
CREATE TABLE <table-name>
(
<attr-name1> <datatype>,
<attr-name2> <datatype>,
-- --- ,
<attr-nameN> <datatype>,
<constraint-type1>,
<constraint-type2>,
-- --,
<constraint-typeN>,
);
CREATE TABLE employee31
(
empFirstName VARCHAR2(50),
empLastNameAge VARCHAR2(50),
empSalary DECIMAL(10,2),
empAge INTEGER,
empDept VARCHAR2(10),
PRIMARY KEY (empFirstName, empLastNameAge),
CHECK (empSalary > 5000)
);
CREATE TABLE employee32
(
empFirstName VARCHAR2(50),
empLastNameAge VARCHAR2(50),
empSalary DECIMAL(10,2),
empAge INTEGER,
empDept VARCHAR2(10),
CONSTRAINT pk_fsName_employee32 PRIMARY KEY (empFirstName, empLastNameAge),
CONSTRAINT ch_empSalary_employee32 CHECK (empSalary > 5000)
);
# Not necessary to give CONSTRAINT <CONTRAINT NAME> <CONSTAINT TYPE> (CONTRAINT
NAME can b e any) you can simply type CONSTRAINT ie PRIMARY KEY(Attribute names>)
FOR EXAMPLE
CREATE TABLE employee33
(
empID VARCHAR2(5),
empFirstName1 VARCHAR2(50),
empLastNameAge1 VARCHAR2(50),
empSalary DECIMAL(10,2),
empAge INTEGER,
empDept VARCHAR2(10),
PRIMARY KEY (empID),
CONSTRAINT fk_fsName_employee33 FOREIGN KEY (empFirstName1, empLastNameAge1)
REFERENCES employee32(empFirstName,empLastNameAge)
);
GROUP BY CLAUSE
* TO MAKE GROUPING WITHIN A TABLE.
SELECT <column-list> FROM TABLE
GROUP BY <col1>, <col2>,......
HAVING <condition>
CREATE TABLE employee35
(
empID VARCHAR(10) ,
empName VARCHAR2(50) ,
empAge INTEGER,
empSalary DECIMAL(12,2),
empDesignation VARCHAR(20),
empDept VARCHAR(10)
);
SELECT empDesignation, SUM(empSalary), COUNT(*)
FROM employee35
GROUP BY empDesignation
HAVING COUNT(*) > 1;
#extracting sum of salaries according to designation(if the designation occurs more
than once then it should be sumed up) and displayed as in front of each designation
one by one
SELECT empDesignation, empDept, SUM(empSalary), COUNT(*)
FROM employee35
GROUP BY empDesignation, empDept;
#showing sum of salaries according to the designations mentioning their departments
as well and also their count
DATE DATA TYPE
* Stores date as well as time;
SELECT SYSDATE FROM DUAL;
CREATE TABLE employee38
(
empName VARCHAR2(50),
empDOB DATE
);
INSERT INTO employee38
VALUES('RAM', SYSDATE);
* TO_CHAR()
* TO_DATE()
TO_CHAR(<date>, <format>); # We define the format of date as our choice(used
with SELECT statement to extract the already existing date in the system acc to
format wanted)
SELECT empName, TO_CHAR(empDOB, 'yyyy-mm-dd')
FROM employee38;
MM Numeric Month (e.g. 08)
MON Abbreviated month name (e.g. AUG)
MONTH Full month name (e.g. AUGUST)
DD Day of month (e.g. 15)
DY Abbreviated name of day (e.g. FRI)
YYYY 4-DIGIT YEAR (e.g. 2023)
YY 2-DIGIT YEAR (e.g. 23)
AM(or PM) Meridian Indicator
HH HOUR OF DAY (1-12)
HH24 HOUR OF DAY (0-23)
MI MINUTE (0-59)
SS SECOND (0-59)
SELECT empName, TO_CHAR(empDOB, 'yy/month/dy -- HH24:MI:SSAM')
FROM employee38;
TO_DATE(<string>, <format>) #Insert karte time hi date ka format bata dena
INSERT INTO employee38
VALUES('RAMA', TO_DATE('2023-07-10', 'YYYY-MM-DD'));
SELECT empName, TO_CHAR(empDOB, 'DD-MM-YY -- HH24:MI:SSAM')
FROM employee38;
INSERT INTO employee38
VALUES('SHYAM', TO_DATE('2023-JUL-10 10:15:20', 'YYYY-MON-DD HH:MI:SSAM'));
SET OPERATIONS
CREATE TABLE emp35
(
empID VARCHAR(10) ,
empName VARCHAR2(50) ,
empAge INTEGER
);
CREATE TABLE emp36
(
empID1 VARCHAR(10) ,
empName1 VARCHAR2(50) ,
empAge1 INTEGER
);
UNION:
SELECT * FROM emp35
UNION
SELECT * FROM emp36;
SELECT empID FROM emp35
UNION
SELECT empName1 FROM emp36;
INTERSECT:
SELECT * FROM emp35
INTERSECT
SELECT * FROM emp36;
SELECT empName FROM emp35
INTERSECT
SELECT empName1 FROM emp36;
MINUS OPERATION
SELECT empName FROM emp35
MINUS
SELECT empName1 FROM emp36;
NESTING OF QUERIES (CONCEPT OF SUBQUEREIES)
* A query can contain another query.
* Nesting can go up to n-levels.
* The result of the inner query work as an
input to the outer query.
CREATE TABLE department1
(
deptID VARCHAR(10) CONSTRAINT pk_deptID_department1 PRIMARY KEY,
deptName VARCHAR2(50),
deptBudget DECIMAL(10,2)
);
CREATE TABLE employee1
(
empID VARCHAR(10) PRIMARY KEY,
empName VARCHAR2(50) ,
empAge INTEGER ,
empSalary DECIMAL(10,2),
empDept VARCHAR2(10) CONSTRAINT fk_empDept_employee1 REFERENCES
department1(deptID)
);
select * from employee1
where empDept =
(select deptID from department1
where deptname = 'hr');
I EXISTS operator
select * from department1
where exists (select empdept from employee1);
select * from department1
where not exists (select empdept from employee1);
select * from department1
where exists
(select empdept from employee1
where empDept = 'd2' );
select * from department1
where not exists
(select empdept from employee1
where empDept = 'd2' );
II ANY OR SOME
select * from employee1
where empSalary > ANY
(select deptBudget from department1 );
III ALL
Select * from employee1
where empSalary > ALL
(select deptBudget from department1 );
IV IN OPERATOR
SELECT * FROM department1
WHERE deptID IN
( SELECT empDept FROM employee1);
SELECT * FROM employee1
WHERE empSalary >
(SELECT AVG(deptBudget) FROM department1 );
Select empDept, SUM(empSalary) from employee1
GROUP BY empDept
HAVING empDept IN
(select deptID from department1 );
JOINS
* JOINS ARE USED TO JOIN TWO OR MORE TABLES.
* BY USING JOINS WE CAN RETRIEVE THE DATA FROM MULTIPLE TABLES.
CROSS JOIN
* EVERY TUPLE OF THE FIRST RELATION IS COMBINED WITH EVERY TUPLE OF THE
SECOND RELATION.
* NO NEED TO BE HAVING COMMON ATTRIBUTE(S)
* RESULT WILL CONTAIN THE TOTAL NO. OF ATTRIBUTES = ATTR(R1) + ATTR(R2)
TOTAL NO. OF TUPLES = TUPLES(R1) * TUPLES(R2)
* COMMON ATTRIBUTES WILL BE DUPLICATED IN THE RESULT.
SELECT * FROM
suppliers CROSS JOIN items;
OR
SELECT * FROM
suppliers, items;
SELECT itemID, itemName, suppID, suppCity FROM
suppliers CROSS JOIN items;
OR
SELECT itemID, itemName, suppID, suppCity FROM
suppliers, items;
SELECT i.itemID, i.itemName, s.suppID, s.suppCity FROM
suppliers s, items i;
II NATURAL JOIN
* IT IS A REFINEMENT OF CROSS JOIN.
* FOR NATURAL JOIN THERE MUST BE COMMON ATTRIBUTE(S) IN THE TABLES TO BE
JOINED.
* ONLY THOSE ROWS HAVING THE SAME VALUES FOR THE COMMON ATTRIBUTE(S)
WILL BE DISPLAYED.
* COMMON ATTRIBUTE(S) WILL NOT BE DISPLAYED IN A DUPLICATED MANNER.
SELECT itemID, suppID FROM
items NATURAL JOIN suppliers;
OR
SELECT itemID, suppID FROM
items, shipments
WHERE items.itemID = shipments.itemID;
III INNER JOIN
* ONLY THOSE RECORDS WILL BE DISPLAYED FROM BOTH THE TABLES;
SATISFYING THE SPECIFIED CONDITION.
SELECT * FROM items INNER JOIN shipments
ON items.itemID = shipments.itemID
SELECT i.itemID, s.suppID, s.quantity FROM items i INNER JOIN shipments s
ON items.itemID = shipments.itemID;
or
SELECT itemID, suppID FROM
items, shipments
WHERE items.itemID = shipments.itemID;
IV OUTER JOIN
* ONLY THOSE RECORDS WILL BE DISPLAYED FROM BOTH THE TABLES;
SATISFYING THE SPECIFIED CONDITION.
(a) LEFT OUTER JOIN:
* RECORDS SATISFYING THE CONDITION + RECORDS FROM THE LEFT TABLE WHICH
ARE NOT SATISFYING THE CONDITION
SELECT i.itemID, s.suppID, s.quantity FROM items i LEFT OUTER JOIN shipments
s
ON i.itemID = s.itemID;
(b) RIGHT OUTER JOIN:
* RECORDS SATISFYING THE CONDITION + RECORDS FROM THE RIGHT TABLE WHICH
ARE NOT SATISFYING THE CONDITION
SELECT i.itemID, s.suppID, s.quantity FROM shipments s RIGHT OUTER JOIN items
i
ON i.itemID = s.itemID;
(c) FULL OUTER JOIN:
* RECORDS SATISFYING THE CONDITION + RECORDS FROM THE LEFT TABLE WHICH
ARE NOT SATISFYING THE CONDITION + + RECORDS FROM THE RIGHT TABLE WHICH
ARE NOT SATISFYING THE CONDITION
SELECT i.itemID, s.suppID, s.quantity FROM shipments s FULL OUTER JOIN items
i
ON i.itemID = s.itemID;
V SELF JOIN
* A TABLE IS JOINED WITH ITSELF.
SELECT i1.itemID, i1.itemName, i2.itemID
FROM items i1, items i2
WHERE i1.itemID <> i2.itemID;
CREATE TABLE employee21
(
empID VARCHAR(10) PRIMARY KEY,
empName VARCHAR2(50) ,
deptID INTEGER REFERENCES department21(deptID) ON DELETE CASCADE
); #ON DELETE CASCADE is used to specify that when a row is deleted from the
parent table, all rows in the child table that reference the deleted row should
also be deleted
VIEWS
* IT IS A VIRTUAL TABLE.
* IT IS DERIVED FROM OTHER TABLES (I.E. BASE TABLES) OR OTHER VIEWS.
* DYNAMIC
* UPDATION IS POSSIBLE THROUGH VIEWS.
* NO JOIN
* NO AGGREGATE FUNCTION
SYNTAX
CREATE VIEW <view-name> [(<column-list>)]
AS SELECT <column-list> FROM <base-table-name>
[ WHERE <condition>];
CREATE VIEW employee21View
AS SELECT * FROM employee21;
CREATE VIEW employee21View1 (vempID, vempName)
AS SELECT empID, empName FROM employee21
WHERE deptID=101;
INSERT INTO employee21View
VALUES('E5', 'HARI', 102);
DELETE FROM employee21View
WHERE EMPNAME = 'HARI';
EXTRACT:
EXTRACT(part FROM date);
SELECT EXTRACT(DAY FROM SYSDATE) FROM DUAL;
