SINGLE ROW FUNCTION:

SRF:
●​ IF WE PASS N NUMBER OF IP’S TO SRF, IT RETURNS
N NUMBER OF OP’S.
●​ SRF EXECUTES ROW BY ROW

L
●​ IT TAKES 1 IP EXECUTES & GENERATE 1 OP THEN

LA
GOES TO NEXT IP

A
K
S
A

DUAL:
K

IT IS A DUMMY TABLE THAT IS PRESENT IN ALL THE

DATABASE TO PERFORM ANY OPERATIONS.
VI
CHARACTER SINGLE ROW FUNCTIONS :

1] LOWER():

THIS FUN IS USED TO CONVERT THE STRING FROM UPPER

L
CASE TO LOWER CASE.

LA
SYNTAX:
LOWER(‘STRING’)

EX:

SELECT LOWER(‘VIKAS’) A
K
FROM DUAL;

O/P:
S

LOWER
A

-----
vikas
K

1] WAQTD NAMES OF EMP’S IN LOWER CASE.

VI
2] UPPER():

THIS IS USED TO CONVERT THE STRING FROM LOWER CASE

TO UPPER CASE.

L
SYNTAX:

LA
UPPER(‘string’)

EX:​

Select upper(‘vikas’)
From dual;
A
K
O/P
S

UPPER
VIKAS
A

1] WAQTD NAMES IN UPPER CASE AND DESIGNATION IN

K

LOWER CASE FOR ALL THE EMP’S.

VI
3] INITCAP():

THIS FUN IS USED TO CONVERT THE INITIAL CHARACTER INTO

UPPER CASE.

SYNTAX:

L
INITCAP(‘STRING’)

LA
EX:

SELECT INITCAP(‘VIKAS’)
FROM DUAL;

O/P:
A
K
INITC
-----
S

Vikas
A

1] WAQTD NAMES OF ALL THE EMP’S WITH 1ST CHAR IN

CAPITAL.
K
VI
4] REVERSE():

THIS FUN IS USED TO REVERSE THE STRING.

L
SYNTAX:

LA
REVERSE(‘STRING’)

EX:

SELECT REVERSE('VIRAT')
A
K
FROM DUAL;

O/P:
S

REVER
A

-----
TARIV
K

1] WAQTD NAMES OF EMP’S IN REVERSE FORM.

VI
5] LENGTH():

THIS FUNCTION IS USED TO FIND THE NUMBER OF

L
CHARACTERS IN A GIVEN STRING.

LA
SYNTAX:
LENGTH(‘STRING’)

EX:

SELECT LENGTH(‘VIKAS’)
A
K
FROM DUAL;

O/P:
S

LENGTH('VIKAS')
A

---------------
5
K

1] WAQTD NAME & LENGTH OF THE NAME FOR ALL THE EMP’S.
VI
6] SUBSTR():

THIS FUN IS USED TO EXTRACT THE PART OF THE STRING

FROM THE ORIGINAL STRING.

L
SYNTAX:

LA
SUBSTR(‘ORIGINAL_STRING’, POSITION,[LENGTH])

EX:
A
SELECT SUBSTR(‘BENGALURU’,1,3)
K
SQL> SELECT SUBSTR('BENGALURU',1,3)
2 FROM DUAL;
S

SUB
A

---
BEN
K

SELECT SUBSTR(‘BENGALURU’,3,2) // NG
VI

1] WAQTD NAME & FIRST 3 CHAR’S OF NAMES FOR ALL THE

EMP’S.

2] WAQTD DETAILS OF EMP’S WHOSE NAME STARTS WITH ‘A’

USING SRF.
7] INSTR():

THIS FUN IS USED TO FIND THE INDEX VALUE OF THE

L
SUBSTRING WHICH IS PRESENT IN THE ORIGINAL STRING.
(INDEX VALUE- POSITION OF THE CHARACTER).

LA
SYNTAX:

INSTR(‘ORIGINAL_STRING’, ‘SUB_STR’,POSITION,[NTH
OCCURANCE]) A
K
EX:
S

BANANA
A

INSTR(‘BANANA’, ‘A’, 1,1)

K

SELECT INSTR('BANANA','A',1,1)
FROM DUAL;
VI

INSTR('BANANA','A',1,1)
-----------------------
2
INSTR(‘BANANA’, ‘A’, 1,2)

1 SELECT INSTR('BANANA','A',1,2)
2* FROM DUAL
SQL> /

INSTR('BANANA','A',1,2)

L
-----------------------
4

LA
A
K
S
A
K
VI
8] REPLACE():

THIS FUN IS USED TO REPLACE THE SUBSTRING WITH NEW

L
STRING IN GIVEN ORIGINAL STRING.

LA
SYNTAX:

REPLACE(‘ORIGINAL_STRING’, ‘SUB_STR’, [‘NEW_STRING’])

EX: A
K
1 SELECT REPLACE ('QSPIDERS','S','J')
2* FROM DUAL
SQL> /
S

REPLACE(
A

--------
QJPIDERJ
K
VI

1 SELECT REPLACE ('QSPIDERS','Q','J')

2* FROM DUAL
SQL> /

REPLACE(
--------
JSPIDERS
 1 SELECT REPLACE ('QSPIDERS','Q')
2* FROM DUAL
S QL> /

REPLACE

L
-------
SPIDERS

LA
A
K
S
A
K
VI
9] CONCAT() :

IT IS USED TO JOIN TWO GIVEN STRINGS’

SYNTAX :

L
CONCAT (‘STRING-1’ , ‘STRING-2’)

LA
EX:

SELECT CONCAT('HI!' , ' HOW ARE YOU ALL?')

FROM DUAL;
A
K
CONCAT('HI!','HOWARE
--------------------
HI! HOW ARE YOU ALL?
S
A

SELECT CONCAT('SQL' , ' IS AWESOME')

FROM DUAL;
K
VI

CONCAT('SQL','
--------------
SQL IS AWESOME
10] TRIM( )

L
LA
TRIM is a String function of Oracle. This function is used to remove
the specified character from head of the string or tail of the string or
Both.

A
The Oracle TRIM() function accepts three arguments:
K
●​ LEADING , TRAILING , BOTH. The first argument allows you to
specify which side of the string to trim. ...
●​ trim_character. is the specified character that should be removed
S

from leading, trailing, or both of the trim_source .

●​ Trim_source / STRING
A
K

SYNTAX:
VI

TRIM ( [LEADING/TRAILING/BOTH] 'CHAR' FROM 'STRING' )

EX:

SELECT TRIM(LEADING 'M' FROM 'MALYALAM')

FROM DUAL

TRIM(LE
-------
ALYALAM

L
LA
SELECT TRIM(TRAILING 'M' FROM 'MALYALAM')
FROM DUAL

TRIM(TR
-------
MALYALA
A
K
SELECT TRIM(BOTH 'M' FROM 'MALYALAM')
FROM DUAL
S
A

TRIM(B
------
K

ALYALA
VI
11] LPAD :

The LPAD in SQL is a function that helps in padding or adding a string

to the left of the given string.

L
SYNTAX :

LA
LPAD (‘INPUTSTR’, LENGTH, ‘PADSTR’);

EX:

SELECT LPAD('SHARMA',10,'#')
FROM DUAL;
A
K
LPAD('SHAR
S

----------
####SHARMA
A
K
VI
12] RPAD :

The RPAD in SQL is a function that helps in padding or adding a string

L
to the RIGHT of the given string.

LA
SYNTAX :

RPAD (‘INPUTSTR’, LENGTH, ‘PADSTR’);

EX:
A
K
SELECT RPAD('SHARMA',10,'#')
FROM DUAL;
S

RPAD('SHAR
A

----------
SHARMA####
K
VI
DATE SINGLE ROW FUNCTION :

1] SYSDATE:

IT IS USED TO FIND THE DATE PRESENT IN THE SYSTEM.

L
LA
SYNTAX: SELECT SYSDATE
​ ​ FROM DUAL;

SQL> SELECT SYSDATE

2 FROM DUAL;

SYSDATE
A
K
---------
02-NOV-23
S

2] SYSTIMESTAMP:
A

THIS FUN IS USED TO FIND THE DATE & TIME ALONG WITH TIME
K

ZONE.
VI

SYNTAX: SELECT SYSTIMESTAMP

​ ​ FROM DUAL;

SQL> SELECT SYSTIMESTAMP

2 FROM DUAL;

SYSTIMESTAMP
---------------------------------------
04-JAN-24 08.54.56.400000 AM +05:30

3] ADD_MONTHS( )

IT IS USED TO ADD NUMBER OF MONTHS TO A PARTICULAR

L
DATE.

LA
SYNTAX :

ADD_MONTHS('DATE',N0_OF_MONTHS)

EX: A
K
SELECT ADD_MONTHS('09-SEP-23', 6)
FROM DUAL;
S

O/P:
A

ADD_MONTH
---------
K

09-MAR-24
VI
4] MONTHS_BETWEEN( ) :

IT IS USED TO FIND THE MONTHS BETWEEN TWO GIVEN

DATES.

L
SYNTAX:

LA
MONTHS_BETWEEN('DATE-1','DATE-2')

EX:
A
K
SELECT MONTHS_BETWEEN('21-JUL-24', '21-JUL-23')
FROM DUAL;
S

MONTHS_BETWEEN('21-JUL-24’,'21-JUL-23')
A

---------------------------------------
12
K
VI

SELECT MONTHS_BETWEEN('21-JUL-23', '21-JUL-24')

FROM DUAL;

MONTHS_BETWEEN('21-JUL-23','21-JUL-24')
---------------------------------------
-12
5] LAST_DAY( ) :

IT IS USED TO FIND THE LAST DAY IN A GIVEN DATE.

L
SYNTAX: LAST_DAY('DATE')

LA
EX:

SELECT LAST_DAY ('21-JUL-23')

FROM DUAL; A
K
LAST_DAY(
----------------
31-JUL-23
S
A

6] NEXT_DAY() :
K

IT IS USED TO FIND THE NEXT GIVEN DAY FROM A GIVEN DATE.

VI

SYNTAX: NEXT_DAY(‘DATE’, ‘DAY’)

EX:

SELECT NEXT_DAY ('21-JUL-23' , 'FRIDAY')

FROM DUAL;
NEXT_DAY(
---------
28-JUL-23

7] EXTRACT( ):

L
IT IS USED TO EXTRACT A PARTICULAR DAY / MONTH / YEAR

LA
FROM A GIVEN DATE.

SYNTAX:

A
EXTRACT ( DAY / MONTH / YEAR FROM DATE 'DATE' )
K
NOTE : DATE = ‘YY/YYYY-MM-DD’
​ ​ EX = ‘23-09-09’
EX:
S

SELECT EXTRACT(YEAR FROM DATE '1998-03-07')

A

FROM DUAL;
K

EXTRACT(YEARFROMDATE'1998-03-07')
---------------------------------
VI

1998

SELECT EXTRACT(MONTH FROM DATE '1998-03-07')

FROM DUAL

EXTRACT(MONTHFROMDATE'1998-03-07')
----------------------------------
3

EXTRACT(DAYFROMDATE'1998-03-07')
--------------------------------
7

L
LA
A
K
S
A
K
VI
CONVERSION SINGLE ROW FUNCTIONS:

1] TO_CHAR():

THIS FUN IS USED TO CONVERT THE GIVEN DATE TO STRING

FORMAT.

L
LA
SYNTAX:

TO_CHAR(DATE, ‘FORMAT MODEL’);

FORMAT_MODELS/TOOLS:
A
1.​YEAR (FULL YEAR IN LETTERS)
K
2.​YYYY (FOUR DIGIT YEAR)
3.​YY (LAST 2 DIGIT YEAR)
4.​MONTH (FULL MONTH)
S

5.​MON (1ST 3 CHAR OF MONTH)

6.​MM (MONTH IN DIGIT)
A

7.​DAY (FULL DAY)

8.​DY (1ST 3 CHAR OF A DAY)
K

9.​DD (THE DATE IN DIGIT)

10.​ D (DAY IN NUMBER)
VI

11.​ HH24 (HOURS IN 24 FORMAT)

12.​ HH12 (HOURS IN 12 FORMAT)
13.​ MI (MINUTES)
14.​ SS (SECONDS)

1] TO_CHAR(SYSDATE, ‘YEAR’)
SQL> SELECT TO_CHAR(SYSDATE,'YEAR')
2 FROM DUAL;

TO_CHAR(SYSDATE,'YEAR')
------------------------------------------
TWENTY TWENTY-THREE

L
2] TO_CHAR(SYSDATE, ‘YYYY’)
​

LA
​
1 SELECT TO_CHAR(SYSDATE,'YYYY')
2* FROM DUAL
SQL> /

TO_C
A
K
----
2024
S

3] TO_CHAR(SYSDATE, ‘YY’)
A

1 SELECT TO_CHAR(SYSDATE,'YY')
K

2* FROM DUAL
SQL> /
VI

TO
--
24

4] TO_CHAR(SYSDATE, ‘MONTH’)
​
1 SELECT TO_CHAR(SYSDATE,'MONTH')
2* FROM DUAL
SQL> /

TO_CHAR(S
---------
MARCH

L
LA
5] TO_CHAR(SYSDATE, ‘MON’)

1 SELECT TO_CHAR(SYSDATE,'MON')
2* FROM DUAL
SQL> /
A
K
TO_
---
S

MAR
A

6] TO_CHAR(SYSDATE, ‘MM’)
​
K

​
1 SELECT TO_CHAR(SYSDATE,'MM')
VI

2* FROM DUAL
SQL> /

TO
--
03
7] TO_CHAR(SYSDATE, ‘DAY’)

1 SELECT TO_CHAR(SYSDATE,'DAY')
2* FROM DUAL
SQL> /

TO_CHAR(S

L
---------
WEDNESDAY

LA
8] TO_CHAR(SYSDATE, ‘DY’)

A
1 SELECT TO_CHAR(SYSDATE,'DY')
2* FROM DUAL
K
SQL> /

TO_
S

---
WED
A

9] TO_CHAR(SYSDATE, ‘DD’)
K
VI

1 SELECT TO_CHAR(SYSDATE,'DD')
2* FROM DUAL
SQL> /

TO
--
06
10] TO_CHAR(SYSDATE, ‘D’)

1 SELECT TO_CHAR(SYSDATE,'D')
2* FROM DUAL
SQL> /

L
T
-

LA
4

11] TO_CHAR(SYSTIMESTAMP, ‘HH24’)

A
1 SELECT TO_CHAR(SYSTIMESTAMP,'HH24')
K
2* FROM DUAL
SQL> /
S

TO
--
A

13
K

12] TO_CHAR(SYSTIMESTAMP, ‘HH12’)

VI

1 SELECT TO_CHAR(SYSTIMESTAMP,'HH12')
2* FROM DUAL
SQL> /

TO
--
01

13] TO_CHAR(SYSTIMESTAMP, ‘MI’)

1 SELECT TO_CHAR(SYSTIMESTAMP,'MI')
2* FROM DUAL
SQL> /

L
TO

LA
--
39

14] TO_CHAR(SYSTIMESTAMP, ‘SS’)

A
K
1 SELECT TO_CHAR(SYSTIMESTAMP,'SS')
2* FROM DUAL
SQL> /
S

TO
A

--
06
K
VI

2] TO_DATE :

The TO_DATE function is used in Oracle to convert a string to a

date.
SYNTAX:

TO_DATE (STRING, [FORMAT] )

EX:

1] SELECT TO_DATE('20100110','YYYY-MM-DD')
FROM DUAL

L
LA
TO_DATE('
---------
10-JAN-10

A
2] SELECT TO_DATE('1999-JAN-05', 'YYYY-MON-DD')
FROM DUAL;
K
TO_DATE('
---------
S

05-JAN-99
A

3] SELECT TO_DATE('2005-12-12', 'YYYY-MM-DD')

FROM DUAL
K

TO_DATE('
VI

---------
12-DEC-05

4] SELECT TO_DATE('01-JULY-99','DD-MON-YY')
FROM DUAL;

TO_DATE('
---------
01-JUL-99

5] SELECT TO_DATE('21-JUL-2023')
FROM DUAL

TO_DATE('

L
---------
21-JUL-23

LA
A
NUMBER SINGLE ROW FUNCTIONS :
K
1] MOD():
S

IT IS A FUN WHICH IS USED TO FIND THE MODULUS OF A GIVEN

NUMBER.
A

SYNTAX: MOD(M,N)
K

EX:
VI

SELECT MOD(7,2)
FROM DUAL;

SQL> SELECT MOD(7,2)

2 FROM DUAL;
 MOD(7,2)
----------
1

2] POWER ( ):

L
The POWER() function returns the value of a number raised to the

LA
power of another number.

SYNTAX:

POWER ( a, b ) A
K
PARAMETER​ ​ ​ DESCRIPTION

​ a​ ​ ​ ​ A number (base)
S

​
​ b​ ​ ​ ​ A number (exponent)
A

Ex :
K

SELECT POWER(2,4)
VI

FROM DUAL;

POWER(2,4)
----------
16

SELECT POWER(5,4)
FROM DUAL;

POWER(5,4)
----------
625

L
3] ROUND( )

LA
The ROUND() function rounds a number to a specified number
of decimal places.

SYNTAX:

ROUND(NUMBER,[SCALE])
A
K
EX:
S

ROUND(234.23) = 234
A

ROUND(234.67) = 235
K
VI

ROUND(235.415,2)
----------------
235.42

SELECT ROUND(235.415)
FROM DUAL;
ROUND(235.415)
--------------
235

SELECT ROUND(235.415,3)
FROM DUAL;

L
ROUND(235.415,3)
----------------

LA
235.415

SELECT ROUND(235.415,6)
FROM DUAL; A
K
ROUND(235.415,6)
----------------
S

235.415
A

SELECT ROUND(235.415,9)
K

FROM DUAL;
VI

ROUND(235.415,9)
----------------
235.415

SELECT ROUND(235.615)
FROM DUAL;
ROUND(235.615)
--------------
236

4] TRUNC( ):

L
The TRUNC() function truncates a number to the specified

LA
number of decimal places.

MAXIMUM 9 VALUES…….

SYNTAX:

TRUNC(NUMBER,[SCALE])
A
K
EX:
S

SELECT TRUNC(235.915)
FROM DUAL;
A

TRUNC(235.915)
K

--------------
235
VI

SELECT TRUNC(235.915,2)
FROM DUAL;

TRUNC(235.915,2)
----------------
235.91
SELECT TRUNC(235.917,2)
FROM DUAL;

TRUNC(235.917,2)
----------------
235.91

L
5] CEIL():

LA
The CEIL() function returns the smallest integer value that is bigger than or
equal to a number.

SYNTAX :

CEIL(NUMBER)
A
K
EX:
S

SELECT CEIL(25.75)
FROM DUAL;
A

CEIL(25.75)
K

-----------
26
VI

SELECT CEIL(25.745)
FROM DUAL;

CEIL(25.745)
------------
26
SELECT CEIL(25.45)
FROM DUAL;

CEIL(25.45)
-----------
26

L
6] FLOOR():

LA
The FLOOR() function returns the largest integer value that is smaller
than or equal to a number.

SYNTAX:

FLOOR(NUMBER) A
K
EX:

SELECT FLOOR(25.45)
S

FROM DUAL;
A

FLOOR(25.45)
------------
25
K

SELECT FLOOR(25.65)
VI

FROM DUAL;

FLOOR(25.65)
------------
25

SELECT FLOOR(27.65)
FROM DUAL;
FLOOR(27.65)
------------
27

L
GENERAL SINGLE ROW FUNCTION:

LA
1] NVL(NULL VALUE LOGIC):

IT CAN ACCEPT 2 ARGUMENTS. A

K
IN ARG1, WE MUST WRITE A COLUMN_NAME OR EXPRESSION
THAT CAN BE NULL.
S

IN ARG2, WE MUST WRITE A VALUE THAT CAN BE

SUBSTITUTED IN PLACE OF NULL.
A

IF ARG1 IS NOT NULL, NVL RETURNS SAME VALUE PRESENT IN

K

THE ARG1.
VI

SYNTAX:

NVL(ARG1,ARG2)
EX WITHOUT NVL:

1] WAQTD TOTAL SAL OF EMP’S.

​ SELECT SAL+COMM
​ FROM EMP;

EX WITH NVL:

L
​ SELECT SAL+NVL(COMM,0)

LA
​ FROM EMP;

A
K
2] NVL2()
S

The Oracle NVL2() function is an extension of the NVL() function with

different options based on whether a NULL value exists.
A

The Oracle NVL2() function accepts three arguments. If the first

argument is not null, then it returns the second argument. In case the
K

second argument is null, then it returns the third argument.

VI

SYNTAX :

NVL2(ARG1, ARG2, ARG3)

EX:
1] WAQTD NAME , COMM OF ALL THE EMP’S IF EMP IS NOT
EARNING ANY COMMISSION PRINT 0 IF EARNING COMM PRINT
1.

SELECT ENAME, NVL2(COMM, 1, 0)

FROM EMP;

L
LA
A
K
S
A
K
VI