Cygnus Technologies Material

The Oracle Database
Oracle is a relational database. In a relational database, all data is stored in two-dimensional

tables that are composed of rows and columns. The Oracle Database enables you to store
data, update it, and efficiently retrieve it.
Oracle provides software to create and manage the Oracle database. The database consists of
physical and logical structures in which system, user, and control information is stored. The
software that manages the database is called the Oracle database server. Collectively, the
software that runs oracle and the physical database are called the Oracle database system.
You will learn more about the operation of the database server and the structure of the Oracle
database where they are relevant to the performance of specific database management tasks.
ORACLE 10g RDBMS CONSISTS OF 2 PROGRAMMING LANGUAGES\
1. ORACLE SQL (SEQUEL)

2. ORACLE PL/SQL (PROCEDURAL LANGUAGE STRUCTURED QUERY LANGUAGE)
ORACLE SQL IS A 4th GENERATION LANGUAGE, IN A 4GL WE ONLY NEED TO SPECIFY

TO THE SYSTEM WHAT TASK IS TO BE COMPLETED WE NEED NOT SPECIFY HOW THAT TASK
MUST BE COMPLETED.ANY 4GL IS VERY SIMPLE TO USE AND THE COMMANDS ARE LIKE
SIMPLE ENGLISH WORDS. ALL RDBMS SOFTWARES WILL SUPPORT SOME FORM OF SQL. SQL
WAS ORGINALLY DEVELOPED BY IBM AS OF TODAY ALL DATABASES HAVE THEIR OWN VER
OF SQL BASED ON THE IBM SQL. IN CASE OF ORACLE DATABASE THE SQL COMPILER WILL
BE A PART OF THE ORACLE DATABASE INSTALLATION. USING ORACLE SQL THE ORACLE
DATABASE PROGRAMMER CAN PERFORM SEVERAL TASKS ON THE DATABASE LIKE
1. ADDING DATA
2. VIEWING DATA
3. DELETING DATA
4. UPDATING DATA
SQL IS FURTHER DIVIDED INTO A SET OF SUB LANGUAGES THEY ARE
1. DATA DEFINITION LANGUAGE (DDL)

2. DATA MANIPULATION LANGUAGE (DML)
3. DATA CONTROL LANGUAGE (DCL)
4. TRANSACTION CONTROL LANGUAGE (TCL)
5. DATA QUERY LANGUAGE (DQL)
DATA DEFINITION LANGUAGE
1. CREATE
2. DROP
3. ALTER
4. RENAME
5. TRUNCATE
6. PURGE
7. FLASHBACK
DATA MANIPULATION LANGUAGE
1. INSERT
2. UPDATE
3. DELETE
4. MERGE
5. INSERT ALL
DATA CONTROL LANGUAGE
1. GRANT
2. REVOKE
TRANSACTION CONTROL LANGUAGE
1. COMMIT
2. ROLLBACK
3. SAVEPOINT
DATA QUERY LANGUAGE
1. SELECT
ONCE ORACLE HAS BEEN INSTALLED ON SERVER WE CAN CREATE A NUMBER OF

DATABASES USING ORACLE SOFTWARE. EACH DATABASE WILL BE IDENTIFIED BY A GLOBAL
DATABASE NAME OR SID (SYSTEM ID). WHILE CONNECTING TO ANY DATABASE WE NEED
TO SPECIFY THE GLOBAL DATABASE NAME FOR THAT DATABASE TO WHICH WE WISH TO
CONNECT.
ONCE A DATABASE HAS BEEN CREATED A PROGRAMMER CAN RUN SQL AND PL/SQL
PROGRAMS FOR THAT DATABASE. FOR THE PROGRAMMER TO INTERACT WITH THAT
DATABASE HE IS PROVIDED WITH A TOOL KNOWN AS ORACLE SQL*PLUS. SQL PLUS ACTS
LIKE A WINDOW TO THE DATABASE FOR THE PROGRAMMER, SQL PLUS WILL PROVIDE THE
PROGRAMMER WITH A COMMAND PROMPT WHERE HE CAN TYPE SQL AND PL/SQL
PROGRAMS AND SEND THOSE PROGRAMS TO THE ORACLE DATABASE SERVER FOR
PROCCESSING OR COMPILATION. FOR SQL STATEMENTS THE SQL COMPILER IS USED AND
FOR PL/SQL STATEMENTS THE PL/SQL COMPILER IS USED. THE SQL COMPILER AND PL/SQL
COMPILER WILL BE ON THE ORACLE DATABASE SERVER. THE SQL COMPILER IS KNOWN AS
THE SQL ENGINE, AND THE PL/SQL COMPILER IS KNOWN AS THE PL/SQL ENGINE
WHEN A DATABASE IS CREATED A SET OF DEFAULT USERS ARE CREATED FOR THAT
DATABASE.
1. SYS (SYSDBA SUPERUSER)

2. SYSTEM/MANAGER (DBA USER)
3. SCOTT/TIGER (NORMAL USER NOT AVAILABLE IN 9i/10g BY DEFAULT)
4. DEMO/DEMO (NORMAL USER) (NOT AVAIABLE IN 8i/9i BY DEFAULT)
THE TECHNICAL TERM USED FOR ORACLE USER IS SCHEMA
A SCHEMA IS COLLECTION OF DATABASE OBJECTS. WHEN WE INSTALL ORACLE AND

CREATE A DATABASE CERTAIN DEFAULT SCHEMA'S ARE CREATED. EVERY SCHEMA IS
IDENTIFIED BY A USERNAME AND PROTECTED BY A PASSWORD. IN A SINGLE ORACLE
DATABASE WE CAN CREATE ANY NUMBER OF SCHEMA’S. WHEN WE CONNECT TO A
PARTICULAR SCHEMA WE WILL ONLY VIEW THAT DATA, WHICH HAS BEEN CREATED WITHIN
THAT SCHEMA, WE WILL NOT SEE INFORMATION, WHICH IS IN OTHER SCHEMA'S.
EVERY SQL COMMAND AND PL/SQL COMMAND WILL END WITH A ; (SEMI COLON). THIS ; IS
KNOWN AS THE SQL TERMINATOR IT WILL SPECIFY TO SQL PLUS WHERE THE COMMAND
HAS ENDED. ALL CONTENTS OF THE COMMAND BEFORE THE SEMI COLON WILL BE SENT TO
THE ORACLE SERVER FOR PROCCESSING.
SQL*PLUS IS A TOOL THAT IS INSTALLED ON A WINDOWS CLIENT TO ACCESS AND ORACLE

DATABASE ON A REMOTE SERVER. SQL*PLUS WILL ACT AS A WINDOW FOR THE
PROGRAMMER TO THE ORACLE DATABASE.
THE PROGRAMMER AND CODE SQL AND PL/SQL COMMAND AT THE SQL*PLUS SQL PROMPT
AND SUBMIT THOSE COMMANDS TO THE ORACLE DATABASE FOR COMPILATION. SQL*PLUS
WILL ONLY PERFORM SYNTAX CHECK TO THE COMMANDS BEFORE SENDING THEM TO THE
DATABASE FOR PROCCESSING.
SQLPLUS IS A PART OF ORACLE CLIENT SIDE INSTALLATION.

IT WILL ALSO GET INSTALLED ON THE SERVER ITSELF WHEN WE GO FOR THE ORACLE
SERVER INSTALLATION.
SQLPLUS HAS ITS OWN SET OF COMMANDS KNOWN AS SQL*PLUS COMMANDS USING
THESE COMMANDS WE CAN PERFORM FORMATTING TO THE DATA THAT IS RETURNED BY
THE ORACLE DATABASE TO THE CLIENT SYSTEM. THESE COMMANDS ARE USED FOR REPORT
GENERATION USING SQL*PLUS.
TYPES OF ORACLE SERVER INSTALLATIONS:-
1. PERSONAL ORACLE: - IT IS A SINGLE USER SERVERSET UP. NETWORKING IS NOT

SUPPORTED. SECURITY FEATURES ARE NOT PROVIDED WITH IT. LEARNERS TO LEARN
ORACLE SQL USE IT. RUNS ON O/S LIKE WINDOWS 2000 PRO, XP HOME EDITION, XP
PROFFESSIONAL, And LINUX PERSONAL EDITION INSTALLTION ETC.
2. ORACLE LITE: - IT IS DEVELOPED FOR LOW RESOURCE SYSTEMS LIKE PALM TOPS AND
LAPTOPS. IT SUPPORTS NETWORKING BUT SECURITY FEATURES ARE LOW.
3. ORACLE ENTERPRISE SERVER: - IT IS MAIN SERVER FROM ORACLE CORP. IT SUPPORTS

ALL SECURITY AND NETWORKING FEATURES. CAN BE USED FOR OLAP AND OLTP
DATABASES AS WELL AS VLDB. IT CAN BE USED ON DEVELOPMENT AND PRODUCTION
SERVERS.
4. TRUSTED ORACLE SERVER: - IT IS ALMOST SAME AS ENTERPRISE ORACLE BUT WITH

VERY HIGH SECURITY FEATURES.USED IN RESEARCH, DEFENCE AND BANKING.
TOOLS PROVIDED WITH THE ORACLE ENTERPRISE SERVER: -
1. SQL*PLUS: - A TOOL USED BY THE PROGRAMMER TO SUBMIT SQL AND PL/SQL

COMMANDS TO THE ORACLE SERVER FOR PROCCESSING.
2. ORACLE SQL: - A LANGUAGE PROVIDED BY THE ORACLE SERVER TO PERFORM ALL DATA
MANIPULATION ON THE ORACLE DATABASE SERVER.
3. ORACLE PL/SQL: - A LANGUAGE PROVIDED WHICH ACTS AS A PROCEDURAL EXTENTION

TO SQL.
4. SQL ENGINE: - COMPILES AND EXECUTES ALL SQL CODE
5. PL/SQL ENGINE: - COMPILES AND EXECUTES ALL PL/SQL CODE.

6. ORACLE ENTERPRISE MANAGER CONSOLE (OEM) . USED TO PERFORM ALL DBA TASKS
FROM A GUI INTERFACE.
7. (RMAN) RECOVERY MANAGER: - USED FOR AUTOMATED BACK AND RECOVERY.
8. ORACLE DATAPUMP (10g) PREVIOUSLY KNOWN AS IMP AND EXP UTILITIES:- USED TO
PERFORM LOGICAL BACKUPS AND ALSO TO PORT DATA FROM ONE SERVER TO ANOTHER
SERVER.
9. LOAD JAVA:- THIS TOOL LOADS JAVA CLASSES AND PACKAGES INTO THE ORACLE
DATABASE. AVIALABLE FROM 8i ONWARDS.
10. DROP JAVA:- THIS TOOL IS USED TO DROP JAVA CLASSES AND PACKAGES FROM
DATABASE.
11. ORACLE DBCA (DATABASE CONFIGURATION ASSISTANT):- IS A JAVA BASED TOOL THAT
GIVES A MENU DRIVEN WIZARD FOR ORACLE DATABASE CREATION.
12. SQL-J:- A VERSION OF SQL TO WORK WITH JAVA . IT IS AN INTERPRETER THAT

CONVERTS SQL STATEMENTS INTO JAVA CODE.
13. ORACLE WEB DB

14. ORACLE INTERNET APP SERVER (OiAS)
15. JAVA WEB SERVER
16. JVM
17. APACHE / TOMCAT SERVER
18. ORACLE LISTENER
ORACLE SQL DATATYPES.
WHAT IS A DATATYPE?
A DATATYPE WILL INFLUENCE WHAT TYPE OF DATA CAN BE STORED IN A COLUMN OF A
TABLE. EVERY COLUMN OF A TABLE MUST BE DEFINED WITH A DATATYPE.
ORACLE SQL WILL SUPPORT THE FOLLOWING DATATYPES.
1. NUMBER
2. DATE
3. CHAR
4. VARCHAR2
5. LONG
6. LARGE OBJECT TYPES (LOB TYPES)
NUMBER: - THIS DATA TYPE IS USED TO STORE BOTH INTEGER AND FLOAT FORMAT DATA.
WE CAN STORE A MAX OF 38 DIGITS WITHIN THE NUMBER DATATYPE.
SYNTAX
<COL NAME> NUMBER [(P, S)]
EMPNO NUMBER (4)

1000
9999
SAL NUMBER (7,2)
- - - - -. - -
EMPNO NUMBER
PRESCITION WILL SPECIFY THE TOTAL WIDTH OF THE NUMBER COL

SCALE WILL SPECIFY THE NO OF DIGITS THAT MUST APPEAR TO THE RIGHT
HAND OF THE DECIMAL POINT.
IF NO SIZE IS SPECIFIED, FOR THE NUMERIC COL, THEN THE COL CAN HOLD
VALUES UPTO, 38 DIGITS.
IF NO SCALE VALUE IS SPECIFIED ALL FLOATING POINT VALUES WILL BE
TRUNCATED OF THEIR DECIMAL VALUES
123.45
DATE: - THE DATE TYPE IS USED TO STORE BOTH DATE AND TIME VALUES. THIS DATATYPE
WILL TREAT THE DATE AS AN ACTUAL DATE AND ALL DATE CALCULATIONS CAN BE
PERFORMED ON THAT DATATYPE.
<COL NAME> DATE
ORACLE DATE TYPE WILL SUPPORT DATES IN THE RANGE OF '01-JAN-4712 BC'
'31-DEC-9999 AD'
DEFAULT FORMAT TO SPECIFY A DATE VALUE IS
'DD-MON-YY' OR 'DD-MON-YYYY'
'31-AUG-03'
'01-JAN-81' - 2081
'01-JAN-1981'
'HH: MI: SS AM/PM'
CHAR: - THE CHAR TYPE IS USED TO STORE CHARACTER STRING FORMAT DATA. A STRING
IS A SET OF ONE OR MORE CHARACTERS ENCLOSED WITHIN SINGLE QUOTES.
CHAR STRING: - 'HELLO HOW ARE YOU?'

NUMERIC STRINGS: - '78372'
DATE STRINGS: - '01-JAN-2003'
ALPHA NUMERIC STRINGS: - 'A001'
WE CAN STORE A MAX OF 2000 CHARS WITHIN A ROW FOR A CHAR COL MIN 1 CHAR
SYNTAX
<COL NAME> CHAR [(SIZE)]

ENAME CHAR (10)
'SMITH_____'
GENDER CHAR
'M'
'F'
ENAME CHAR
IF NO SIZE IS SPECIFIED THEN THE COL WILL DEAFAULT TO 1 BYTE
THE CHAR TYPE PERFORMS BLANK PADDING I.E. IT WILL ALWAYS TAKE UP COMPLETE
MEMORY OF THE COL EVEN IF THE DATA SUPPLIED IS LESS THAN THE MAX SIZE OF THE
COL.
VARCHAR2: - THE VARCHAR2 TYPE IS USED TO STORE CHAR STRING FORMAT DATA, BUT
UNLIKE THE CHAR TYPE IT WILL NOT PERFORM ANY BLANK PADDING. WE CAN STORE A MAX
OF 4000 CHARS PER ROW IN VARCHAR2 COL.
SYNTAX
<COL NAME> VARCHAR2 (SIZE)
IN THE VARCHAR2 TYPE THE SIZE OF THE COL IS NOT OPTIONAL WE MUST ALWAYS
SPECIFY THE SIZE OF THE COL.
ENAME VARCHAR2 (10)
EMAIL_TEXT VARCHAR2 (4000)
LONG: - THE LONG TYPE IS USED TO STORE VERY LARGE AMOUNT OF TEXT BASED
INFORMATION. WE CAN STORE UPTO 2 GB OF TEXT BASED INFORMATION PER ROW WITHIN
A TABLE.
SYNTAX: -
<COL NAME> LONG
EMAIL_TEXT LONG
WE CAN HAVE ONLY 1 LONG COL PER TABLE. WE CANNOT USE A LONG COLUMN IN WHERE
CONDITION, WE CANNOT USE A LONG COLUMN IN A GROUP FUNCTION OR GROUP BY
CLAUSE.
LARGE OBJECT TYPES: - THE LOB TYPES WERE INTRODUCED FROM ORACLE 8 ONWARDS
1. CLOB: - CHARACTER LARGE OBJECT, WE CAN STORE UPT0 4 GB OF TEXT BASED

INFORMATION IN A COL DEFINED WITH CLOB TYPE, WE CAN HAVE ANY NUMBER OF CLOB
COLUMNS WITHIN A TABLE.
2 BLOB: - BINARY LARGE OBJECT, WE CAN STORE UPTO 4 GB OF BINARY BASED DATA IN A
BLOB COLUMN WE CAN HAVE ANY NUMBER OF BLOB COLUMNS WITHIN A TABLE.
3. BFILE: - BINARY FILE, THIS DATATYPE WILL STORE A FILE POINTER TO A BINARY FORMAT
FILE ON THE O/S THE FILE CAN BE UPT0 4 GB IN SIZE.
TO WORK ON THESE DATA TYPES WE WILL USE THE DBMS_LOB PACKAGE, WHICH IS A PART
OF THE ORACLE INSTALLATION. TO WORK WITH THIS PACKAGE WE MUST BE A DBA.
NULL TYPE: - NULL IS A MISSING OR UNKNOWN VALUE IT WILL TAKE 1 BYTE IN THE
MEMORY
CREATE TABLE: - THIS A DDL COMMAND IT IS USED TO CREATE A DATA BASE TABLE
WITHIN A SCHEMA.
SYNTAX: -
CREATE TABLE <TABLE NAME> (<COL NAME> <DATA TYPE>[(SIZE),.....)]
WE CAN HAVE UPTO 1000 COLS PER TABLE WITHIN ORACLE DATABASE.
NAMING CONVENTIONS IN ORACLE SQL
1. THE NAME MUST NOT EXCEED 30 CHARS

2. THE NAME MUST BEGIN WITH A ALPHABET BETWEEN A AND Z
3. THE NAME MUST NOT KEEP ANY SPACES
4. THE NAME CAN KEEP _ , # AND $ APART FROM NUMBERS
5. THE NAME CANNOT BE THE SAME AS A ORACLE RESERVED KEY WORD
6. THE NAME CANNOT BE THE SAME AS AN EXISTING DATABASE OBJECT WITHIN THE
SAME SCHEMA.
CREATE TABLE EMPLOYEE (EMPNO NUMBER (4), ENAME VARCHAR2 (10),

JOB VARCHAR2 (10), MGR NUMBER (4), HIREDATE DATE, SAL NUMBER (7,2),
COMM NUMBER (3), DEPTNO NUMBER (2));
SQL> DESC EMPLOYEE

Name Null? Type
----------------------------------------- -------- ------------
EMPNO NUMBER (4)
ENAME VARCHAR2 (10)
JOB VARCHAR2 (10)
MGR NUMBER (4)
HIREDATE DATE
SAL NUMBER (7,2)
COMM NUMBER (3)
DEPTNO NUMBER (2)
SQL> SELECT * FROM EMPLOYEE;
THIS COMMAND WILL DISPLAY THE INFORMATION WITHIN THE EMPLOYEE TABLE.
SELECT *|<COL LIST> FROM <TABLE NAME>;
SQL> SELECT ENAME, JOB FROM EMPLOYEE;
INSERT: - THIS COMMAND IS USED TO ADD RECORDS TO A TABLE.
SYNTAX
INSERT INTO <TABLE NAME> [(<COL LIST>)] VALUES (<VALUE LIST>);
INSERT INTO EMPLOYEE VALUES (7788,'ALLEN','ANALYST','','01-JAN-2003',

1000,’’,10);
WHEN WE WISH TO SUPPLY VALUES ONLY FOR SPECIFIC COLS IN A TABLE WE MUST
SPECIFY THE COL LIST AS WELL AS THE VALUES
INSERT INTO EMPLOYEE (EMPNO, JOB, DEPTNO) VALUES (1002,'MANAGER', 10);
INSERT INTO EMPLOYEE VALUES ('&EMPNO','&ENAME','&JOB','&MGR',

'&HIREDATE','&SAL','&COMM','&DEPTNO');
Enter value for empno: 1004

Enter value for ename: KING
Enter value for job: PERSIDENT
Enter value for mgr:
Old 1: INSERT INTO EMPLOYEE VALUES ('&EMPNO','&ENAME','&JOB','&MGR',
New 1: INSERT INTO EMPLOYEE VALUES ('1004','KING','PERSIDENT','',
Enter value for hiredate: 08-JUN-2003
Enter value for sal: 5000
Enter value for comm:
Enter value for deptno: 10
Old 2: '&HIREDATE','&SAL','&COMM','&DEPTNO')
New 2: '08-JUN-2003','5000','','10')
& - IS SQL*PLUS OPERATOR IT IS KNOWN AS THE SUBSTUTION OPERATOR.

SPECIFYING A '/' IN SQL*PLUS WILL EXECUTE THE PREVIOUS COMMAND THAT HAD
BEEN ISSUED.
DELETE: - THE DELETE COMMAND IS USED TO DELETE ROWS OF INFORMATIONF
FROM A TABLE
DELETE FROM <TABLE NAME> [WHERE <CONIDTION>]
DELETE FROM EMP WHERE JOB='CLERK'; - WILL DELETE ALL THE CLERKS FROM THE TABLE
DELETE FROM EMP; : - THIS WILL DELETE ALL THE ROWS FROM THE TABLE
DELETE <TABLE NAME> [<WHERE CONDITION>]
DELETE EMP; : - WILL DELETE ALL THE ROWS FROM THE EMP TABLE
DELETE EMP WHERE JOB='ANALYST';
UPDATE: - THE UPDATE COMMAND IS USED TO MODIFY THE INFORMATION WITHIN A COL.
SYNTAX: -
UPDATE <TABLE NAME > SET <COL NAME>= <VALUE> [WHERE <CONDITION>];
UPDATE EMP SET ENAME='ALLEN' WHERE ENAME='SMITH'; - CHANGES THE NAME

TO ALLEN FOR SMITH EMPLOYEE
UPDATE EMP SET JOB='CLERK'; - CHANGES ALL THE JOBS TO CLERK
UPDATE EMP SET SAL=SAL+100; - INCREMENTS ALL SAL'S BY 100
UPDATE EMP SET HIREDATE=SYSDATE; - SETS ALL HIREDATE TO CURRENT DATE
UPDATE EMP SET ENAME='ALLEN', SAL=SAL+200 WHERE ENAME='SMITH';
-CHANGES NAME AND SAL OF SMITH EMPLOYEE
TO REMOVE THE TABLE FROM THE DATABASE WE USE THE DROP TABLE COMMAND
DROP TABLE <TABLE NAME>;
DROP TABLE EMP;
RENAME: -
THE RENAME COMMAND IS USED TO RENAME A TABLE NAME.
SYNTAX
RENAME <OLD TABLE NAME> TO <NEW TABLE NAME>;
RENAME EMP TO EMPLOYEE;
TRUNCATE: - THE TRUNCATE COMMAND IS USED TO REMOVE ALL DATA FROM A TABLE
PERMANENTLY.
TRUNCATE TABLE <TABLE NAME>;
TRUNCATE TABLE EMP;
TRANSACTION CONTROL LANGUAGE:-
COMMIT: -THE COMMIT COMMAND IS USED TO SAVE ANY UNSAVED TRANSACTIONS THAT
HAVE BEEN MADE ON A TABLE.
SYNTAX: -
COMMIT;
COMMIT IS OF TWO TYPES
1. IMPLICIT COMMIT
2. EXPLICIT COMMIT
IMPLICIT COMMIT IS DONE IN THE FOLLOWING SITUATIONS
1. WHEN WE EXIT/DICONNECT FROM ORACLE

2. WHEN WE ISSUE ANY DDL OR DCL COMMAND
EXPLICIT COMMIT IS DONE WHEN WE ISSUE THE COMMIT COMMAND AT THE SQL PROMPT
SQL> COMMIT;
ROLLBACK: - THE ROLLBACK COMMAND IS USED TO UNDO ANY UNSAVED TRANSACTIONS.

WE CANNOT ROLLBACK THOSE TRANSACTIONS THAT HAVE BEEN COMMITED.
SYNTAX: -
SQL > ROLLBACK;
WHEN WE ISSUE A ROLLBACK COMMAND IT WILL UNDO ALL DML TRANSACTIONS THAT ARE
UNCOMMITED UPTO THE LAST COMMIT POINT.
WE CANNOT ROLBACK DDL AND DCL TRANSACTIONS WE CAN ROLLBACK ONLY DML
TRANSACTIONS.
SAVEPOINT: - A SAVEPOINT IS A TEMP COMMIT POINT THAT WILL SAVE A TRANSACTION

AGAINST A ROLLBACK.
SQL> INSERT INTO EMP (EMPNO) VALUES (1001);
1 row created.
SQL> SAVEPOINT 1;
Savepoint created.
SQL> DELETE FROM EMP WHERE JOB='CLERK';
4 rows deleted.
SQL> ROLLBACK TO S1;
Rollback complete.
SQL> SELECT * FROM EMP WHERE JOB='CLERK';
EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

----- ---------- --------- ----- --------- ----- ----- ------
7369 SMITH CLERK 7902 17-DEC-80 800 20
7876 ADAMS CLERK 7788 12-JAN-83 1100 20
7900 JAMES CLERK 7698 03-DEC-81 950 30
7934 MILLER CLERK 7782 23-JAN-82 1300 10
SQL> SELECT * FROM EMP WHERE EMPNO=1001;
EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

----- ---------- --------- ----- --------- ----- ----- ------
1001
SQL> ROLLBACK;
Rollback complete.
NOTE: - IF WE DIRECTLY GIVE ROLLBACK WITHOUT SAVEPOINT NAME THEN EVENTHOUGH

THERE IS A SAVEPOINT ALL THE SAVEPOINTS WILL BE ROLLEDBACK UPTO THE LAST
COMMIT POINT.
FLASHBACK DROP
ORACLE 10g OFFER THE FLASHBACK DROP OPTION.

THIS FEATURE ALLOWS US TO UNDO A DROP OPTION USING A FLASHBACK TABLE.
TO SUPPORT THE FLASHBACK DROP OPTION ORACLE 10g HAS A RECYCLE BIN WHERE THE
TABLE WILL BE STORED AFTER IT HAS BEEN DROPPED. THUS WHEN WE DROP A TABLE IT
WILL NOT BE REMOVED FROM THE DATABASE.WE NEED NOT ENABLE FLASHBACK
TABLESPACE TO WORK WITH THIS OPTION.
DROP TABLE <TABLE NAME>;
WHEN WE DROP THE TABLE THE NAME OF THE TABLE WILL BE CHANGED AND IT WILL be
STORED IN THE RECYCLE BIN.
WE CAN CONTINUE TO SELECT DATA FROM THE RENAMED TABLE.
DROP TABLE EMP;

Select * from tab;
rb$$44022$table$20
Select * from Rb$$44022$table$20;
PURGE TABLE Rb$$44022$table$20;
DROP TABLE EMP PURGE;
RB: = ROLLBACK
$$44022: - IT IS THE UNIQUE NUMBER GIVEN BY DATA DICTIONARY TO THE TABLE OBJECT.
$TABLE: - INDICATES THE OBJECT TYPE.
$20: - GIVES A VERSION NUMBER FOR UNIQUENESS.
TO GET THE NAMES OF THE OBJECTS IN THE RECYCLE BIN AND THE NAMES OF THE
ORIGINAL OBJECTS WE WRITE THE FOLLOWING QUERY.
SELECT OBJECT_NAME, ORIGINAL_NAME, TYPE

FROM USER_RECYCLEBIN;
FLASHBACK TABLE EMP TO BEFORE DROP;
THE ABOVE COMMAND WILL RESTORE THE TABLE THAT WE HAD DROPPED.
FLASHBACK TABLE EMP TO BEFORE DROP RENAME TO EMPLOYEE;
WHEN WE FLASHBACK A TABLE FROM THE RECYCLE BIN ALL ASSOCIATED INDEXES FOR
THAT TABLE WILL ALSO BE RECOVERED.
PURGE TABLESPACE USERS;
DROP DATABASE ORCL;
CONSTRAINTS: -
A CONSTRAINT IS A CHECK OR A RULE THAT IS DEFINED ON A TABLES COLUMN. A
CONSTRAINT WILL CHECK THE DATA THAT IS BEING ENTERED INTO THE TABLE COLS, IF
THE DATA IS SATISFYING THE CONSTRAINT RULE THEN THAT DATA IS ALLOWED INTO THE
TABLE OTHERWISE IT WILL BE REJECTED.
ORACLE SQL SUPPORTS THE FOLLOWING TYPES OF CONSTRAINTS
1. NOT NULL CONSTRAINT

2. UNIQUE CONSTRAINT
3. CHECK CONSTRAINT
4. PRIMARY KEY CONSTRAINT
5. FOREIGN KEY CONSTRAINT
NOTE: - WE CAN DEFINE ANY CONSTRAINT AT THE TIME OF CREATION OF THE TABLE OR
AFTER CREATION OF THE TABLE.
NOT NULL CONSTRAINT: - WHEN A NOT CONSTRAINT IS DEFINED ON A TABLES COL THEN
THAT COL WILL NOT ALLOW ANY NULL VALUES TO BE INSERTED OR UPDATED INTO THAT
COL.
CREATE TABLE EMP1 (EMPNO NUMBER (4) NOT NULL, ENAME VARCHAR2 (10) NOT NULL,
JOB VARCHAR2 (10), MGR NUMBER (4), DEPTNO NUMBER (4));
WHEN WE DEFINE A CONSTRAINT ON A TABLES COLUMN THEN ORACLE WILL SPECIFY A

NAME FOR THAT CONSTRAINT. THE CONSTRAINT NAME CAN BE USED AT A LATER POINT OF
TIME FOR REMOVING THE CONSTRAINT OR FOR DISABLING THE CONSTRAINT. IF REQUIRED
WE CAN SPECIFY THE NAME FOR THE CONSTRAINT
SQL> SELECT CONSTRAINT_NAME, CONSTRAINT_TYPE FROM USER_CONSTRAINTS WHERE

TABLE_NAME='EMP1';
THE ABOVE QUERY WILL RETURN ALL CONSTRAINT INFORMATION FOR THE GIVEN TABLE.
IF WE WISH TO SPECIFY THE NAME OF THE CONSTRAINT THEN WE USE THE CONSTRAINT
KEY WORD IN THE CREATE TABLE COMMAND.
CREATE TABLE EMP1 (EMPNO NUMBER (4) CONSTRAINT NN_EMPNO NOT NULL,
ENAME VARCHAR2 (10) CONSTRAINT NN_ENAME NOT NULL,
JOB VARCHAR2 (10), MGR NUMBER (4), DEPTNO NUMBER (4))
FOR NOT NULL CONSTRAINT THE CONSTRAINT TYPE IS 'C'

FOR UNIQUE 'U'
FOR CHECK 'C'
FOR PRIMARY KEY 'P'
FOR FOREIGN KEY 'R'
UNIQUE: - THE UNIQUE CONSTRAINT WILL NOT ALLOW DUPLICATE VALUES TO BE ENTERED
IN THE SPECIFIED COL.
CREATE TABLE EMP1 (EMPNO NUMBER (4) CONSTRAINT UN_EMPNO UNIQUE,

THE FOLLOWING COMMAND IS USED TO SPECIFY BOTH UNIQUE AND NOT NULL
CONSTRAINTS ON THE TABLE.
CREATE TABLE EMP1 (EMPNO NUMBER (4) CONSTRAINT UN_EMPNO UNIQUE

CONSTRAINT NN_EMPNO NOT NULL,

TABLE_NAME='EMP1';
CONSTRAINT_NAME C
------------------------------ -
NN_EMPNO C
NN_ENAME C
UN_EMPNO U
CHECK CONSTRAINT: -
THE CHECK CONSTRAINT IS USED TO CHECK A USER DEFINED CONDITION FOR A COL
WHEN THE DATA IS BEING INSERTED OR UPDATED FOR THAT COLUMN.
ENAME WE MUST CHECK THAT THE ENAME MUST ALWAYS IN UPPER CASE
CREATE TABLE EMP1 (EMPNO NUMBER (4) CONSTRAINT UN_EMPNO UNIQUE
ENAME VARCHAR2 (10) CONSTRAINT CK_ENAME CHECK (ENAME=UPPER (ENAME))
CONSTRAINT NN_ENAME NOT NULL,
PRIMARY KEY CONSTRAINT: -
WHEN WE DEFINE THE PRIMARY KEY CONSTRAINT ON A TABLE THEN THE FOLLOWING
ACTIONS WILL BE PERFORMED ON THAT TABLE
1. THE COL WILL BECOME NOT NULL

2. THE COL WILL BECOME UNIQUE
3. THE COL WILL BE INDEXED
4. THE COL VALUES CAN BE READ OR REFERENCED IN OTHER TABLES COLUMNS
NOTE: - AN INDEX OBJECT IS USED TO INCREASE THE SPEED FOR SEARCH AND RETRIEVAL
OF DATA WITHIN A TABLES COL.
CREATE TABLE DEPT (DEPTNO NUMBER (2) CONSTRAINT PK_DEPTNO PRIMARY KEY,
DNAME VARCHAR2 (10), LOC VARCHAR2 (10));
CREATE TABLE EMP (EMPNO NUMBER (4) CONSTRAINT UN_EMPNO UNIQUE

JOB VARCHAR2 (10), MGR NUMBER (4),
DEPTNO NUMBER (4) CONSTRAINT FK_DEPTNO REFERENCES DEPT (DEPTNO))

TABLE_NAME='EMP';
CONSTRAINT_NAME C
------------------------------ -
NN_EMPNO C
NN_ENAME C
CK_ENAME C
UN_EMPNO U
FK_DEPTNO R
SQL> DROP TABLE DEPT;

DROP TABLE DEPT
*
ERROR at line 1:
ORA-02449: unique/primary keys in table referenced by foreign keys
SQL> INSERT INTO DEPT VALUES (10,'AC','NY');
1 row created.
SQL> INSERT INTO DEPT VALUES (20,'SALES','CHCAGO');
1 row created.
SQL> COMMIT;
Commit complete.
SQL> DESC EMP

Name Null? Type
----------------------------------------- -------- ----------------------------
EMPNO NOT NULL NUMBER (4)
ENAME NOT NULL VARCHAR2 (10)
JOB VARCHAR2 (10)
MGR NUMBER (4)
DEPTNO NUMBER (4)
SQL> INSERT INTO EMP VALUES (1001,'ALLEN','CLERK','7888', 50);

INSERT INTO EMP VALUES (1001,'ALLEN','CLERK','7888', 50)
*
ERROR at line 1:
ORA-02291: integrity constraint (SCOTT.FK_DEPTNO) violated - parent key not
Found
SQL> INSERT INTO EMP VALUES (1001,'ALLEN','CLERK','7888', 10);

1 row created.
SQL> SELECT * FROM DEPT;
DEPTNO DNAME LOC

------ ---------- ----------
10 AC NY
20 SALES CHCAGO
SQL> SELECT * FROM EMP;
EMPNO ENAME JOB MGR DEPTNO

----- ---------- ---------- ----- ------
1001 ALLEN CLERK 7888 10
SQL> DELETE FROM DEPT WHERE DEPTNO=10;

DELETE FROM DEPT WHERE DEPTNO=10
*
ERROR at line 1:
ORA-02292: integrity constraint (SCOTT.FK_DEPTNO) violated - child record found
SQL> SQL> DELETE FROM EMP WHERE DEPTNO=10;
1 row deleted.
SQL> DELETE FROM DEPT WHERE DEPTNO=10;
1 row deleted.
SQL>
ON DELETE CASCADE: - WHEN THIS CLAUSE IS SPECIFIED, IF WE DELETE THE MASTER

RECORD IN THE PARENT TABLE THEN ALL RELATED CHILD RECORDS IN THE CHILD TABLE
ARE ALSO DELETED
CREATE TABLE DEPT (DEPTNO NUMBER (2) CONSTRAINT PK_DEPTNO PRIMARY KEY, DNAME
VARCHAR2 (10), LOC VARCHAR2 (10));
CREATE TABLE EMP (EMPNO NUMBER (4) CONSTRAINT UN_EMPNO UNIQUE

JOB VARCHAR2 (10), MGR NUMBER (4),
DEPTNO NUMBER (4) CONSTRAINT FK_DEPTNO REFERENCES DEPT (DEPTNO) ON DELETE
CASCADE)
SQL> INSERT INTO DEPT VALUES (10,'AC','NY');
1 row created.
SQL> COMMIT;
Commit complete.
SQL> INSERT INTO EMP VALUES (1001,'ALLEN','CLERK','1002',10);
1 row created.
SQL> INSERT INTO EMP VALUES (1002,'ALLEN','MANAGER','',10);
1 row created.
SQL> COMMIT;
Commit complete.
DEPTNO DNAME LOC

------ ---------- ----------
10 AC NY
EMPNO ENAME JOB MGR DEPTNO

----- ---------- ---------- ----- ------
1001 ALLEN CLERK 1002 10
1002 ALLEN MANAGER 10
SQL> DELETE FROM DEPT;
1 row deleted.
no rows selected
No rows selected
TABLE LEVEL CONSTRAINTS
UNIQUE: -
CREATE TABLE EMP
(EMPNO NUMBER (4),
ENAME VARCHAR2 (10),
JOB VARCHAR2 (10),
SAL NUMBER (7,2),
DEPTNO NUMBER (2), CONSTRAINT UN_EMPNO UNIQUE ( EMPNO ));
CREATE TABLE EMP

(EMPNO NUMBER (4),
JOB VARCHAR2 (10),
SAL NUMBER (7,2),
DEPTNO NUMBER (2),
CONSTRAINT UN_EMPNO_ENAME UNIQUE (EMPNO, ENAME));
CREATE TABLE EMP

(EMPNO NUMBER (4),
JOB VARCHAR2 (10),
SAL NUMBER (7,2),
DEPTNO NUMBER (2),
CONSTRAINT UN_EMPNO_ENAME UNIQUE (EMPNO, ENAME),
CONSTRAINT CK_ENAME CHECK (ENAME=UPPER (ENAME)));
CREATE TABLE EMP

(EMPNO NUMBER (4),
JOB VARCHAR2 (10),
SAL NUMBER (7,2),
COMM NUMBER (3),
DEPTNO NUMBER (2),
CONSTRAINT UN_EMPNO_ENAME UNIQUE (EMPNO, ENAME),
CONSTRAINT CK_ENAME CHECK (ENAME=UPPER (ENAME)),
CONSTRAINT CK_SAL_COMM CHECK (SAL>COMM));
PRIMARY KEY TABLE LEVEL: -
CREATE TABLE DEPT (

DEPTNO NUMBER (2),
DNAME VARCHAR2 (10),
LOC VARCHAR2 (10),
CONSTRAINT PK_DEPTNO PRIMARY KEY (DEPTNO));
CREATE TABLE DEPT

(DEPTNO NUMBER (2),
LOC VARCHAR2 (10),
CONSTRAINT PK_DEPTNO_DNAME PRIMARY KEY (DEPTNO, DNAME));
FOREIGN KEY TABLE LEVEL; -
CREATE TABLE EMP (

EMPNO NUMBER (4),
JOB VARCHAR2 (10),
DEPTNO NUMBER (2),
CONSTRAINT FK_DEPTNO FOREIGN KEY (DEPTNO) REFERENCES
DEPT (DEPTNO) ON DELETE CASCADE);
CREATE TABLE EMP (

EMPNO NUMBER (4),
JOB VARCHAR2 (10),
DEPTNO NUMBER (2),
CONSTRAINT FK_DEPTNO FOREIGN KEY (DEPTNO, DNAME) REFERENCES DEPT (DEPTNO,
DNAME) ON DELETE CASCADE);
CREATE TABLE DEPT (DEPTNO NUMBER (2) CONSTRAINT PK_DEPTNO PRIMARY KEY, DNAME
VARCHAR2 (10) CONSTRAINT PK_DNAME PRIMARY KEY);
TABLE LEVEL CONSTRAINTS ARE DEFINED AFTER ALL THE COLUMN DEFINITIONS.
USING TABLE LEVEL CONSTRAINTS WE CAN DEFINE COMPOSITE UNIQUE, PRIMARY AND
FOREIGN KEYS.
USING TABLE LEVEL CONSTRAINTS WE CAN MAKE COMPARISON BETWEEN COLUMNS
VALUES WITH CHECK CONSTRAINTS.
TABLE LEVEL CONSTRAINTS MAKE THE SYNTAX SIMPLER TO READ SINCE ALL CONSTRAINT
DEFINITIONS ARE KEPT SEPERATE FROM COLUMN DEFINITIONS.
NOT NULL CONSTRAINT CANNOT BE DEFINED AT TABLE LEVEL.
ALTER TABLE: -
THE ALTER TABLE COMMAND IS USED TO MODIFY THE STRUCTURE OF THE TABLE. USING
THE ALTER TABLE COMMAND WE CAN PERFORM THE FOLLOWING TASKS
1. ADD A COL TO THE TABLE

2. REMOVE A COL FROM THE TABLE
3. ADD A CONSTRAINT TO THE COL
4. REMOVE A CONSTRAINT FROM A COL
5. DISABLE A CONSTRAINT ON A COL
6. ENABLE A CONSTRAINT ON A COL
7. INCREASE OR DECREASE THE SIZE OF A COL
8. CHANGE THE DATATYPE OF A COL
ADDING A COL TO A TABLE
SYNTAX: -
ALTER TABLE <TABLE NAME> ADD (<COL NAME> <DATA TYPE> [<CONSTRAINT>],...);
ALTER TABLE EMP ADD (GENDER CHAR (1) CONSTRAINT CK_GENDER CHECK (GENDER IN
('M','F')), ADDRESS VARCHAR2 (20));
DROP A COL FROM A TABLE: -
SYNTAX
ALTER TABLE <TABLE NAME> DROP COLUMN <COL NAME>;
ALTER TABLE EMP DROP COLUMN GENDER;
ADDING CONSTRAINT TO A COL: -
NOT NULL: -
SYNTAX: -
ALTER TABLE <TABLE NAME> MODIFY <COL NAME> CONSTRAINT <CONSTRAINT NAME>
NOT NULL;
ALTER TABLE EMP MODIFY EMPNO CONSTRAINT NN_EMPNO NOT NULL;
UNIQUE: -
SYNTAX: -
ALTER TABLE <TABLE NAME> ADD CONSTRAINT <CONSTRAINT NAME> UNIQUE

(<COLNAME>)
ALTER TABLE EMP ADD CONSTRAINT UN_EMPNO UNIQUE (EMPNO);
CHECK: -
ALTER TABLE <TABLE NAME> ADD CONSTRAINT <CONSTRAINT NAME> CHECK

(<CONDITION>)
ALTER TABLE EMP ADD CONSTRAINT CK_ENAME CHECK (ENAME=UPPER (ENAME));
PRIMARY KEY: -
ALTER TABLE <TABLE NAME> ADD CONSTRAINT <CONSTRAINT NAME> PRIMARY KEY (<COL
NAME>);
ALTER TABLE DEPT ADD CONSTRAINT PK_DEPTNO PRIMARY KEY (DEPTNO);
FOREIGN KEY
ALTER TABLE <TABLE NAME> ADD CONSTRAINT <CONSTRAINT NAME> FOREIGN KEY (<COL
NAME>) REFERENCES <TABLE NAME> (<PK COL NAME>);
ALTER TABLE EMP ADD CONSTRAINT FK_DEPTNO FOREIGN KEY (DEPTNO) REFERENCES
DEPT (DEPTNO);
REMOVING OR DROPPING A CONSTRAINT FROM A COL
ALTER TABLE <TABLE NAME> DROP CONSTRAINT <CONSTRAINT NAME>;
ALTER TABLE EMP DROP CONSTRAINT FK_DEPTNO;
ALTER TABLE DEPT DROP CONSTRAINT PK_DEPTNO;
ALTER TABLE EMP DROP CONSTRAINT NN_EMPNO;
DISABLE A CONSTRAINT ON COL
ALTER TABLE <TABLE NAME> DISABLE CONSTRAINT <CONSTRAINT NAME>;

ALTER TABLE EMP DISABLE CONSTRAINT UN_EMPNO;
WHEN A CONSTRAINT IS DISBABLED WE CAN ENTER DATA THAT IS NOT VALIDATING THE
CONSTRAINT, BUT ONCE THAT DATA HAS BEEN ENTERED INTO THE TABLE WE CANNOT
ENABLE THE CONSTRAINT UNLESS THE INVALID DATA IS REMOVED FROM THE TABLE.
ENABLE THE CONSTRAINT: -
SYNTAX
ALTER TABLE <TABLE NAME> ENABLE CONSTRAINT <CONSTRAINT NAME>;
ALTER TABLE EMP ENABLE CONSTRAINT UN_EMPNO;
WE CAN CHECK THE STATUS OF A CONSTRAINT BY WRITING THE FOLLOWING QUERY
SELECT CONSTRAINT_NAME, CONSTRAINT_TYPE, STATUS FROM USER_CONSTRAINTS

WHERE TABLE_NAME='EMP';
INCREASE OR DECREASE THE SIZE OF A COL: -
WE CAN INCREASE OR DECREASE THE SIZE OF A COL, AT ANY TIME WETHER DATA IS,
EXISTING IN THE COL OR NOT.
SYNTAX: -
ALTER TABLE <TABLE NAME> MODIFY <COL NAME> <DATA TYPE> (<NEW SIZE>)
ALTER TABLE EMP MODIFY EMPNO NUMBER (5);
ALTER TABLE EMP MODIFY EMPNO NUMBER (4);
ALTER TABLE EMP MODIFY ENAME VARCHAR2 (15);
CHANGING THE DATA TYPE OF A COLUMN: -
ALTER TABLE <TABLE NAME> MODIFY <COL NAME> <NEW DATATYPE>;
TO CHANGE THE DATATYPE OF A COLUMN THE COL MUST BE EMPTY, BUT IF WE ARE
CHANGING THE DATATYPE FROM CHAR TO VARCHAR2 OR VARCHAR2 TO CHAR THEN THE
COL NEED NOT BE EMPTY.THE SIZE OF THE DATATYPE MUST BE SAME OR LARGER THAN THE
OLD SIZE IN CASE DATA IS ALREADY EXISING IN THE COL.
ALTER TABLE EMP MODIFY ENAME CHAR (15);
ALTER TABLE EMP MODIFY EMPNO VARCHAR2 (10);
SQL> DELETE FROM EMP;

14 rows deleted.
SQL> ALTER TABLE EMP MODIFY EMPNO VARCHAR2 (5);
SQL> ALTER TABLE EMP MODIFY ENAME NUMBER (10);
SQL> ALTER TABLE EMP MODIFY HIREDATE VARCHAR2 (10);
GRANT/REVOKE: -
GRANT: -
THE GRANT COMMAND IS USED TO GIVE ACCESS PRIVILAGES FOR A OBJECT FROM ONE
USER TO ANOTHER USER.
SCOTT USER DEMO USER

EMP
SYNTAX: -
GRANT <PRIVILAGE NAME> | ALL ON <OBJECT NAME> TO <USER NAME> | PUBLIC
PRIVILAGE NAME: - IS THE NAME OF THE PRIVILAGE WE WISH TO GRANT FOR THE GIVEN
OBJECT
ALL: - WILL GRANT ALL THE AVAILABLE PRIVILAGES FOR THAT OBJECT TYPE
OBJECT NAME: - IS THE NAME OF THE OBJECT ON WHICH WE WISH TO GRANT ACCESS
USER NAME: - IS THE NAME OF THE ORACLE USER TO WHOM WE WISH TO GRANT ACCESS
PUBLIC: - WILL GRANT THE GIVEN PRIVILAGE TO ALL THE ORACLE DATABASE USERS
HOW CAN WE CREATE A USER?
SQL> CONNECT SYSTEM/MANAGER

Connected.
SQL> CREATE USER DEMO IDENTIFIED BY DEMO;
User created.
SQL> GRANT CONNECT, RESOURCE TO DEMO;
Grant succeeded.
SQL> CONNECT DEMO/DEMO
SQL> GRANT CONNECT, RESOURCE TO DEMO;
Grant succeeded.

Connected.
SQL> SELECT * FROM TAB;
no rows selected
SQL> CONNECT SCOTT/TIGER

Connected.
SQL> GRANT SELECT ON EMP TO DEMO;
Grant succeeded.

Connected.
SQL> SELECT * FROM SCOTT.EMP;
-----
WE CAN GRANT THE FOLLOWING PRIVILAGES FOR A TABLE
1. SELECT
2. INSERT
3. UPDATE
4. DELETE
5. ALTER
6. REFERENCES: - IF WE GIVE THIS GRANT THEN THE OTHER USER CAN CREATE A FOREIGN
KEY TO THE TABLE THAT HAS BEEN GRANTED.
7. INDEX: - IF WE GIVE THIS GRANT THEN THE OTHER USER CAN CREATE AN INDEX ON THE
TABLE THAT HAS BEEN GRANTED.
SQL GRANT ALL ON EMP TO DEMO;
IF WE GIVE ALL THEN ALL THE PRIVILAGES WILL GRANT TO DEMO USER AT ONE GO.

Connected.
SQL> GRANT SELECT ON EMP TO DEMO;
Grant succeeded.
THE GIVN QUERY WILL GET THE DETAILS FOR THE TABLE GRANTS.
SQL> SELECT * FROM TABLE_PRIVILEGES WHERE OWNER ='SCOTT' AND

TABLE_NAME='EMP';
GRANTEE OWNER
------------------------------ ------------------------------
TABLE_NAME GRANTOR SIDURAIC
------------------------------ ------------------------------ - - - - - - - -
DEMO SCOTT
EMP SCOTT YNNNNNN
SQL>GRANT ALL ON EMP TO DEMO WITH GRANT OPTION;

THE ABOVE COMMAND WILL ALLOW DEMO USER TO BOTH GRANT AND REVOKE PRIVILAGES
ON THE EMP TABLE TO OTHER USERS
SQL> GRANT SELECT ON SCOTT.EMP TO ABC;
SQL> CONNECT ABC/ABC
SQL> SELECT * FROM SCOTT.EMP;
SQL> REVOKE ALL ON EMP FROM ABC;
REVOKE: - THIS COMMAND IS USED TO REMOVE THE PRIVILAGES FOR A USER FOR A GIVEN
OBJECT
SYNTAX
REVOKE <PRIVILAGE NAME> | ALL ON <OBJECT NAME> FROM <USER NAME> | PUBLIC;
REVOKE ALL ON EMP FROM PUBLIC;

REVOKE ALL ON EMP FROM DEMO;
WHEN A GRANT HAS BEEN SPECIFIED EXPLICITLY THEN WE HAVE TO REVOKE THE
PRIVILAGES IN AN EXPLICIT MANNER. BY GIVING THE REVOKE COMMAND EXCLUSIVELY FOR
THAT USER.
VIEWS
A VIEW IS A DATABASE OBJECT THAT WILL STORE A QUERY IN COMPILED FORMAT,

WHENEVER THE USER CALLS THE VIEW THE QUERY ASSOCIATED TO THE VIEW WILL BE
EXECUTED AND THE RESULT OF THE QUERY WILL BE DISPLAYED TO THE END USER.
SYNTAX: -
CREATE VIEW <VIEW NAME> AS <SELECT STATEMENT>;
CREATE VIEW V1 AS SELECT ENAME, SAL FROM EMP;
VIEWS ARE USED FOR THE FOLL PURPOSES

1. TO STORE A COMPLEX QUERY IN THE DATABASE AND ALLOW THAT QUERY TO BE
ACCESSED BY MULTIPLE USERS.
2. TO RESTRICT ACCESS TO THE ORIGINAL DATA OF A TABLE.
CREATE VIEW V1 AS SELECT ENAME, SAL FROM EMP;

GRANT SELECT ON V1 TO DEMO;
WHAT PRIVILAGES CAN WE GRANT ON A VIEW?

1. INSERT
2. UPDATE
3. DELETE
4. SELECT
WE CAN PERFORM DML OPERATIONS ONLY ON THOSE COLS THAT HAVE BEEN SELECTED
WITHIN THE VIEW.
GRANT ALL ON V1 TO DEMO;
SEQUENCE: -
IT IS USED TO AUTOMATICALLY GENERATE NUMBERS IN SQL
CREATE SEQUENCE S1 START WITH 1 INCREMENT BY 1 MINVALUE 1 MAXVALUE 10;
SQL> DROP SEQUENCE S1;
Sequence dropped.
SQL> CREATE SEQUENCE S1 START WITH 1 INCREMENT BY 1 MINVALUE 1 MAXVALUE 10;
Sequence created.
SQL> INSERT INTO EMP (EMPNO) VALUES (S1.NEXTVAL);
1 row created.
SQL> SELECT S1.CURRVAL FROM DUAL;
THE ABOVE QUERY WILL RETURN THE CURRENT VALUE OF THE SEQUENCE
MTL_SYSTEM_ITEMS_B
INDEX
WHAT IS AN INDEX?
AN INDEX IS A PERFORMANCE RELATED OBJECT. WHEN WE CREATE AN INDEX ON A TABLES

COLUMN THEN ORACLE WILL USE THAT INDEX TO SEARCH FOR INFORMATION WITHIN THE
COLUMN WHEN REQUIRED.
SYNTAX:-
CREATE INDEX <INDEX NAME> ON <TABLE NAME> (<COL LIST>);
AN INDEX WILL KEEP SEVERAL DETAILS ABOUT THE DATA WITHIN THE COL.
IT WILL KEEP INFORMATION LIKE
ROWID OF EVERY ROW IN THE COL
DATAFILE ID
DATABLOCK ID
ROWNUM OF EVERY ROW WITHIN THE COLUMN.
CREATE INDEX I1 ON EMP (EMPNO);

SELECT * FROM EMP WHERE EMPNO=7788;
ORACLE WILL NOT USE AN INDEX IN THE FOLLOWING SITUATIONS
1. WHEN THE NUMBER OF ROWS IS BELOW 500

2. WHEN THE RESULT OF THE QUERY IS MORE THAN 5% OF THE TOTAL RECORDS IN THE
TABLE.
WE SHOULD NOT CREATE INDEX IN THE FOLLOWING SITUATIONS
1. ON COLUMNS WHERE THE DATA IS REPEATING TO A VERY LARGE EXTENT.

2. ON COLUMNS THAT ARE UPDATED VERY FREQUENTLY
3. ON TABLES WHERE VALUES ARE DELETED VERY FREQUENTLY
WE SHOULD CREATE INDEX ON A TABLE IN THE FOLLOWING SITUATIONS
1. WHEN THE COLUMN IS CONTAINING VERY LARGE AMOUNT OF UNIQUE VALUES AND IS
NOT BEING UPDATED FREQUENTLY
2. WHEN THE COLUMN IS USED FREQUENTLY IN THE WHERE CLAUSE OF THE QUERY
3. WHEN THE COLUMN IS CONTAINING VERY LARGE NUMBER OF NULL VALUES.
DROP INDEX <INDEX NAME>;

SELECT INDEX_NAME, COLUMN_NAME FROM USER_IND_COLUMNS WHERE
TABLE_NAME='EMP'
CREATE INDEX I2 ON EMP (ENAME, JOB);
WE CAN INCLUDE UPTO 16 COLUMNS IN AN INDEX
WE CAN HAVE UPTO 16 INDEX ON A TABLE.
CREATE UNIQUE INDEX U1 ON DEPT (DEPTNO);
CLUSTER
CREATE CLUSTER DEPTNO_CLUSTER (DEPTNO NUMBER (2));
CREATE INDEX CLUSTER_INDEX ON CLUSTER DEPTNO_CLUSTER;
CREATE TABLE DEPT (DEPTNO NUMBER (2) CONSTRAINT

PK_DEPTNO PRIMARY KEY, DNAME VARCHAR2 (10),
LOC VARCHAR2 (10)) CLUSTER DEPTNO_CLUSTER (DEPTNO);
CREATE TABLE EMP (EMPNO NUMBER (4),

JOB VARCHAR2 (10),
HIREDATE DATE,
DEPTNO NUMBER (2) CONSTRAINT FK_DEPTNO REFERENCES DEPT (DEPTNO)) CLUSTER
DEPTNO_CLUSTER (DEPTNO);
DROP CLUSTER DEPTNO_CLUSTER;
DROP CLUSTER DEPTNO_CLUSTER INCLUDING TABLES;

SYNONYM: -
A SYNONYM IS A DATABASE OBJECT, WHICH ACTS AS AN ALIAS NAME FOR ANOTHER
DATABASE OBJECT LIKE A TABLE OR VIEW OR ANOTHER SYNONYM.
SYNTAX: -
CREATE SYNONYM <SYNONYM NAME> FOR <TABLE NAME>;
CREATE SYNONYM E FOR EMP;
A SYNONYM WILL NOT KEEP ANY DATA BY ITSELF, IT WILL ONLY CREATE AN ALIAS NAME
FOR ANOTHER DATABASE OBJECT, AND IT WILL ALLOW THE USER TO ACCESS THAT OBJECT
THROUGH THIS ALIAS NAME.
SQL> DELETE FROM E WHERE JOB='CLERK';
4 rows deleted.
SQL> SELECT * FROM E WHERE JOB='CLERK';
no rows selected
SQL> SELECT * FROM EMP WHERE JOB='CLERK’;
SQL> SELECT * FROM EMP WHERE JOB='CLERK';
no rows selected
WHATEVER OPERATION WE PERFORM ON THE SYNONYM IS ULTIMATELY DONE ON THE

TABLE. SO IF WE DELETE OR INSERT OR UPDATE THEN THE ORIGINAL TABLE WILL BE
AFFECTED BY THIS OPERATION.
USES OF SYNONYM
1. TO HIDE THE ORIGINAL TABLE NAME FROM OTHER USERS.
2. IF WE GRANT A TABLE TO ANOTHER USER THEN THAT USER CAN ACCESS OUR TABLE
FASTER BY CREATING A SYNONYM FOR OUR TABLE IN HIS SCHEMA.
SQL> GRANT ALL ON EMP TO DEMO;

SQL> CREATE SYNONYM EMP FOR SCOTT.EMP;
SYNONYM CREATED
NOTE: - THE SYNONYM WILL BE WORKING AS LONG AS THE TABLE IS GRANTED, WHEN THE
GRANT OF OUR TABLE IS REMOVED THEN THE SYNONYM WILL STOP WORKING BUT IT WILL
NOT BE REMOVED.
SQL> DESC USER_SYNONYMS

Name Null? Type
----------------------------------------- -------- ----------------------------
SYNONYM_NAME NOT NULL VARCHAR2 (30)
TABLE_OWNER VARCHAR2 (30)
TABLE_NAME NOT NULL VARCHAR2 (30)
DB_LINK VARCHAR2 (128)
SQL> SELECT * FROM USER_SYNONYMS WHERE SYNONYM_NAME='EMP';
no rows selected
SQL> SELECT * FROM USER_SYNONYMS WHERE SYNONYM_NAME='E';
SYNONYM_NAME TABLE_OWNER
------------------------------ ------------------------------
TABLE_NAME
------------------------------
DB_LINK
--------------------------------------------------------------------------------
E SCOTT
EMP
THIS TABLE IS USED TO GET INFORMATION ABOUT ANY SYNONYM WITHIN THE ORACLE
DATABASE SCHEMA.
SELECT - STATEMENTS
THE SELECT COMMAND IS USED TO RETRIEVE DATA OR INFORMATION FROM THE DATABASE
TABLES. WE CAN DISPLAY DATA IN DIFFERENT METHODS USING THE SELECT COMMAND.
SYNTAX: -
SELECT * | <COL LIST> FROM <TABLE NAME> [WHERE <CONDITION>];
* - WILL SELECT ALL COLS IN A TABLE
GIVING THE <COL LIST> WILL SELECT SPECIFIED COLS FROM THE TABLE
FROM <TABLE NAME> WILL SPECIFY THE NAME OF THE TABLE FROM WHERE WE WISH TO
SELECT THE DATA.
[WHERE <CONDITION>] - THIS IS AN OPTIONAL CLAUSE, WHEN WE SPECIFY THIS CLAUSE

THEN WE ARE RESTRICTING THE NO OF ROWS THAT ARE SELECTED FROM THE TABLE.
SELECT * FROM EMP;
SELECT EMPNO, ENAME, DEPTNO FROM EMP;
WHEN WE ARE SELECTING FEW COLS FROM A TABLE THE THAT IS KNOWN AS PROJECTION
SELECT * FROM EMP WHERE JOB='CLERK';
WHEN WE ARE RESTRICTING THE NO OF ROWS THAT ARE BEING SELECTED FROM THE
TABLE THEN IT IS KNOWN AS RESTRICTION.
SELECT EMPNO, ENAME FROM EMP WHERE JOB='MANAGER';
WHERE <CONDITION>: -
THE WHERE CLAUSE IS USED TO RESTRICT THE NO OF ROWS THAT ARE SELECTED BASED
ON A CONDITION.
SYNTAX: -
WHERE <LEFT VALUE> <REL OPERATOR> <RIGHT VALUE>
CONSTANT VALUE BASIC CONSTANT VALUE

COL NAME ADVANCED COL NAME
EXPRESSION EXPRESSION
OPERATOR: - AN OPERATOR IS A PRE-DEFINED FUNCTION THAT WILL COMPARE ONE OR

MORE VALUE AND RETURN A SINGLE BOOEAN VALUE i.e. TRUE OR FALSE. THE OPERATOR
WILL BE IN THE FORM OF A SINGLE CHARACTER OR A SET OF CHARACTERS.
BASIC RELATIONAL OPERATORS: -

THE BASIC RELATIONAL OPERATORS ARE
=
>
<
>=
<=
!= :- NOT EQUAL
^= "
<> "
SELECT * FROM EMP WHERE HIREDATE>'31-DEC-81';

SELECT * FROM EMP WHERE SAL>3000;
SELECT * FROM EMP WHERE JOB='CLERK';
SELECT * FROM EMP WHERE DEPTNO!=10;
SELECT * FROM EMP WHERE SAL<=3000;
LOGICAL OPERATORS: - THEY ARE USED TO CHECK MORE THAN ONE CONDITION AND
BASED ON THE TYPE OF OPERATOR THEY WILL RETURN TRUE OR FALSE.
THERE ARE 3 LOGICAL OPERATORS IN SQL

1. AND
2. OR
3. NOT
AND: - THE AND OPERATOR WILL CHECK 2 OR MORE CONDITIONS AND RETURN TRUE ONLY
IF ALL THE CONDITIONS THAT IT IS CHECKING, RETURN TRUE.
<CONDITION1> AND <CONDITION2> RESULT

T T T
F T F
T F F
F F F
DISPLAY THOSE EMPLOYEES WHO EARN SAL BETWEEN 1000 AND 2500
SELECT * FROM EMP WHERE SAL>=1000 AND SAL<=2500;

DISPLAY THOSE EMPLOYEES WHO JOINED IN THE YEAR 81'
SELECT * FROM EMP WHERE HIREDATE>='01-JAN-81' AND HIREDATE<='31-DEC-81';
SELECT HIREDATE FROM EMP WHERE HIREDATE>='01-JAN-81' AND HIREDATE<='31-DEC-

81';
OR: - THE OR OPERATOR WILL CHECK 2 OR MORE CONDITIONS AND RETURN TRUE IF
ANYONE OF THE TWO CONDITIONS IS TRUE.
<CONDITION1> OR <CONDITION2> RESULT

T T T
F T T
T F T
F F F
DISPLAY THOSE EMPLOYEES WHO DID NOT JOIN IN THE YEAR 81'
SELECT * FROM EMP WHERE HIREDATE<'01-JAN-81' OR HIREDATE>'31-DEC-81';
DISPLAY THOSE EMPLOYEES WHO EARN SAL <1000 AND > 2000
SELECT * FROM EMP WHERE SAL<1000 OR SAL>2000;
DISPLAY THOSE EMP WHO WORK IN DEPT 10 OR 30 AND JOB IS CLERK OR SALESMAN
SELECT * FROM EMP WHERE (DEPTNO=10 OR DEPTNO=30) AND (JOB='CLERK' OR

JOB='SALESMAN');
DISPLAY THOSE EMP WHO EARN SAL >2500 AND WHOSE WORK ON DEPT 20,30
SELECT * FROM EMP WHERE (DEPTNO=20 OR DEPTNO=30) AND SAL>2500;
NOT: -
THE NOT OPERATOR WILL SIMPLY REVERSE THE GIVEN CONDITION
SYNTAX: -
NOT (<CONDITOIN>)
SELECT * FROM EMP WHERE NOT (JOB='CLERK');
SELECT * FROM EMP WHERE NOT (HIREDATE>='1-JAN-81' AND HIREDATE<='31-DEC-81');
ADVANCED RELATIONAL OPERATORS: -
1. IS NULL
2. IS NOT NULL
3. BETWEEN
4. NOT BETWEEN
5. IN
6. NOT IN
7. LIKE
8. NOT LIKE
IS NULL: -
SYNTAX
WHERE <LEFT VALUE> IS NULL
THIS OPERATOR CHECKS IF THE GIVEN LEFT VALUE IS A NULL VALUE
SELECT * FROM EMP WHERE COMM IS NULL;
SELECT * FROM EMP WHERE MGR IS NULL;
IS NOT NULL: -
WHERE <LEFT> VALUE IS NOT NULL;
THIS OPERATOR CHECKS IF THE GIVEN LEFT VALUE IS NOT A NULL VALUE
SELECT * FROM EMP WHERE COMM IS NOT NULL;
SELECT * FROM EMP WHERE MGR IS NOT NULL;
BETWEEN: -
SYNTAX
WHERE <LEFT VALUE> BETWEEN <LOW VALUE> AND <HI VALUE>
SELECT * FROM EMP WHERE SAL BETWEEN 1000 AND 2500;
SELECT * FROM EMP WHERE HIREDATE BETWEEN '01-JAN-81' AND '31-DEC-81';
NOT BETWEEN: -
SYNTAX
WHERE <LEFT VALUE> NOT BETWEEN <LOW VALUE> AND <HI VALUE>
SELECT * FROM EMP WHERE SAL NOT BETWEEN 1000 AND 2500;
SELECT * FROM EMP WHERE HIREDATE NOT BETWEEN '01-JAN-81' AND '31-DEC-81';
IN: -
SYNTAX
WHERE <LEFT VALUE> IN (<VALUE LIST>)
SELECT * FROM EMP WHERE DEPTNO IN (10,30);

SELECT * FROM EMP WHERE JOB IN ('CLERK','MANAGER');
NOT IN
WHERE <LEFT VALUE> NOT IN (<VALUE LIST>)
SELECT * FROM EMP WHERE DEPTNO NOT IN (10,30);
SELECT * FROM EMP WHERE JOB NOT IN ('CLERK','MANAGER');
LIKE: - THIS OPERATOR IS USED FOR STRING PATTERN SEARCH
% - WILL REPRESENT A SET OF CHARACTERS

_ - WILL REPRESENT A SINGLE CHARACTER
WHERE <LEFT VALUE> LIKE 'STRING PATTERN'
SELECT * FROM EMP WHERE ENAME LIKE 'S%';
SELECT * FROM EMP WHERE ENAME LIKE '%N';
SELECT * FROM EMP WHERE ENAME LIKE '%A%'; - IT WILL SEARCH FOR A AT ANY
POSITION WITHIN THE STRING.
SELECT * FROM EMP WHERE ENAME LIKE '_____'; - IT WILL DISPLAY THOSE ENAMES THAT
ARE 5 CHARS IN LENGTH.
SELECT * FROM EMP WHERE ENAME LIKE '_M%'; - IT WILL DISPLAY THOSE ENAMES WHERE
M IS IN THE SECOND POSITION
SELECT * FROM EMP WHERE HIREDATE LIKE '%80';
SELECT * FROM EMP WHERE SAL LIKE '%. %'; - IT WILL DISPLAY THOSE EMP'S WHO HAVE .
IN THEIR SALARY.
SELECT * FROM EMP WHERE ENAME LIKE 'S%' OR ENAME LIKE '%N'; - IT WILL DISPLAY
THOSE EMP WHOSE ENAME IS STARTING WITH 'S' OR ENDING WITH 'N'
NOT LIKE: -
SELECT * FROM EMP WHERE ENAME NOT LIKE 'S%' AND ENAME NOT LIKE '%N';
SELECT * FROM EMP WHERE ENAME LIKE 'S%' AND HIREDATE NOT LIKE '%82';
SELECT * FROM EMP WHERE ENAME LIKE 'S%' AND HIREDATE LIKE '%82';
SUB-QUERIES
A SUB-QUERY WILL CONSIST OF TWO QUERIES, WHERE ONE QUERY WILL CALL THE OTHER
QUERY.THE QUERY THAT CALLS THE OTHER QUERY IS KNOWN AS THE PARENT QUERY OR
ROOT QUERY. THE QUERY THAT IS BEING CALLED BY THE PARENT QUERY OR ROOT QUERY
IS KNOWN AS THE SUB QUERY OR CHILD QUERY OR NESTED QUERY.
ORACLE SUPPORTS TWO TYPES OF SUB QUERIES
1. INDEPENDENT SUB QUERY
2. CORRELATED SUB QUERY
INDEPENDENT SUB-QUERY:-
IN AN INDEPENDENT SUB-QUERY THE SUB-QUERY OR CHILD - QUERY WILL BE EXECUTED

FIRST AND WILL RETURN ONE OR MORE RECORDS TO THE PARENT QUERY OR ROOT QUERY.
BASED ON THE RECORDS RETURNED BY THE SUB QUERY THE PARENT QUERY WILL BE
EXECUTED AND WILL RETURN THE OUTPUT.
THE SUB QUERY IS TOTALLY INDEPENDENT OF THE PARENT QUERY, IT WILL EXECUTE BY
ITSELF WITHOUT REQUIRING ANY VALUES FROM THE PARENT QUERY.
THE PARENT QUERY ON THE OTHER HAND IS DEPENDENT ON THE SUB QUERY.
SYNTAX:-
<PARENT QUERY> <RELATIONAL OP> (<CHILD QUERY>)

|-SELECT |-BASIC |-SELECT
|-DELETE |-ADVANCED
|-UPDATE
WE USE INDEPENDENT SUB-QUERY WHEN

1. THE OUTPUT IS REQUIRED FROM ONE TABLE BUT THE CONDITION REQUIRES ANOTHER
VALUE FROM ANOTHER TABLE.
EX: - DISPLAY THOSE EMP WHO WORK IN SALES DEPT.
2. WHEN OUTPUT IS REQUIRED FROM A SET OF RECORDS OF ONE TABLE BUT CONDITION
REQUIRES ANOTHER RELATED RECORD FROM THE SAME TABLE AS THE OUTPUT TABLE.
EX: - DISPLAY THOSE EMP WHO WORK UNDER JONES.
HOW TO WRITE AN INDEPENDENT SUB-QUERY?
1. DECIDE THE OUTPUT

2. DECIDE THE OUTPUT TABLE (PARENT QUERY)
3. DECIDE THE CONDITION
4. DECIDE THE CONDITION TABLE (CHILD QUERY)
5. DECIDE THE RELATION BETWEEN THE OUTPUT TABLE AND THE CONDITION TABLE IN
ORDER TO COMBINE THE TWO QUERIES.
IF THE TWO TABLES ARE KEEPING ANY COMMON DATA OR COLUMNS THEN THEY CAN BE
COMBINED ON THE BASIS OF EQUALITY USING = BASIC RELATIONAL OPERATOR OR IN
ADVANCED RELATIONAL OPERATOR.
IF THE TWO TABLES ARE NOT KEEPING ANY COMMON COLUMNS OR DATA THEN THE TWO
QUERIES CAN BE COMBINED ON THE BASIS OF VALUE RANGE USING >= OR <= OR
BETWEEN OPERATORS.
DISPLAY THOSE EMP WORK IN SALES DEPT.
OUTPUT - *
OUTPUT - EMP
CONDITION
DNAME = SALES
DEPT
RELATION BETWEEN EMP AND DEPT TABLE IS
EMP.DEPTNO=DEPT.DEPTNO
SELECT * FROM EMP

WHERE DEPTNO=(SELECT DEPTNO FROM DEPT
WHERE DNAME='SALES');
DISPLAY THOSE WHO ARE WORKING UNDER JONES
SELECT * FROM EMP

WHERE MGR=(SELECT EMPNO FROM EMP
WHERE ENAME='JONES');
DISPLAY THOSE EMP WHOSE SALARY GRADE IS 3
DISPLAY THOSE EMP WHOSE DNAME END'S WITH 'S'
SELECT * FROM EMP

WHERE DEPTNO IN (SELECT DEPTNO FROM DEPT
WHERE DNAME LIKE '%S');
DISPLAY EMP WHO’S MANAGERS JOINED IN THE YEAR '81
SELECT * FROM EMP

WHERE MGR IN (SELECT EMPNO FROM EMP
WHERE HIREDATE LIKE '%81');
DISPLAY THOSE EMP WHO WORK UNDER JONES OR CLARK.
SELECT * FROM EMP

WHERE ENAME IN ('JONES','CLARK'));
DISPLAY THOSE EMP WHOSE MANAGERS DEPT IS SALES.
SELECT * FROM EMP

WHERE DEPTNO =(SELECT DEPTNO FROM DEPT
WHERE DNAME='SALES'));
DISPLAY THOSE EMP WHO WORK IN ACCOUNTING DEPT

AND SALGRADE IS 4.
SELECT * FROM EMP

WHERE DEPTNO=(SELECT DEPTNO FROM DEPT
WHERE DNAME='ACCOUNTING')
AND SAL BETWEEN (SELECT LOSAL FROM SALGRADE
WHERE GRADE=4)
AND (SELECT HISAL FROM SALGRADE
WHERE GRADE=4);
DISPLAY THOSE EMP WHOSE JOB IS CLERK AND LOCATED AT CHICAGO.
SELECT * FROM EMP

WHERE JOB='CLERK'
AND DEPTNO=(SELECT DEPTNO FROM DEPT
WHERE LOC='CHICAGO');
DISPLAY SCOTT EMP'S MANAGERS DETAILS.
SELECT * FROM EMP

WHERE EMPNO = (SELECT MGR FROM EMP
WHERE ENAME='SCOTT');
DISPLAY THOSE WHO’S MANAGERS SALGRADE IS 5
SELECT * FROM EMP

WHERE SAL BETWEEN (SELECT LOSAL FROM SALGRADE
WHERE GRADE=5)
AND (SELECT HISAL FROM SALGRADE
WHERE GRADE=5));
DISPLAY DETAILS, OF THOSE WHO ARE MANAGERS FOR SALESMAN EMPLOYEES.
SELECT * FROM EMP

WHERE EMPNO IN (SELECT MGR FROM EMP
WHERE JOB='SALESMAN');
CORRELATED SUB-QUERY
A CORRELATED SUB-QUERY IS USED ON THOSE TABLES THAT KEEP A PARENT CHILD

RELATION WITHIN THE TABLE ITSELF, LIKE EMPNO AND MGR IN EMP TABLE.
IN A, CORRELATED SUBQUERY, BOTH THE QUERIES, ARE DEPENDENT ON EACH OTHER, i.e.
PARENT QUERY IS DEPENDENT ON THE CHILD QUERY FOR DATA AND VICE-VERSA.
IN A CORRELATED SUBQUERY WE MUST USE TABLE ALIAS NAMES BECAUSE OUTER QUERY
DATA MUST BE READ WITHIN THE SUB-QUERY.
SELECT E.ENAME, E.SAL FROM EMP E;
E- ALIAS NAME FOR THE TABLE.
IN A CORRELATED SUBQUERY THE PARENT QUERY IS EXECUTED FIRST BUT IN A PARTIAL

MANNER. WHEN THE PARENT EXECUTES THE FROM CLAUSE WILL FIRST EXECUTE AND
RETURN A SET OF RECORDS FROM THE TABLE AFTER EXECUTION OF THE FROM CLAUSE THE
WHERE CLAUSE HAS TO BE CHECKED. TO CHECK THE WHERE CLAUSE CONDITION THE
PARENT QUERY WILL REQUIRE SOME VALUES FROM THE SUBQUERY, THUS AT THAT POINT
THE SUBQUERY EXECUTION WILL BEGIN.
IN A CORRELATED SUB-QUERY THE SUB QUERY IS EXECUTED THOSE MANY TIMES AS THE
NUMBER OF RECORDS PICKED UP BY THE FROM CLAUSE OF THE PARENT QUERY.
SELECT E.EMPNO, E.ENAME, E.MGR, E.SAL FROM EMP E

WHERE E.SAL>(SELECT M.SAL FROM EMP M
WHERE M.EMPNO=E.MGR);
DISPLAY THOSE EMP WHO WORK IN THE SAME DEPT AS THEIR MANAGER.
SELECT E. * FROM EMP E

WHERE E.DEPTNO=(SELECT M.DEPTNO FROM EMP M
ANY: -
DISPLAY THOSE EMP WHO EARN SAL GREATER THAN ANY OF THE FOLLOWING SAL
1500
1200
3000
1250
SELECT * FROM EMP

WHERE SAL>ANY (1500,1200,3000,1250);
DISPLAY THOSE MANAGERS WHO ARE EARNING MORE THAN ANY ONE OF THIER SUB-
ORDINATES.
SELECT M.EMPNO, M.ENAME, M.SAL FROM EMP

WHERE M.SAL>ANY (SELECT E.SAL FROM EMP E
WHERE E.MGR=M.EMPNO);
DISPLAY THOSE EMP WHO EARN SAL GREATER THAN ALL OF THE FOLLOWING SAL
1500
1200
3000
1250
SELECT * FROM EMP

WHERE SAL>ALL (1500,1200,3000,1250);
DISPLAY THOSE MANAGERS WHO EARN SALARY GREATER THAN ALL THEIR SUBORDINATES.
SELECT M.EMPNO, M.ENAME, M.SAL FROM EMP M

WHERE M.SAL>ALL (SELECT E.SAL FROM EMP E
WHERE E.MGR=M.EMPNO)
AND EXISTS (SELECT J.EMPNO FROM EMP J
WHERE J.MGR=M.EMPNO);
DISPLAY THOSE EMP WHOSE JOB IS NOT THAT OF ANYONE IN DEPT 10

SELECT * FROM EMP
WHERE JOB NOT IN(SELECT JOB FROM EMP
WHERE DEPTNO=10);
SELECT E.EMPNO, E.ENAME FROM EMP E

WHERE NOT EXISTS (SELECT M.EMPNO FROM EMP M
DISPLAY THOSE EMP WHOSE DEPT LOC IS SAME AS MANAGERS DEPT LOC.
DISPLAY THOSE MANAGERS WHO EARN GREATER THAN ATLEAST ONE OF THEIR SUB-
ORDINATES.
SELECT M.EMPNO, M.ENAME, M.SAL FROM EMP M

WHERE M.SAL > ANY (SELECT E.SAL FROM EMP E
WHERE E.MGR = M.EMPNO);
SELECT * FROM EMP

WHERE EMPNO NOT IN (SELECT DISTINCT MGR FROM EMP);
DISPLAY THOSE EMP WHOSE DEPT NAME IS NOT ENDING WITH S
SELECT * FROM EMP

WHERE DEPTNO NOT IN (SELECT DEPTNO FROM DEPT
SELECT * FROM EMP

WHERE EMPNO NOT IN (SELECT DISTINCT MGR FROM EMP
WHERE MGR IS NOT NULL);
DISPLAY THOSE WHOSE DEPT NAME ENDS WITH S
SELECT * FROM EMP

DISPLAY THOSE WHO WORK IN BOSTON.

SELECT * FROM EMP
WHERE DEPTNO = (SELECT DEPTNO FROM DEPT
WHERE LOC='BOSTON');
DISPLAY THOSE EMP WHOSE NAME STARTS WITH J AND DEPT NAME ENDS WITH S
SELECT * FROM EMP

WHERE ENAME LIKE 'J%'
AND DEPTNO IN (SELECT DEPTNO FROM DEPT
DISPLAY THOSE EMP WHO ARE WORKING UNDER KING.

SELECT * FROM EMP
WHERE MGR = (SELECT EMPNO FROM EMP
WHERE ENAME='KING');
DISPLAY THOSE WHO WORK UNDER JONES OR CLARK
SELECT * FROM EMP

WHERE ENAME IN ('JONES','CLARK'));
DISPLAY THOSE WHO’S MANAGER JOINED IN THE YEAR 1981
SELECT * FROM EMP

WHERE HIREDATE>='01-JAN1981' AND
HIREDATE<='31-DEC-1981');
DISPLAY THOSE WHO’S MANAGER JOINED IN THE YEAR 1982
SELECT * FROM EMP

DISPLAY THOSE EMP WHO’S MANAGERS JOINED IN 81 AND EMP ALSO JOINED IN 81
SELECT * FROM EMP

HIREDATE<='31-DEC-1981')
AND(HIREDATE>='01-JAN1981' AND
DISPLAY THOSE EMP WHOSE MANAGERS DEPT IS SALES.
SELECT * FROM EMP

WHERE DEPTNO = (SELECT DEPTNO FROM DEPT
WHERE DNAME='SALES'));
DISPLAY THOSE WHO’S SALGRADE IS 4

SELECT * FROM EMP
WHERE SAL>=(SELECT LOSAL FROM SALGRADE
WHERE GRADE=4)
AND SAL<=(SELECT HISAL FROM SALGRADE
WHERE GRADE=4);
SELECT * FROM EMP

WHERE GRADE=4)
AND (SELECT HISAL FROM SALGRADE WHERE GRADE=4);
DISPLAY THOSE EMP WHOSE SALGRADE IS 3 OR 4 AND DEPT IS ACCOUNTING

SELECT * FROM EMP
WHERE GRADE=3)
AND (SELECT HISAL FROM SALGRADE WHERE GRADE=4)
AND DEPTNO = (SELECT DEPTNO FROM DEPT
WHERE DNAME='ACCOUNTING');
SELECT * FROM EMP

WHERE ((SAL BETWEEN
(SELECT LOSAL FROM SALGRADE WHERE GRADE=3)
AND (SELECT HISAL FROM SALGRADE WHERE GRADE=3))
OR (SAL BETWEEN
(SELECT LOSAL FROM SALGRADE WHERE GRADE=4)
AND (SELECT HISAL FROM SALGRADE WHERE GRADE=4)))
AND DEPTNO=(SELECT DEPTNO FROM DEPT
WHERE DNAME='ACCOUNTING');
DISPLAY THOSE EMP WHOSE DEPT IS NEW YORK OR CHICAGO
SELECT * FROM EMP

WHERE LOC IN ('NEW YORK','CHICAGO'));
DISPLAY THOSE WHO’S MANAGERS JOINED IN 82 AND EMP JOINED IN 81.
SELECT * FROM EMP

WHERE
HIREDATE BETWEEN '01-JAN-1981' AND '31-DEC-1981'
AND MGR IN (SELECT EMPNO FROM EMP
WHERE HIREDATE BETWEEN '01-JAN-1982' AND '31-DEC-1982');
DISPLAY SCOTT EMP'S MANAGERS DETAILS.
SELECT * FROM EMP

WHERE EMPNO=(SELECT MGR FROM EMP
WHERE ENAME='SCOTT');
DISPLAY THOSE WHO’S MANAGERS SALGRADE IS 5
SELECT * FROM EMP

WHERE MGR IN
(SELECT EMPNO FROM EMP
WHERE SAL BETWEEN
(SELECT LOSAL FROM SALGRADE WHERE GRADE=5) AND (SELECT HISAL FROM SALGRADE
WHERE GRADE=5));
DISPLAY THOSE WHO ARE MANAGERS FOR SALESMAN EMPLOYEES.
SELECT * FROM EMP WHERE EMPNO IN (SELECT MGR FROM EMP WHERE JOB='SALESMAN');
DISPLAY THOSE EMP WHO EARN SALARY > ANY ONE EMP IN DEPT 10
SELECT * FROM EMP WHERE SAL>ANY (SELECT SAL FROM EMP WHERE DEPTNO=10);
DISPLAY THOSE EMP WHOSE SAL IS > ANY SALESMAN'S SALARY
SELECT * FROM EMP WHERE SAL>ANY (SELECT SAL FROM EMP

WHERE JOB='SALESMAN');
DISPLAY THOSE WHO’S SAL IS GREATER THAN ALL THE EMP OF DEPT 10
SELECT * FROM EMP WHERE SAL>ALL (SELECT SAL FROM EMP
WHERE DEPTNO=10);
SELECT * FROM EMP WHERE SAL>ALL (SELECT SAL FROM EMP WHERE JOB='SALESMAN');
SQL FUNCTIONS: -
A FUNCTION IS A PREDEFINED PROGRAM THAT WILL ACCEPT ONE OR MORE VALUES,
PROCCESS THE SAME AND RETURN A SINGLE VALUE.
ORACLE SQL PROVIDES 2 TYPES OF FUNCTIONS
1. ROW FUNCTIONS
2. GROUP FUNCTIONS
ROW FUNCTIONS ARE THOSE THAT WILL PROCCESS EACH INDIVIDUAL ROW WITHIN A
TABLE ONE AT A TIME.
GROUP FUNCTIONS ARE THOSE THAT WILL PROCCESS A SET OF ROWS AT A TIME
ROW FUNCTIONS ARE FURTHER DIVIDED INTO
1. CHARACTER FUNCTIONS
2. NUMBER FUNCTIONS
3. DATE FUNCTIONS
4. CONVERSION FUNCTIONS
DUAL IS A SYSTEM DEFINED TABLE THAT CONSISTS OF ONLY 1 ROW AND 1 COLUMN. THE
DUAL TABLE IS USED TO LEARN SQL FUNCTIONS OR TO TEST PLSQL FUNCTIONS OR TO
PERFORM MINOR CALCULATIONS.SELECT 10+2 FROM DUAL;
GROUP FUNCTIONS
GROUPS FUNCTIONS WILL PROCCESS A SET OF RECORDS AT AT TIME.

A GROUP FUNCTION WILL ACCEPT MULTIPLE VALUES OF A COLUMN AND PROCCESS THE
SAME AND RETURN A SINGLE VALUE.
THE FOLLOWING ARE THE GROUP FUNCTIONS SUPPORTED BY ORACLE SQL.
1. SUM (<COL NAME>)

2. MIN (<COL NAME>)
3. MAX (<COL NAME>)
4. AVG (<COL NAME>)
5. COUNT (*) | (<COL NAME>)
SELECT SUM (SAL) FROM EMP;

SELECT MIN (SAL) FROM EMP;
SELECT MAX (SAL) FROM EMP;
SELECT AVG (SAL) FROM EMP;
SELECT MIN (HIREDATE) FROM EMP;
SELECT MAX (HIREDATE) FROM EMP;
SELECT COUNT (COMM) FROM EMP;
SELECT COUNT (*) FROM EMP;
THE COUNT FUNCTION WILL IGNORE NULL VALUES WHEN IT IS USED AT THE COLUMN
LEVEL
THE COUNT FUNCTION WILL NOT, IGNORE, NULL VALUES WHEN IT IS USED AT THE TABLE
LEVEL.
RESTRICTIONS FOR GROUP FUNCTIONS: -
1. GROUP FUNCTION OUTPUT CANNOT BE CLUBBED WITH INDIVIDUAL COLUMN OUTPUT.
SELECT ENAME, MAX (SAL) FROM EMP;
SELECT ENAME, SAL FROM EMP

WHERE SAL=(SELECT MAX (SAL) FROM EMP);
2. GROUP FUNCTIONS CAN BE USED ONLY WITH SELECT AND HAVING CLAUSES.
SELECT ENAME FROM EMP WHERE SAL=MAX (SAL);
3. GROUP FUNCTIONS WILL NOT PROCCESS NULL VALUES. EXCEPT THE COUNT(*)
FUNCTION ALL OTHER GROUP FUNCTIONS IGNORE NULLS.
SELECT SUM (COMM) FROM EMP;
SELECT COUNT (COMM) FROM EMP;
SELECT COUNT (*) FROM EMP;
COUNT (*) WILL COUNT NULL VALUES BUT COUNT AT COLUMN LEVEL WILL IGNORE NULL
VALUES.
SELECT SUM (SAL) FROM EMP WHERE JOB='CLERK';
GROUP BY CLAUSE: -
IT IS A CLAUSE USED WITH THE SELECT COMMAND.THE GROUP BY CLAUSE IS USED TO

DISPLAY INDIVIDUAL COLUMN OUTPUT ALONG WITH GROUP FUNCTION OUTPUT.
THE GROUP BY CLAUSE MUST BE ON THE BASIS OF A SINGLE COLUMN OR MORE COLUMNS.
SYNTAX: -
GROUP BY <COL NAME>;
GROUP BY JOB
THE GROUP BY CLAUSE WILL APPEAR AFTER THE WHERE CLAUSE
SELECT <COL LIST> FROM <TABLE NAME>

[WHERE <CONDITION>]
GROUP BY <COL LIST>;
RELATED RECORDS ARE GROUPED TOGETHER AND PASSED TO THE GROUP FUNCTION ONE
GROUP OF RECORDS AT A TIME. AS THE RECORDS ARE RECIEVED BY THE GROUP FUNCTION
THE GROUP FUNCTION WILL PROCCESS THE SAME AND RETURN A SINGLE VALUE.
THIS PROCCESS WILL CONTINUE UNTILL ALL GROUPS OF RECORDS HAVE BEEN
PROCCESSED.
SELECT SUM (SAL) FROM EMP GROUP BY DEPTNO;
SELECT DEPTNO, SUM (SAL) FROM EMP GROUP BY DEPTNO;
ALL INDIVIDUAL COLUMNS WHICH WE SPECIFY IN THE SELECT CLAUSE MUST APPEAR IN
THE GROUP BY CLAUSE BUT VICE - VERSA IS NOT A MUST
SELECT DEPTNO, JOB, SUM (SAL) FROM EMP GROUP BY DEPTNO, JOB;
DISPLAY LOCATION WISE JOB WISE TOTAL SALARIES.
SELECT LOC, JOB, SUM (SAL) FROM EMP, DEPT

WHERE EMP.DEPTNO=DEPT.DEPTNO
GROUP BY LOC, JOB;
DISPLAY NAME OF THE MANAGER WITH TOTAL NO OF EMP UNDER THE MANAGER.
SELECT M.ENAME, COUNT (*) FROM EMP E, EMP M

WHERE M.EMPNO=E.MGR
GROUP BY M.ENAME;
DISPLAY THE DEPT NAMES WITH TOTAL SAL PAID BY EACH DEPT.
SELECT DNAME, SUM (SAL) FROM EMP, DEPT

GROUP BY DNAME;
DISPLAY SALGRADE AND TOTAL NO OF EMP UNDER THAT GRADE.
SELECT GRADE, COUNT (*) FROM EMP, SALGRADE

WHERE SAL BETWEEN LOSAL AND HISAL
GROUP BY GRADE;
HAVING CLAUSE: -
THE HAVING CLAUSE IS USED TO SPECIFY A CONDITION WITH THE GROUP FUNCTION. IT IS
SIMILAR TO THE WHERE CLAUSE BUT IT CAN KEEP A GROUP FUNCTION. THE HAVING
CLAUSE WILL APPEAR ONLY AFTER THE GROUP BY CLAUSE.
SYNTAX: -
SELECT <COL LIST> FROM <TABLE NAME>

[WHERE <CONDITION>]
GROUP BY <COL NAME>
HAVING <CONDITION>;
DISPLAY DEPTNO AND TOTAL SAL OF THAT DEPT WHICH PAYS TOTAL SAL ABOVE 10000.
SELECT DEPTNO, SUM (SAL) FROM EMP

GROUP BY DEPTNO
HAVING SUM (SAL)>=8000;
DISPLAY DEPTNO AND TOTAL NO OF EMP OF THOSE DEPTS WHICH HAVE COUNT GREATER
THAN 3
SELECT DEPTNO, COUNT (*) FROM EMP

GROUP BY DEPTNO
HAVING COUNT (*)>=3;
DISPLAY GRADE IN WHICH ATLEAST 2 EMPS ARE WORKING.
SELECT GRADE, COUNT (*) FROM EMP, SALGRADE

GROUP BY GRADE
DISPLAY MANAGERS WHO HAVE ATLEAST 2 SUB-ORDINATES
SELECT M.ENAME, COUNT (*) FROM EMP E, EMP M

WHERE M.EMPNO=E.MGR
GROUP BY M.ENAME
DISPLAY THE DEPT HAVING MAX NUMBER OF EMPLOYEES
SELECT emp.DEPTNO, DNAME,COUNT(*) FROM EMP,DEPT

GROUP BY emp.DEPTNO, DNAME
HAVING COUNT (*)=(SELECT MAX (COUNT (*)) FROM EMP
GROUP BY DEPTNO);
DISPLAY MANAGERS NAMES AND TOTAL SAL PAID FOR EMP'S UNDER THEM.
SELECT M.ENAME, SUM (E.SAL) FROM EMP E, EMP M

WHERE M.EMPNO=E.MGR
GROUP BY M.ENAME;
DISPLAY GRADES AND TOTAL SAL PAID FOR EACH GRADE
SELECT GRADE, SUM (SAL) FROM EMP, SALGRADE

GROUP BY GRADE;
DISPLAY JOB AND NO OF EMP UNDER EACH JOB TYPE
SELECT JOB, COUNT (*) FROM EMP

GROUP BY JOB;
DECODE: -
SELECT DECODE (1,1,2,3) FROM DUAL;
SELECT DECODE (1,2,1,3) FROM DUAL;
SELECT PRD_ID, AVAILABLE,

DECODE (AVAILABLE,'Y','PRODUCT IS AVAILABLE',
'PRODUCT IS NOT AVAILABLE') FROM MORE_PRODUCTS;
SELECT PRODUCT_ID, PRODUCT_TYPE_ID, DECODE (PRODUCT_TYPE_ID,

1,'BOOK',
2,'VIDEO',
3,'DVD',
4,'CD','MAGAZINE') FROM PRODUCTS;
SELECT EMPNO, ENAME, DECODE (JOB,

'CLERK','WORKER',
'SALESMAN','SALESPERSON',
'ANALYST','PROGRAMMER',
'MANAGER','SUPERVISOR',
'PRESIDENT','CEO','N/A') JOB FROM EMP;
SELECT DECODE (JOB,'CLERK','WORKER', JOB) FROM EMP;
CASE: -
SELECT PRODUCT_ID, PRODUCT_TYPE_ID,

CASE PRODUCT_TYPE_ID
WHEN 1 THEN 'BOOK'
WHEN 2 THEN 'VIDEO'
WHEN 3 THEN 'DVD'
WHEN 4 THEN 'CD'
ELSE 'MAGAZINE'
END
FROM PRODUCTS;
SEARCHED CASE:-
SELECT PRODUCT_ID, PRODUCT_TYPE_ID,

CASE
WHEN PRODUCT_TYPE_ID=1 THEN 'BOOK'
WHEN PRODUCT_TYPE_ID=2 THEN 'VIDEO'
WHEN PRODUCT_TYPE_ID=3 THEN 'DVD'
WHEN PRODUCT_TYPE_ID=4 THEN 'CD'
ELSE 'MAGAZINE'
END
FROM PRODUCTS;
SELECT PRODUCT_ID, PRICE,

CASE
WHEN PRICE>15 THEN 'EXPENSIVE'
ELSE 'CHEAP'
END
FROM PRODUCTS;
ROLL UP: - THE ROLL UP CLAUSE EXTENDS THE GROUP BY TO RETURN A ROW CONTAINING
A SUBTOTAL FOR EACH GROUP ALONG WITH A TOTAL FOR ALL GROUPS.
SELECT DIVISION_ID, SUM (SALARY) FROM EMPLOYEES2

GROUP BY ROLLUP (DIVISION_ID);
SELECT JOB, SUM (SAL) FROM EMP

GROUP BY ROLLUP (JOB);
SELECT JOB_ID, DIVISION_ID, SUM (SALARY)

FROM EMPLOYEES2
GROUP BY ROLLUP (DIVISION_ID, JOB_ID);
SELECT JOB_ID, DIVISION_ID, SUM (SALARY)

FROM EMPLOYEES2
GROUP BY ROLLUP (JOB_ID, DIVISION_ID);
SELECT DEPTNO, JOB, SUM (SAL) FROM EMP

GROUP BY ROLLUP (DEPTNO, JOB);

GROUP BY ROLLUP (JOB, DEPTNO);
SELECT DEPTNO, JOB, AVG (SAL) FROM EMP

GROUP BY ROLLUP (DEPTNO, JOB);
SELECT DEPTNO, JOB, AVG (SAL) FROM EMP

GROUP BY ROLLUP (JOB, DEPTNO);
CUBE: - THE CUBE CLAUSE EXTENDS GROUP BY CLAUSE TO RETURN ROWS CONTAINING A
SUBTOTAL FOR ALL COMBINATIONS OF COLUMNS INCLUDED IN THE CUBE CLAUSE ALONG
WITH A TOTAL AT THE END.

GROUP BY CUBE (DEPTNO, JOB);

GROUP BY CUBE (JOB, DEPTNO)
NOTE ORACLE 9i Release 1 PUTS THE EXTRA ROWS FROM THE CUBE AT THE END BUT
ORACLE 10g/9i Release 2 PUTS THE EXTRA ROWS AT THE BEGGINING.
GROUPING FUNCTION: -
THE GROUPING FUNCTION ACCEPTS A COLUMN AND RETURNS 0 OR 1. GROUPING RETURNS

1, WHEN A COLUMN VALUE IS NULL AND RETURNS 0, WHEN THE COLUMN VALUE IS NOT
NULL. GROUPING IS ONLY USED IN QUERIES THAT USE THE ROLLUP OR CUBE. GROUPING IS
USEFUL WHEN YOU WANT TO DISPLAY A VALUE WHEN A NULL WOULD OTHERWISE BE
RETURNED.
SELECT DIVISION_ID, SUM (SALARY) FROM EMPLOYEES2

GROUP BY ROLLUP (DIVISION_ID);
SELECT GROUPING (DIVISION_ID), DIVISION_ID, SUM (SALARY) FROM EMPLOYEES2 GROUP

BY ROLLUP (DIVISION_ID);
USING DECODE TO MODIFY THE VALUE RETURNED BY GROUPING
SELECT DECODE (GROUPING (DIVISION_ID), 1,

'GRAND TOTAL', DIVISION_ID) AS DIV, SUM (SALARY)
FROM EMPLOYEES2 GROUP BY ROLLUP (DIVISION_ID);
SELECT
DECODE (GROUPING (JOB), 1,'TOTAL FOR ALL JOBS', JOB) JOB, SUM (SAL) FROM EMP
GROUP BY ROLLUP (JOB);
REPLACE FUNCTION: -
SELECT REPLACE (JOB,'SALESMAN','SALESPERSON') JOB

FROM EMP;
TRANSLATE:-
SELECT TRANSLATE ('HAL','ABCDEFGHIJKLMNOPQRSTUVQXYZ',

'BCDEFGHIJKLMNOPQRSTUVWXYZA') FROM DUAL;
NVL: - NULL VALUE FUNCTION
SELECT ENAME, SAL, NVL (COMM, 0) FROM EMP;
SELECT ENAME, SAL, NVL (COMM, 0), SAL+NVL (COMM, 0)

FROM EMP;
CHARACTER FUNCTIONS: -
UPPER: - CONVERTS THE GIVEN STRING TO UPPER CASE.
SELECT UPPER (ENAME) FROM EMP;
SELECT UPPER ('hello how are you?') FROM DUAL;
LOWER: - CONVERTS THE GIVEN STRING TO LOWER CASE.

SELECT LOWER (ENAME) FROM EMP;
SELECT LOWER ('ORACLE SQL') FROM DUAL;
INITCAP:- CONVERTS THE INITIAL CHARACTER TO CAPITALS FOR ALL WORDS WITHIN A
STRING
SELECT INITCAP (ENAME) FROM EMP;
SELECT INITCAP ('WELCOME TO ORACLE') FROM DUAL;
LENGTH: - RETURNS THE LENGTH OF A STRING
SELECT LENGTH ('WELCOME TO ORACLE SQL') FROM DUAL;
SELECT LENGTH (' ORACLE SQL ') FROM DUAL;
LTRIM: - TRIMS LEADING SPACES FROM A STRING
SELECT LTRIM (' HI') FROM DUAL;
RTRIM: - TRIMS TRAILING SPACES FROM A STRING
SELECT RTRIM ('HI ') FROM DUAL;
TRIM: - TRIMS BOTH LEADING AND TRAILING SPACES.
SELECT TRIM (' ORACLE ') FROM DUAL;
REVERSE: - REVERSES THE GIVEN STRING
SELECT REVERSE ('ORACLE') FROM DUAL;
SUBSTR: - EXTRACTS A PART OF A GIVEN STRING
SELECT SUBSTR ('ORACLE SQL', 1,6) FROM DUAL;
SELECT SUBSTR ('ORACLE SQL', -3,3) FROM DUAL;
SELECT SUBSTR ('ORACLE SQL',8) FROM DUAL;
INSTR: - SEARCHES FOR THE GIVEN STRING WITHIN ANOTHER STRING AND RETURNS
POSITION OF THE FIRST STRING IN THE OTHER STRING.
SELECT INSTR ('ORACLE SQL','C') FROM DUAL;
SELECT INSTR ('ORACLE SQL','C', 5) FROM DUAL;
SELECT INSTR ('ORACLE SQL PRO*C','C', 5) FROM DUAL;
SELECT INSTR ('ORACLE SQL PRO*C','C', 1,2) FROM DUAL;

LPAD: - WILL PAD BLANK SPACES OR A SPECIFIC CHARACTER TO THE LHS OF THE
SPECIFIED STRING.
SELECT LPAD (ENAME, 10,'*') FROM EMP;
RPAD: - WILL PAD BLANK SPACES OR A SPECIFIC CHARACTER TO THE RHS OF THE
SPECIFIED STRING.
SELECT RPAD (ENAME, 10,'*') FROM EMP;
CONCAT: - WILL JOIN TWO STRINGS OR COLUMNS

SELECT CONCAT (ENAME, JOB) FROM EMP;
CONCATENATION OPERATOR: -
SELECT ENAME||JOB||HIREDATE FROM EMP;
ASCII: - RETURNS ASCII VALUE OF THE GIVEN CHARACTERS.
SELECT ASCII ('A') FROM DUAL;
CHR: - RETURNS THE CHARACTER WHEN THE ASCII VALUE IS SPECIFIED.
SELECT CHR (65) FROM DUAL;
SELECT INITCAP (ENAME)||'('||INITCAP (JOB)||')' "EMPLOYEE DETAILS" FROM EMP
NUMBER FUNCTIONS
THE NUMBER FUNCTIONS ARE AS FOLLOWS
1. SIGN: -
CHECKS IF THE GIVEN VALUE IS +TIVE OR -TIVE VALUE
SELECT SIGN (10) FROM DUAL;
SELECT SIGN (-200) FROM DUAL;
SELECT SIGN (0) FROM DUAL;
2. POWER: -
SELECT POWER (10,3) FROM DUAL;
3. SQRT
SELECT SQRT (16) FROM DUAL;
4. MOD
SELECT MOD (10,2) FROM DUAL;
SELECT MOD (10,3) FROM DUAL;

5. TRUNC
SELECT TRUNC (10.27) FROM DUAL;
SELECT TRUNC (10.999999) FROM DUAL;
SELECT TRUNC (10.275643,3) FROM DUAL;
6. ROUND: -
SELECT ROUND (10.27) FROM DUAL;
SELECT ROUND (10.51) FROM DUAL;
SELECT ROUND (10.5476,2) FROM DUAL;
7. CEIL: -
RETURNS THE SMALLEST INTEGER GREATER THAN OR EQUAL TO THE GIVEN VALUE.
SELECT CEIL (10.2) FROM DUAL;
SELECT CEIL (10) FROM DUAL;
SELECT CEIL (-20) FROM DUAL;
SELECT CEIL (-20.3) FROM DUAL;
8.FLOOR: -
RETURNS THE SMALLEST INTEGER, LESS THAN, OR EQUAL TO THE GIVEN VALUE.
SELECT FLOOR (10.9999) FROM DUAL;
SELECT FLOOR (10) FROM DUAL;
SELECT FLOOR (-20) FROM DUAL;
SELECT FLOOR (0) FROM DUAL;
SELECT FLOOR (-20.56) FROM DUAL;
DATE FUNCTIONS: -
SYSDATE: - RETURNS CURRENT DATE AND TIME FROM THE DATABASE.
SELECT SYSDATE FROM DUAL;
MONTHS_BETWEEN: - RETURNS TOTAL NUMBER OF MONTHS BETWEEN TWO DATES.
SELECT MONTHS_BETWEEN (SYSDATE, HIREDATE) FROM EMP;
SELECT HIREDATE, ROUND (MONTHS_BETWEEN (SYSDATE, HIREDATE)/12) FROM EMP;

ADD_MONTHS: - ADD’S A SPECIFIED NO OF MONTHS TO A GIVEN DATE.
SELECT ADD_MONTHS (SYSDATE, 2) FROM DUAL;
SELECT ADD_MONTHS (SYSDATE, -2) FROM DUAL;
SELECT SYSDATE+2 FROM DUAL;
NEXT_DAY: -
RETURNS THE DAY OF THE SPECIFIED DATE
SELECT NEXT_DAY (SYSDATE,'THURSDAY') FROM DUAL;

SELECT NEXT_DAY (SYSDATE,'SUNDAY') FROM DUAL;
LAST_DAY: -
RETURNS THE LAST DAY OF THE MONTH
SELECT LAST_DAY (SYSDATE) FROM DUAL;
CONVERSION FUNCTIONS
TO_CHAR: - USED TO CONVERT A DATE OR NUMBER TO A CHARACTER.
SELECT TO_CHAR (SYSDATE,'DAY') FROM DUAL;
SELECT TO_CHAR (SYSDATE,'DD/MM/YYYY') FROM DUAL;
SELECT TO_CHAR (SYSDATE,'HH: MI: SS AM') FROM DUAL;
SELECT TO_CHAR (HIREDATE,'DDSPTH FMMONTH YEAR') FROM EMP;
TO_DATE: - CONVERTS A GIVEN STRING TO A DATE
SELECT TO_CHAR (TO_DATE ('01-JAN-2005'),'DDSPTH FMMONTH YEAR') FROM DUAL;
INSERT INTO EMP (EMPNO, HIREDATE) VALUES

(1001,TO_DATE ('01-JAN-2005 03:30:00 PM', 'DD-MON-YYYY HH: MI: SS AM'))
TO_NUMBER: -
SELECT TO_NUMBER ('10') FROM DUAL;
SELECT GREATEST ('35','211') FROM DUAL;
SELECT GREATEST (TO_NUMBER ('35'), TO_NUMBER ('211')) FROM DUAL;
SELECT GREATEST
('01-JUN-81','31-JAN-81') FROM DUAL;
SELECT GREATEST (TO_DATE ('01-JUN-81'), TO_DATE ('31-JAN-81')) FROM DUAL;
SELECT LEAST (TO_DATE ('01-JUN-81'), TO_DATE ('31-JAN-81')) FROM DUAL;

JOIN QUERIES
JOIN QUERIES ARE USED TO RETRIEVE DATA FROM TWO OR MORE TABLES AND DISPLAY
THAT DATA IN A SINGLE OUTPUT.
1. EQUI-JOIN
2. OUTER JOIN
3. SELF JOIN
4. NON-EQUI JOIN
5. CARTESIAN JOIN
6. CROSS JOIN
7. NATURAL JOIN
8. NATURAL JOIN WITH USING CLAUSE
9. ON JOIN
10. LEFT OUTER JOIN
11. RIGHT OUTER JOIN
12. FULL OUTER JOIN
EQUI JOIN:- THIS TYPE OF JOIN IS USED ON THOSE TABLES THAT KEEP COMMON COLUMNS
CONTAINING SOME COMMON DATA.
DISPLAY EMP DETAILS ALONG WITH CORRESPONDING DEPT DETAILS.
SELECT EMPNO, ENAME, JOB, EMP.DEPTNO, DNAME, LOC

FROM EMP,DEPT
WHERE EMP.DEPTNO=DEPT.DEPTNO;

FROM EMP, DEPT
WHERE DEPT.DEPTNO=EMP.DEPTNO;
SELECT E.EMPNO, E.ENAME, E.JOB, D.DEPTNO, D.DNAME, D.LOC

FROM EMP E, DEPT D
WHERE D.DEPTNO=E.DEPTNO;
OUTER JOIN:- THE OUTER JOIN IS SIMILAR TO THE EQUI JOIN BUT IT WILL GET THAT EXTRA
DATA THAT IS AVAILABLE IN ONLY ONE OF THE TWO TABLES. THIS EXTRA DATA IS
DISPLAYED ALONG WITH ALL OTHER DATA FROM BOTH TABLES.
DISPLAY EMP DETAILS ALONG WITH CORRESPONDING DEPT DETAILS AND ALSO DISPLAY
THAT DEPT'S DETAILS IN, WHICH THERE ARE NO EMPLOYEES.
TO GET THIS EXTRA INFORMATION ORACLE USES THE OUTER JOIN OPERATOR THAT IS (+).
THIS OPERATOR MUST BE PLACED WITHIN THE JOIN CONDITION ON THAT TABLES SIDE
THAT IS DEFFICIENT OF THE DATA.
SELECT EMPNO, ENAME, JOB, DEPT.DEPTNO, DNAME, LOC

FROM EMP, DEPT
WHERE EMP.DEPTNO (+)=DEPT.DEPTNO;

FROM EMP , DEPT
WHERE EMP.DEPTNO=DEPT.DEPTNO (+);
SELF JOIN: -
THE SELF-JOIN IS USED ON THOSE TABLES THAT KEEP A PARENT CHILD RELATION WITHIN
THE TABLE ITSELF.
DISPLAY EMP DETAILS ALONG WITH MANAGERS NAME AND EMPNO.
SELECT E.EMPNO, E.ENAME, M.EMPNO, M.ENAME

FROM EMP E , EMP M
WHERE M.EMPNO=E.MGR;
DISPLAY THOSE EMP WHO ARE EARNING MORE THAN THEIR MANAGER AND ALSO DISPLAY
THE MANAGERS INFORMATION ALONG WITH THE EMP.
SELECT E.EMPNO, E.ENAME, E.SAL, M.EMPNO, M.ENAME

FROM EMP E , EMP M
WHERE M.EMPNO=E.MGR
AND E.SAL>(SELECT J.SAL FROM EMP J
WHERE J.EMPNO=E.MGR);
NON-EQUI JOIN
IT IS USED ON THOSE TABLES THAT DO NOT KEEP ANY COMMON COLUMNS. THE NON-EQUI
JOIN IS BASED ON VALUE RANGE COMPARISONS.
DISPLAY ALL EMP DETAILS ALONG WITH SALGRADE DETAILS.
SELECT EMPNO, ENAME, SAL, GRADE

FROM EMP, SALGRADE
WHERE SAL BETWEEN LOSAL AND HISAL;
SELECT EMPNO, ENAME, SAL, GRADE

FROM EMP, SALGRADE
WHERE SAL>=LOSAL AND SAL<=HISAL;
DISPLAY THOSE WHO’S GRADE IS SAME AS MANAGERS GRADE.
SELECT E.EMPNO, E.ENAME, S.GRADE, K.EMPNO, K.ENAME

FROM EMP E, SALGRADE S, EMP K
WHERE (E.SAL BETWEEN S.LOSAL AND S.HISAL)
AND S.GRADE=(SELECT M.GRADE
FROM EMP J, SALGRADE M
WHERE (J.SAL BETWEEN M.LOSAL AND M.HISAL)
AND J.EMPNO=E.MGR)
AND K.EMPNO=E.MGR;
CARTESIAN JOIN:- THIS TYPE OF JOIN WILL NOT KEEP ANY JOIN CONDITION , IT WILL
SIMPLY DISPLAY ALL DATA FROM TWO OR MORE TABLES THAT HAVE BEEN MENTIONED IN
THE QUERY.
SELECT EMPNO, ENAME, DEPT.DEPTNO, DNAME FROM EMP, DEPT
THE CROSS JOIN PRODUCES THE CROSS PRODUCT OF TWO TABLES. IT IS THE SAME AS
CARTESIAN JOIN.
SELECT ENAME, EMP.DEPTNO, DNAME FROM

EMP CROSS JOIN DEPT;
SELECT ENAME, DNAME FROM

DEPT CROSS JOIN EMP;
NATURAL JOIN:-
THE NATURAL JOIN IS BASED ON ALL COLUMNS OF TWO TABLES THAT HAVE THE SAME
COLUMN NAME.
IF THE COLUMNS HAVING THE SAME NAME HAVE DIFFERENT DATA TYPES THEN THE
NATURAL JOIN WILL RETURN AN ERROR.
SELECT EMPNO, ENAME, DEPTNO, DNAME, LOC

FROM EMP NATURAL JOIN DEPT;
NATURAL JOIN WITH USING CLAUSE:-

INCASE THE COLUMNS HAVE SAME NAME BUT DIFFERENT DATA TYPES THEN WE CAN USE
THE NATURAL JOIN WITH THE USING CLAUSE.
SELECT EMPNO, ENAME, DEPTNO, DNAME, LOC

FROM EMP JOIN DEPT USING (DEPTNO);
ON JOIN:-
THIS TYPE OF JOIN LETS US SPECIFY THE JOIN CONDITION SEPERATELY FROM THE SEARCH
OR FILTER CONDITION, THERE BY INCREASING THE PERFORMANCE OF THE QUERY
SELECT E.EMPNO, E.ENAME, E.SAL, E.DEPTNO, D.DNAME, D.LOC

FROM EMP E JOIN DEPT D
ON (E.DEPTNO=D.DEPTNO)
WHERE D.DNAME LIKE '%S';
LEFT OUTER JOIN
SELECT E.EMPNO, E.ENAME, D.DEPTNO, D.DNAME, D.LOC

FROM DEPT D LEFT OUTER JOIN EMP E
ON (E.DEPTNO=D.DEPTNO);
RIGHT OUTER JOIN
SELECT E.EMPNO, E.ENAME, D.DEPTNO, D.DNAME, D.LOC

FROM DEPT D RIGHT OUTER JOIN EMP E
ON(E.DEPTNO=D.DEPTNO);
SELECT E.EMPNO, E.ENAME, E.DEPTNO, D.DNAME, D.LOC

FROM EMP E, DEPT D
WHERE E.DEPTNO=D.DEPTNO (+)
UNION
SELECT E.EMPNO, E.ENAME, E.DEPTNO, D.DNAME, D.LOC
FROM EMP E, DEPT D
WHERE E.DEPTNO (+)=D.DEPTNO;
FULL OUTER JOIN
SELECT E.EMPNO, E.ENAME, E.DEPTNO, D.DEPTNO, D.DNAME

FROM EMP E FULL OUTER JOIN DEPT D ON (E.DEPTNO=D.DEPTNO);
ORDER BY CLAUSE
THIS CLAUSE IS THE LAST CLAUSE IN A SELECT STATEMENT.

USING THIS CLAUSE WE CAN ORDER THE DATA IN ASCENDING OR DECENDING ORDER.
SYNTAX
ORDER BY <COL NAME>;
SELECT * FROM EMP ORDER BY ENAME;
DEFAULT ORDER OF SORTING IS ASCENDING.
SELECT * FROM EMP ORDER BY ENAME ASC;
SELECT * FROM EMP ORDER BY ENAME DESC;
TREE WALKING
TREE WALKING IS USED TO DISPLAY DATA WITHIN THOSE TABLES THAT KEEP A PARENT
CHILD RELATION WITHIN THE TABLE ITSELF.USING THE TREE WALK WE DISPLAY A TREE
VIEW STRUCTURE OF THE PARENT RECORDS AND RELATED CHILD RECORDS.
EXAMPLE DISPLAY MANAGER DETAILS ALONG WITH CORRESPONDING EMPLOYEE DETAILS.
TO PERFORM THE TREE WALK WE REQUIRE TO USE THE

"START WITH" AND "CONNECT BY PRIOR" CLAUSES ALONG WITH THE ORDER BY CLAUSE.
SYNTAX
START WITH <FILTER CONDITION>

CONNECT BY PRIOR <RELATION CONDITION>
|
EMPNO=MGR
SELECT LPAD(ENAME,LENGTH(ENAME)+LEVEL*3) FROM EMP START WITH MGR IS NULL

CONNECT BY PRIOR EMPNO=MGR;
DISPLAY EMPLOYEES IN HIERARCHY STARTING FROM JONES.
SELECT LPAD(ENAME,LENGTH(ENAME)+LEVEL*3) FROM EMP START WITH ENAME ='JONES'

SELECT COUNT(*) FROM EMP

WHERE LEVEL>1
START WITH ENAME='JONES'
CONNECT BY PRIOR EMPNO=MGR
DISPLAY LAST LEVEL OF EMPLOYEES ONLY.
SELECT ENAME FROM EMP WHERE

LEVEL=(SELECT MAX (LEVEL) FROM EMP
START WITH MGR IS NULL
CONNECT BY PRIOR EMPNO=MGR)
DISPLAY THOSE EMPLOYEES WHOSE LEVEL IS AN ODD NUMBER.
SELECT ENAME FROM EMP

WHERE MOD(LEVEL,2)!=0
DISPLAY 2nd LEVEL EMPLOYEES ONLY

DISPLAY HOW MANY EMP ARE PRESENT IN LEVEL 3.
SET OPERATORS
THE PURPOSE OF SET OPERATORS IS TO DISPLAY DATA OR COMBINE OUTPUT OF TWO OR

MORE QUERIES AND RETURNS ONE SINGLE OUTPUT.
SYNTAX: -
<QUERY1> <SET OPERATOR> <QUERY2>;
THE SET OPERAORS ARE
1. UNION
2. INTERSECT
3. MINUS
4. UNION ALL
UNION: -
IT RETURNS THE UNIQUE VALUES FROM BOTH THE QUERIES.
SELECT DEPTNO FROM EMP

UNION
SELECT DEPTNO FROM DEPT;
SELECT 10,20,30,40 FROM DUAL

UNION
SELECT 20,30,40,40 FROM DUAL;
INTERSECT:-
IT RETURNS THE UNIQUE VALUES BUT MUST BE PRESENT IN BOTH THE QUERIES OUTPUT.
SELECT DEPTNO FROM EMP

INTERSECT
SELECT DEPTNO FROM DEPT;
MINUS:-
RETURNS THOSE VALUES THAT ARE PRESENT IN THE FIRST QUERIES OUTPUT AND NOT
AVAILABLE IN THE SECOND QUERIES OUTPUT.
SELECT DEPTNO FROM DEPT

MINUS
SELECT DEPTNO FROM EMP;
UNION ALL: - THE COMBINED OUTPUT OF BOTH THE QUERIES IS GIVEN AS THE FINAL
OUTPUT.
SELECT DEPTNO FROM DEPT

UNION ALL
SELECT DEPTNO FROM EMP;
THERE IS A RESTRICTION FOR SET OPERATORS i.e. THE COLUMNS IN QUERY1 MUST MATCH
THE COLUMNS IN QUERY2
IN DATATYPE, ORDER AND NUMBER.
DISPLAY THOSE WHO ARE EMP AS WELL AS MANAGERS (INTERSECT)
DISPLAY THOSE WHO ARE NOT MANAGERS (MINUS)
DISPLAY THOSE DEPTS WHICH DO NOT HAVE EMP (MINUS)
DISPLAY THOSE DEPTS WHICH HAVE EMP (INTERSECT)
DISPLAY NUMBER OF RECORDS FROM ALL THE TABLES.
SELECT COUNT (*) FROM

(SELECT DEPTNO FROM DEPT
UNION ALL
SELECT EMPNO FROM EMP
UNION ALL
SELECT GRADE FROM SALGRADE)
DISPLAY 25% OF RECORDS FROM EMP TABLE.
SELECT * FROM EMP SAMPLE(25);
DISPLAY 10TH HIGHEST SAL FROM EMP TABLE USING ROWNUM.
SELECT * FROM (SELECT ROWNUM RN, ENAME, SAL FROM (SELECT ENAME, SAL FROM EMP
ORDER BY SAL DESC)) WHERE RN=10;
EVERY 4TH SUCCESSIVE RECORD SHOULD BE RETRIEVED.
SELECT * FROM (SELECT ROWNUM RN, ENAME, SAL FROM (SELECT ENAME, SAL FROM EMP
ORDER BY SAL DESC))
WHERE MOD(RN,4)=0;
DISPLAY THOSE EMP WHOSE SALARY IS AN ODD VALUE
SELECT * FROM EMP WHERE MOD (SAL, 2)>=1;

DISPLAY THOSE EMP WHOSE SAL IS ATLEAST 3 DIGITS?
SELECT * FROM EMP WHERE SAL>=100;
DISPLAY THOSE EMP WHO JOINED 10 YEARS AGO FROM TODAY.
DISPLAY 1/2 ENAME IN UPPER CASE AND 1/2 IN LOWER CASE
DELETE THOSE EMP WHO ARE WORKING IN THE COMPANY MORE THAN 2 YEARS.
Select * from emp WHERE ROUND (MONTHS_BETWEEN (SYSDATE, HIREDATE)/12) =24;
SELECT LOWER (SUBSTR (ENAME, 1,ROUND (LENGTH (ENAME)/2)))||

UPPER (SUBSTR (ENAME, ROUND ((LENGTH (ENAME)/2)+1)))
FROM EMP
INSERT ALL/ INSERT FIRST
Inserts to multiple tables in a single INSERT statement are a significant addition to the
Oracle9i database ETL features. This allows the INSERT INTO … SELECT statement to load
data to multiple target tables. A single scan can perform inserts to multiple target tables
[based on the conditions you specify - optional].
Prior to Oracle9i, you may have to write multiple INSERT statements for each table or use a
PL/SQL cursor to insert into different tables.
The syntax of multi-table insert is:
INSERT { ALL insert_into_clause [values_clause]

[insert_into_clause [values_clause]]...
| conditional_insert_clause
}
subquery
where the conditional_insert_clause is
[ ALL | FIRST ]
WHEN condition THEN insert_into_clause [values_clause]
[WHEN condition THEN insert_into_clause [values_clause]
]...
[ELSE insert_into_clause [values_clause]
]
The INSERT ALL clause inserts rows into the target tables unconditionally. Each row read is
processed against each INSERT clause.
The following example takes each row from SALES_HISTORY table and inserts into the
SALES_MONTHLY table a total amount for each month (flat table to a normalized table):
DESC SALES_HISTORY
Name Null? Type
----------------------------------------- -------- -------------
YEAR NUMBER(4)
REGION CHAR (2)
JAN NUMBER
FEB NUMBER
MAR NUMBER
APR NUMBER
MAY NUMBER
JUN NUMBER
JUL NUMBER
AUG NUMBER
SEP NUMBER
OCT NUMBER
NOV NUMBER
DEC NUMBER
DESC SALES_MONTHLY
Name Null? Type
----------------------------------------- -------- -------------
MONTH_YEAR DATE
AMOUNT NUMBER
INSERT ALL
INTO SALES_MONTHLY (MONTH_YEAR, AMOUNT)
VALUES (TO_DATE('01/'||YEAR,'MM/YYYY'), JAN)
INTO SALES_MONTHLY VALUES (TO_DATE('02/'||YEAR,'MM/YYYY'), FEB)
INTO SALES_MONTHLY VALUES (TO_DATE('03/'||YEAR,'MM/YYYY'), MAR)
INTO SALES_MONTHLY VALUES (TO_DATE('04/'||YEAR,'MM/YYYY'), APR)
INTO SALES_MONTHLY VALUES (TO_DATE('05/'||YEAR,'MM/YYYY'), MAY)
INTO SALES_MONTHLY VALUES (TO_DATE('06/'||YEAR,'MM/YYYY'), JUN)
INTO SALES_MONTHLY VALUES (TO_DATE('07/'||YEAR,'MM/YYYY'), JUL)
INTO SALES_MONTHLY VALUES (TO_DATE('08/'||YEAR,'MM/YYYY'), AUG)
INTO SALES_MONTHLY VALUES (TO_DATE('09/'||YEAR,'MM/YYYY'), SEP)
INTO SALES_MONTHLY VALUES (TO_DATE('10/'||YEAR,'MM/YYYY'), OCT)
INTO SALES_MONTHLY VALUES (TO_DATE('11/'||YEAR,'MM/YYYY'), NOV)
INTO SALES_MONTHLY VALUES (TO_DATE('12/'||YEAR,'MM/YYYY'), DEC)
SELECT YEAR,
SUM(JAN) JAN, SUM(FEB) FEB, SUM(MAR) MAR, SUM(APR) APR,
SUM(MAY) MAY, SUM(JUN) JUN, SUM(JUL) JUL, SUM(AUG) AUG,
SUM(SEP) SEP, SUM(OCT) OCT, SUM(NOV) NOV, SUM(DEC) DEC
FROM SALES_HISTORY
GROUP BY YEAR
/
The ALL in the conditional insert clause makes Oracle evaluate all the WHEN conditions
irrespective of the other WHEN conditions. The FIRST clause stops evaluating other WHEN
conditions the first time any condition is evaluated true. The conditions are evaluated in the
order they appear.
INSERT FIRST
WHEN REGION = 'TX' THEN
INTO SALES_TEXAS (YEAR, TOTAL_AMOUNT)
VALUES (YEAR, TOTAMT)
WHEN REGION = 'CA' THEN
INTO SALES_CALIF (YEAR, TOTAL_AMOUNT)
WHEN REGION = 'NM' THEN
INTO SALES_NEWMEX (YEAR, TOTAL_AMOUNT)
WHEN REGION = 'AZ' THEN
INTO SALES_ARIZ (YEAR, TOTAL_AMOUNT)
ELSE
INTO SALES_OTHER (YEAR, TOTAL_AMOUNT)
SELECT YEAR, REGION,
(JAN+FEB+MAR+APR+MAY+JUN+JUL+AUG+SEP+OCT+NOV+DEC) TOTAMT
FROM SALES_HISTORY
/
If the ELSE clause is omitted, Oracle takes no action on that row.
TABLE PARTITIONING
Partitioning allows tables to be subdivided into smaller pieces, enabling themto be managed
and accessed at a finer level of granularity.
Partitioning allows a table to be subdivided into smaller pieces. Each piece of database object
is called a partition.
Each partition has its own name, and may optionally have its own storage characteristics.
From the perspective of a database administrator, a partitioned object has multiple
pieces that can be managed either collectively or individually.
This gives the administrator considerably flexibility in managing partitioned object.
However, from the perspective of the application, a partitioned table is identical to a
nonpartitioned table; no modifications are necessary when accessing a partitioned
table using SQL DML commands.
CREATING BASIC RANGE PARTITIONS:-
CREATE TABLE EMP1(EMPNO NUMBER(4),

ENAME VARCHAR2(10),
SAL NUMBER(7,2),
HIREDATE DATE) PARTITION BY RANGE (SAL)
(PARTITION P1 VALUES LESS THAN (1000),
PARTITION P2 VALUES LESS THAN (2000),
PARTITION P3 VALUES LESS THAN (3000),
PARTITION P4 VALUES LESS THAN (5000));
INSERTING DATA INTO A PARTITION:-
INSERT INTO EMP1 PARTITION (P1) VALUES (1001,'ALLEN',800,'01-JAN-2005');
INSERT INTO EMP1 PARTITION (P1) VALUES (1002,'JAMES',999,'01-JAN-2005');
INSERT INTO EMP1 PARTITION (P3) VALUES (1003,'CLARK',1800,'01-JAN-2005');
INSERT INTO EMP1 PARTITION (P4) VALUES (1004,'KING',4500,'01-JAN-2005');
INSERT INTO EMP1 PARTITION (P3) VALUES (1005,'SMITH',2800,'01-JAN-2005');
DELETING DATA FROM A PARTITION:-

DELETE FROM EMP1 PARTITION (P3);
ROLLBACK
SELECTING DATA FROM A PARTITION:-
SELECT * FROM EMP1 PARTITION (P3);
CREATING TABLESPACES WISE PARTITIONS:-
CREATE TABLESPACE TS1 DATAFILE 'C:\PART_TABLESPACE_DATAFILES\TS1.DBF' SIZE 2M;
CREATE TABLE EMP1(EMPNO NUMBER(4),

ENAME VARCHAR2(10),
SAL NUMBER(7,2),
HIREDATE DATE) PARTITION BY RANGE (SAL)
(PARTITION P1 VALUES LESS THAN (1000) TABLESPACE TS1,
PARTITION P2 VALUES LESS THAN (2000) TABLESPACE TS2,
PARTITION P3 VALUES LESS THAN (3000) TABLESPACE TS3,
PARTITION P4 VALUES LESS THAN (5000) TABLESPACE TS4);
INSERT INTO EMP1 PARTITION (P1) VALUES (1001,'ALLEN',800,'01-JAN-2005');
INSERT INTO EMP1 PARTITION (P1) VALUES (1002,'JAMES',999,'01-JAN-2005');
INSERT INTO EMP1 PARTITION (P2) VALUES (1003,'CLARK',1800,'01-JAN-2005');
INSERT INTO EMP1 PARTITION (P4) VALUES (1004,'KING',4500,'01-JAN-2005');
INSERT INTO EMP1 PARTITION (P3) VALUES (1005,'SMITH',2800,'01-JAN-2005');
OR
INSERT INTO EMP1 VALUES (1001,'ALLEN',800,'01-JAN-2005');
INSERT INTO EMP1 PARTITION VALUES (1002,'JAMES',999,'01-JAN-2005');
INSERT INTO EMP1 VALUES (1003,'CLARK',1800,'01-JAN-2005');
INSERT INTO EMP1 PARTITION VALUES (1004,'KING',4500,'01-JAN-2005');
INSERT INTO EMP1 PARTITION VALUES (1005,'SMITH',2800,'01-JAN-2005');
MOVING A PARTITION:-
ALTER TABLE EMP1 MOVE PARTITION P1 TABLESPACE TS3;
ADDING A PARTITION:-
ALTER TABLE EMP1 ADD PARTITION P6 VALUES LESS THAN (6000);
MERGING TWO PARTITIONS:-
ALTER TABLE EMP1 MERGE PARTITIONS P1 , P2 INTO PARTITION P1_P2 TABLESPACE TS2;
SPLITTING A PARTITION:-
ALTER TABLE EMP1 SPLIT PARTITION P1_P2 AT 1000 INTO (PARTITION P1 TABLESPACE TS1,
PARTITION P2 TABLESPACE TS2);
RENAME A PARTITION:-
ALTER TABLE EMP1 RENAME PARTITION P1 TO P01;
DROP A PARTITION:-
ALTER TABLE EMP1 DROP PARTITION P01;
LIST PARTITIONS:-
CREATE TABLE SALES_BY_REGION (ITEM# NUMBER,

QTY NUMBER,
STORE_NAME VARCHAR2(30),
STATE_CODE VARCHAR2(10),
SALE_DATE DATE)
PARTITION BY LIST(STATE_CODE)
(PARTITION REGION_EAST VALUES ('WB','AM','MZ','NGL') TABLESPACE TS1,
PARTITION REGION_WEST VALUES ('GJ','MH','RT','MP') TABLESPACE TS2,
PARTITION REGION_NORTH VALUES ('JK','ND','UP','PJB') TABLESPACE TS3,
PARTITION REGION_SOUTH VALUES ('KRL','TN','AP','KRT') TABLESPACE TS4);
NVL2 FUNCTION
The NVL2 function extends the functionality found in the NVL function. It lets you substitutes a
value when a null value is encountered as well as when a non-null value is encountered.
The syntax for the NVL2 function is:
NVL2( string1, value_if_NOT_null, value_if_null )
string1 is the string to test for a null value.
value_if_NOT_null is the value returned if string1 is not null.
value_if_null is the value returned if string1 is null.

Example #1:
select NVL2(supplier_city, 'Completed', 'n/a')

from suppliers;
The SQL statement above would return 'n/a' if the supplier_city field contained a null value.
Otherwise, it would return the 'Completed'.
Example #2:
select supplier_id,
NVL2(supplier_desc, supplier_name, supplier_name2)
from suppliers;
This SQL statement would return the supplier_name2 field if the supplier_desc contained a null
value. Otherwise, it would return the supplier_name field.
COALESCE
The coalesce function returns the first non-null expression in the list. If all expressions evaluate to
null, then the coalesce function will return null.
The syntax for the coalesce function is:
coalesce( expr1, expr2, ... expr_n )
For Example:
You could use the coalesce function in an SQL statement as follows:
SELECT coalesce( address1, address2, address3 ) result

FROM suppliers;
The above coalesce statement is equivalent to the following IF-THEN-ELSE statement:
IF address1 is not null THEN

result := address1;
ELSIF address2 is not null THEN

result := address2;
ELSIF address3 is not null THEN

result := address3;
ELSE
result := null;
END IF;
MERGE
Purpose
Use the MERGE statement to select rows from one table for update or insertion into
another table. The decision whether to update or insert into the target table is based
on a condition in the ON clause.
This statement is a convenient way to combine at least two operations. It lets you
avoid multiple INSERT and UPDATE DML statements.
MERGE is a deterministic statement. That is, you cannot update the same row of the
target table multiple times in the same MERGE statement.
Prerequisites
You must have INSERT and UPDATE object privileges on the target table and
SELECT privilege on the source table.
Syntax
merge::=
merge_update_clause::=
MERGE
hint
INTO
schema .
table
t_alias
USING
schema .
table
view
subquery
t_alias
ON ( condition )
WHEN MATCHED THEN merge_update_clause
WHEN NOT MATCHED THEN merge_insert_clause ;
UPDATE SET column =
expr
DEFAULT
,
merge_insert_clause::=
Semantics
INTO Clause
Use the INTO clause to specify the target table you are updating or inserting into.
USING Clause
Use the USING clause to specify the source of the data to be updated or inserted.
The source can be a table, view, or the result of a subquery.
ON Clause
Use the ON clause to specify the condition upon which the MERGE operation either
updates or inserts. For each row in the target table for which the search condition is
true, Oracle updates the row based with corresponding data from the source table.
If the condition is not true for any rows, then Oracle inserts into the target table
based on the corresponding source table row.
WHEN MATCHED | NOT MATCHED
Use these clauses to instruct Oracle how to respond to the results of the join
condition in the ON clause. You can specify these two clauses in either order.
merge_update_clause
The merge_update_clause specifies the new column values of the target table.
Oracle performs this update if the condition of the ON clause is true. If the update
clause is executed, then all update triggers defined on the target table are activated.
Restrictions on Updating a View
 You cannot specify DEFAULT when updating a view.
 You cannot update a column that is referenced in the ON condition clause.
INSERT ( column
,
) VALUES (
expr
,
DEFAULT
)
MERGE
SQL Statements: DROP SEQUENCE to ROLLBACK 17-79
merge_insert_clause
The merge_insert_clausespecifies values to insert into the column of the target
table if the condition of the ON clause is false. If the insert clause is executed, then all
insert triggers defined on the target table are activated.
Restriction on Merging into a View You cannot specify DEFAULT when updating a
view.
Examples
Merging into a Table: Example The following example creates a bonuses table in
the sample schema oe with a default bonus of 100. It then inserts into the bonuses
table all employees who made sales (based on the sales_rep_id column of the
oe.orders table). Finally, the Human Resources manager decides that all
employees should receive a bonus. Those who have not made sales get a bonus of
1% of their salary. Those who already made sales get an increase in their bonus
equal to 1% of their salary. The MERGE statement implements these changes in one
step:
CREATE TABLE bonuses (employee_id NUMBER, bonus NUMBER DEFAULT 100);
INSERT INTO bonuses(employee_id)
(SELECT e.employee_id FROM employees e, orders o
WHERE e.employee_id = o.sales_rep_id
GROUP BY e.employee_id);
SELECT * FROM bonuses;
EMPLOYEE_ID BONUS

153 100
154 100
155 100
156 100
158 100
159 100
160 100
161 100
163 100
MERGE INTO bonuses D
USING (SELECT employee_id, salary, department_id FROM employees
WHERE department_id = 80) S
MERGE
ON (D.employee_id = S.employee_id)
WHEN MATCHED THEN UPDATE SET D.bonus = D.bonus + S.salary*.01
WHEN NOT MATCHED THEN INSERT (D.employee_id, D.bonus)
VALUES (S.employee_id, S.salary*0.1);
EMPLOYEE_ID BONUS

153 180
154 175
155 170
156 200
158 190
159 180
160 175
161 170
163 195
157 950
145 1400
170 960
179 620
152 900
169 1000
.
.
.
LOCK TABLE
Purpose
Use the LOCK TABLE statement to lock one or more tables (or table partitions or
subpartitions) in a specified mode. This lock manually overrides automatic locking
and permits or denies access to a table or view by other users for the duration of
your operation.
Some forms of locks can be placed on the same table at the same time. Other locks
allow only one lock for a table.
A locked table remains locked until you either commit your transaction or roll it
back, either entirely or to a savepoint before you locked the table.
A lock never prevents other users from querying the table. A query never places a
lock on a table. Readers never block writers and writers never block readers.
Prerequisites
The table or view must be in your own schema or you must have the LOCK ANY
TABLE system privilege, or you must have any object privilege on the table or view.
See Also:
Oracle9i Database Concepts for a complete description of the
interaction of lock modes
COMMIT on page 12-75
ROLLBACK on page 17-99
SAVEPOINT on page 18-2
LOCK TABLE
17-74 Oracle9 i SQL Reference
Syntax
lock_table::=
Semantics
schema
Specify the schema containing the table or view. If you omit schema, then Oracle
assumes the table or view is in your own schema.
table / view
Specify the name of the table to be locked.
If you specify view, then Oracle locks the view’s base tables.
If you specify PARTITION ( partition) or SUBPARTITION ( subpartition), then
Oracle first acquires an implicit lock on the table. The table lock is the same as the
lock you specify for partition or subpartition, with two exceptions:
If you specify a SHARE lock for the subpartition, then Oracle acquires an
implicit ROW SHARE lock on the table.

If you specify an EXCLUSIVE lock for the subpartition, then Oracle acquires an
implicit ROW EXCLUSIVE lock on the table.
If you specify PARTITION and table is composite-partitioned, then Oracle
acquires locks on all the subpartitions of partition.
Restriction on Locking Tables If table is part of a hierarchy, then it must be the
root of the hierarchy.
LOCK TABLE
schema . table
view
PARTITION ( partition )
SUBPARTITION ( subpartition )
@ dblink
,
IN lockmode MODE
NOWAIT
;
LOCK TABLE
dblink
Specify a database link to a remote Oracle database where the table or view is
located. You can lock tables and views on a remote database only if you are using
Oracle’s distributed functionality. All tables locked by a LOCK TABLE statement
must be on the same database.
If you omit dblink, then Oracle assumes the table or view is on the local database.
lockmodeClause
Specify one of the following modes:
ROW SHARE ROW SHARE permits concurrent access to the locked table, but
prohibits users from locking the entire table for exclusive access. ROW SHARE is
synonymous with SHARE UPDATE, which is included for compatibility with earlier
versions of Oracle.
ROW EXCLUSIVE ROW EXCLUSIVE is the same as ROW SHARE, but also prohibits
locking in SHARE mode. ROW EXCLUSIVE locks are automatically obtained when
updating, inserting, or deleting.
SHARE UPDATE See ROW SHARE.
SHARE SHARE permits concurrent queries but prohibits updates to the locked
table.
SHARE ROW EXCLUSIVE SHARE ROW EXCLUSIVE is used to look at a whole table
and to allow others to look at rows in the table but to prohibit others from locking
the table in SHARE mode or updating rows.
EXCLUSIVE EXCLUSIVE permits queries on the locked table but prohibits any
other activity on it.
NOWAIT
Specify NOWAIT if you want Oracle to return control to you immediately if the
specified table (or specified partition or subpartition) is already locked by another
user. In this case, Oracle returns a message indicating that the table, partition, or
subpartition is already locked by another user.
See Also: "Referring to Objects in Remote Databases" on
page 2-118 for information on specifying database links
LOCK TABLE
If you omit this clause, then Oracle waits until the table is available, locks it, and
returns control to you.
Examples
Locking a Table: Example The following statement locks the employees table in
exclusive mode, but does not wait if another user already has locked the table:
LOCK TABLE employees
IN EXCLUSIVE MODE
NOWAIT;
The following statement locks the remote employees table that is accessible
through the database link remote:
LOCK TABLE employees@remote
IN SHARE MODE;

Cygnus Technologies Material

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cygnus Technologies Material

Transféré par

Droits d'auteur :

Formats disponibles

The Oracle Database

Oracle is a relational database. In a relational database, all data is stored in two-dimensional

ORACLE 10g RDBMS CONSISTS OF 2 PROGRAMMING LANGUAGES\

1. ORACLE SQL (SEQUEL)

ORACLE SQL IS A 4th GENERATION LANGUAGE, IN A 4GL WE ONLY NEED TO SPECIFY

1. DATA DEFINITION LANGUAGE (DDL)

DATA DEFINITION LANGUAGE

DATA MANIPULATION LANGUAGE

DATA CONTROL LANGUAGE

TRANSACTION CONTROL LANGUAGE

DATA QUERY LANGUAGE

ONCE ORACLE HAS BEEN INSTALLED ON SERVER WE CAN CREATE A NUMBER OF

1. SYS (SYSDBA SUPERUSER)

THE TECHNICAL TERM USED FOR ORACLE USER IS SCHEMA

A SCHEMA IS COLLECTION OF DATABASE OBJECTS. WHEN WE INSTALL ORACLE AND

SQL*PLUS IS A TOOL THAT IS INSTALLED ON A WINDOWS CLIENT TO ACCESS AND ORACLE

SQLPLUS IS A PART OF ORACLE CLIENT SIDE INSTALLATION.

TYPES OF ORACLE SERVER INSTALLATIONS:-

1. PERSONAL ORACLE: - IT IS A SINGLE USER SERVERSET UP. NETWORKING IS NOT

3. ORACLE ENTERPRISE SERVER: - IT IS MAIN SERVER FROM ORACLE CORP. IT SUPPORTS

4. TRUSTED ORACLE SERVER: - IT IS ALMOST SAME AS ENTERPRISE ORACLE BUT WITH

TOOLS PROVIDED WITH THE ORACLE ENTERPRISE SERVER: -

1. SQL*PLUS: - A TOOL USED BY THE PROGRAMMER TO SUBMIT SQL AND PL/SQL

3. ORACLE PL/SQL: - A LANGUAGE PROVIDED WHICH ACTS AS A PROCEDURAL EXTENTION

4. SQL ENGINE: - COMPILES AND EXECUTES ALL SQL CODE

5. PL/SQL ENGINE: - COMPILES AND EXECUTES ALL PL/SQL CODE.

7. (RMAN) RECOVERY MANAGER: - USED FOR AUTOMATED BACK AND RECOVERY.

12. SQL-J:- A VERSION OF SQL TO WORK WITH JAVA . IT IS AN INTERPRETER THAT

13. ORACLE WEB DB

ORACLE SQL DATATYPES.

ORACLE SQL WILL SUPPORT THE FOLLOWING DATATYPES.

WE CAN STORE A MAX OF 38 DIGITS WITHIN THE NUMBER DATATYPE.

<COL NAME> NUMBER [(P, S)]

EMPNO NUMBER (4)

SAL NUMBER (7,2)

PRESCITION WILL SPECIFY THE TOTAL WIDTH OF THE NUMBER COL

<COL NAME> DATE

DEFAULT FORMAT TO SPECIFY A DATE VALUE IS

'HH: MI: SS AM/PM'

CHAR STRING: - 'HELLO HOW ARE YOU?'

<COL NAME> CHAR [(SIZE)]

IF NO SIZE IS SPECIFIED THEN THE COL WILL DEAFAULT TO 1 BYTE

<COL NAME> VARCHAR2 (SIZE)

ENAME VARCHAR2 (10)

EMAIL_TEXT VARCHAR2 (4000)

<COL NAME> LONG

1. CLOB: - CHARACTER LARGE OBJECT, WE CAN STORE UPT0 4 GB OF TEXT BASED

CREATE TABLE <TABLE NAME> (<COL NAME> <DATA TYPE>[(SIZE),.....)]

NAMING CONVENTIONS IN ORACLE SQL

1. THE NAME MUST NOT EXCEED 30 CHARS

CREATE TABLE EMPLOYEE (EMPNO NUMBER (4), ENAME VARCHAR2 (10),

SQL> DESC EMPLOYEE

SQL> SELECT * FROM EMPLOYEE;

SELECT *|<COL LIST> FROM <TABLE NAME>;

SQL> SELECT ENAME, JOB FROM EMPLOYEE;

INSERT: - THIS COMMAND IS USED TO ADD RECORDS TO A TABLE.

INSERT INTO EMPLOYEE VALUES (7788,'ALLEN','ANALYST','','01-JAN-2003',

INSERT INTO EMPLOYEE (EMPNO, JOB, DEPTNO) VALUES (1002,'MANAGER', 10);

INSERT INTO EMPLOYEE VALUES ('&EMPNO','&ENAME','&JOB','&MGR',

Enter value for empno: 1004

& - IS SQL*PLUS OPERATOR IT IS KNOWN AS THE SUBSTUTION OPERATOR.

DELETE FROM <TABLE NAME> [WHERE <CONIDTION>]

DELETE <TABLE NAME> [<WHERE CONDITION>]

DELETE EMP WHERE JOB='ANALYST';