SINGLE ROW FUNCTION:
SRF:
● SRF EXECUTES ROW BY ROW
● IT TAKES 1 IP EXECUTES & GENERATE 1 OP THEN GOES TO NEXT IP
● IF WE PASS N NUMBER OF IP’S TO SRF, IT RETURNS N NUMBER OF OP’S.
DUAL:
IT IS A DUMMY TABLE THAT IS PRESENT IN ALL THE
DATABASE TO PERFORM ANY OPERATIONS.
LOWER():
THIS IS FUN IS USED TO CONVERT THE STRING FROM UPPER
CASE TO LOWER CASE.
SYNTAX: LOWER(‘STRING’)
EX:
SELECT LOWER(‘VIKAS’)
FROM DUAL;
SQL> SELECT LOWER('VIKAS')
2 FROM DUAL;
LOWER
-----
vikas
UPPER():
THIS IS USED TO CONVERT THE STRING FROM LOWER CASE
TO UPPER CASE.
SYNTAX:
UPPER(‘string’)
EX:
Select upper(‘vikas’)
From dual;
SQL> select upper('vikas')
2 from dual;
UPPER
VIKAS
INITCAP():
THIS FUN IS USED TO CONVERT THE INITIAL CHARACTER INTO
UPPER CASE.
SYNTAX: INITCAP(‘STRING’)
EX:
SELECT INITCAP(‘VIKAS’)
FROM DUAL;
SQL> SELECT INITCAP('VIKAS')
2 FROM DUAL;
INITC
-----
Vikas
REVERSE():
THIS FUN IS USED TO REVERSE THE STRING.
SYNTAX:
REVERSE(‘STRING’)
EX:
SELECT REVERSE(‘VIKAS’)
FROM DUAL;
SQL> SELECT REVERSE('VIKAS')
2 FROM DUAL;
REVER
-----
SAKIV
LENGTH():
THIS FU IS USED TO FIND THE NUMBER OF CHARACTERS IN A
GIVEN STRING.
SYNTAX: LENGTH(‘STRING’)
EX:
SELECT LENGTH(‘VIKAS’)
FROM DUAL;SQL> SELECT LENGTH('VIKAS')
2 FROM DUAL;
LENGTH('VIKAS')
---------------
5
SUBSTR():
THIS FUN IS USED TO EXTRACT THE PART OF THE STRING
FROM THE ORIGINAL STRING.
SYNTAX:
SUBSTR(‘ORIGINAL_STRING’, POSITION,[LENGTH])
EX:
SELECT SUBSTR(‘BENGALURU’,1,3)
SQL> SELECT SUBSTR('BENGALURU',1,3)
2 FROM DUAL;
SUB
---
BEN
SELECT SUBSTR(‘BENGALURU’,3,2) // NG
SYSDATE:
IT IS USED TO FIND THE DATE PRESENT IN THE SYSTEM.
SYNTAX: SELECT SYSDATE
FROM DUAL;
SQL> SELECT SYSDATE
2 FROM DUAL;
SYSDATE
---------
23-FEB-23
SYSTIMESTAMP:
THIS FUN IS USED TO FIND THE DATE & TIME ALONG WITH TIME
ZONE.
SYNTAX: SELECT SYSTIMESTAMP
FROM DUAL;
SQL> SELECT SYSTIMESTAMP
2 FROM DUAL;
SYSTIMESTAMP
---------------------------------------------------------------------------
23-FEB-23 05.24.46.472000 PM +05:30
TO_CHAR():
THIS FUN IS USED TO CONVERT THE GIVEN DATE TO STRING
FORMAT.
SYNTAX:
TO_CHAR(DATE, ‘FORMAT_MODELS’);
FORMAT_MODELS/TOOLS:
1. YEAR
2. YYYY
3. YY
4. MONTH
5. MON
6. MM
7. DAY
8. DY
9. DD
10. D
11. HH24
12. HH12
13. MI
14. SS
1] TO_CHAR(SYSDATE, ‘YEAR’)
SQL> SELECT TO_CHAR(SYSDATE,'YEAR')
2 FROM DUAL;
TO_CHAR(SYSDATE,'YEAR')
------------------------------------------
TWENTY TWENTY-THREE
2] TO_CHAR(SYSDATE, ‘YYYY’)
1 SELECT TO_CHAR(SYSDATE,'YYYY')
2* FROM DUAL
SQL> /
TO_C
----
2023
3] TO_CHAR(SYSDATE, ‘YY’)
1 SELECT TO_CHAR(SYSDATE,'YY')
2* FROM DUAL
SQL> /
TO
--
23
4] TO_CHAR(SYSDATE, ‘MONTH’)
1 SELECT TO_CHAR(SYSDATE,'MONTH')
2* FROM DUAL
SQL> /
TO_CHAR(S
---------
FEBRUARY
5] TO_CHAR(SYSDATE, ‘MONTH’)
1 SELECT TO_CHAR(SYSDATE,'MON')
2* FROM DUAL
SQL> /
TO_
---
FEB
6] TO_CHAR(SYSDATE, ‘MM’)
1 SELECT TO_CHAR(SYSDATE,'MM')
2* FROM DUAL
SQL> /
TO
--
02
7] TO_CHAR(SYSDATE, ‘DAY’)
1 SELECT TO_CHAR(SYSDATE,'DAY')
2* FROM DUAL
SQL> /
TO_CHAR(S
---------
THURSDAY
8] TO_CHAR(SYSDATE, ‘DD’)
1 SELECT TO_CHAR(SYSDATE,'DD')
2* FROM DUAL
SQL> /
TO
--
23
9] TO_CHAR(SYSDATE, ‘D’)
1 SELECT TO_CHAR(SYSDATE,'D')
2* FROM DUAL
SQL> /
T
-
5
10] TO_CHAR(SYSDATE, ‘HH24’)
1 SELECT TO_CHAR(SYSDATE,'HH24')
2* FROM DUAL
SQL> /
TO
--
17
11] TO_CHAR(SYSDATE, ‘HH24’)
1 SELECT TO_CHAR(SYSDATE,'HH12')
2* FROM DUAL
SQL> /
TO
--
05
12] TO_CHAR(SYSDATE, ‘HH24’)
1 SELECT TO_CHAR(SYSDATE,'MI')
2* FROM DUAL
SQL> /
TO
--
39
13] TO_CHAR(SYSDATE, ‘SS’)
1 SELECT TO_CHAR(SYSDATE,'SS')
2* FROM DUAL
SQL> /
TO
--
06
14] TO_CHAR(SYSDATE, ‘DY’)
1 SELECT TO_CHAR(SYSDATE,'DY')
2* FROM DUAL
SQL> /
TO_
---
THU
INSTR():
THIS FUN IS USED TO FIND THE INDEX VALUE OF THE
SUBSTRING WHICH IS PRESENT IN THE ORIGINAL STRING.
(INDEX VALUE- POSITION OF THE CHARACTER).
SYNTAX:
INSTR(‘ORIGINAL_STRING’, ‘SUB_STR’,POSITION,[NTH
OCCURANCE])
EX:
BANANA
INSTR(‘BANANA’, ‘A’, 1,1)
SQL> SELECT INSTR('BANANA','A',1,1)
2 FROM DUAL;
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)
-----------------------
4
NVL(NULL VALUE LOGIC):
IT CAN ACCEPT 2 ARGUMENTS.
IN ARG1, WE MUST WRITE A COLUMN_NAME OR EXPRESSION
THAT CAN BE NULL.
IN ARG2, WE MUST WRITE A VALUE THAT CAN BE
SUBSTITUTED IN PLACE OF NULL.
IF ARG1 IS NOT NULL, NVL RETURNS SAME VALUE PRESENT IN
THE ARG.
SYNTAX:
NVL(ARG1,ARG2)
1] WAQTD TOTAL SAL OF EMP’S.
SELECT SAL+COMM
FROM EMP;
SELECT SAL+NVL(COMM,0)
FROM EMP;
MOD():
IT IS A FUN WHICH IS USED TO FIND THE MODULUS OF A GIVEN
NUMBER.
SYNTAX: MOD(M,N)
EX:
SELECT MOD(7,2)
FROM DUAL;
SQL> SELECT MOD(7,2)
2 FROM DUAL;
MOD(7,2)
----------
1
REPLACE():
THIS FUN IS USED TO REPLACE THE SUBSTRING WITH NEW
STRING IN GIVEN ORIGINAL STRING.
SYNTAX:
REPLACE(‘ORIGINAL_STRING’, ‘SUB_STR’, [‘NEW_STRING’])
EX:
SELECT REPLACE (‘QSPIDERS’,’S’,’J’)
FROM DUAL;
1 SELECT REPLACE ('QSPIDERS','S','J')
2* FROM DUAL
SQL> /
REPLACE(
--------
QJPIDERJ
1 SELECT REPLACE ('QSPIDERS','Q','J')
2* FROM DUAL
SQL> /
REPLACE(
--------
JSPIDERS
1 SELECT REPLACE ('QSPIDERS','Q')
2* FROM DUAL
SQL> /
REPLACE
-------
SPIDERS
