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;