Copyright 2012 Steven Feuerstein

PL-SQL FACE LIFTING

THIS PRESENTATION FOCUS ON CHANGES YOU CAN MAKE ONLY IN
YOUR PL/SQL CODE .
NOT :
TUNING SQL STATEMENTS
LIKE EXPLAIN PLANS, HINTS, THE CBO, ETC
CONFIGURING THE DATABASE
THE DBA MUST MAKE SURE THAT ALL OF THE MANY CACHES IN THE
SYSTEM GLOBAL AREA ARE BIG ENOUGH TO AVOID SWAPPING DUE TO
APPLICATION OF THE LEAST RECENTLY USED (LRU) ALGORITHM .
PL-SQL fae !ifting "#!i Lei$a%
Page 1
Copyright 2012 Steven Feuerstein
HIGH PERFORMANCE PL/SQL AGENDA
BULK COLLECT AND FORALL
DATA CACHING
THE NOCOPY HINT
PIPELINED TABLE FUNCTIONS
MOST OF THESE FEATURES RELY ON COLLECTIONS, PL/SQLS ARRAYS
PL-SQL fae !ifting "#!i Lei$a%
Page
2
Copyright 2012 Steven Feuerstein
ORACLE FEATURES AND UTILITIES THAT
ASSIST IN OPTIMI!ATION
MEMORY MANAGEMENT AND PL/SQL CODE
IF YOU ARE NOT CAREFUL, YOU CAN CRASH YOUR SESSION AND/OR
SERVER .
PROFILING EXECUTION OF CODE
IDENTIFY PERFORMANCE BOTTLENECKS
CALCULATING ELAPSED TIME OF EXECUTION
CRITICAL FOR GRANULAR ANALYSIS OF PERFORMANCE AND
COMPARISON OF PERFORMANCE BETWEEN DIFFERENT
IMPLEMENTATIONS OF SAME PROGRAM
PL-SQL fae !ifting "#!i Lei$a%
Page
&
Copyright 2012 Steven Feuerstein
PL/SQL RUNTIME MEMORY ARCHITECTURE
PL-SQL fae !ifting "#!i Lei$a%
Page
'
System Global Area (SGA) of RDBMS Instance
Shared Pool
Large Pool
Reserved Pool
show_emps calc_totals upd_salaries
Select *
from emp
Shared SQL
Pre-parsed
Update emp
Set sal=...
Library cache
Session 1 memory
UG ! User Global rea
PG ! Process Global rea
emp_rec emp%rowtype;
tot_tab pkg.tottabtype;
Session " memory
UG ! User Global rea
PG ! Process Global rea
emp_rec emp%rowtype;
tot_tab pkg.tottabtype;
Session 1
Session "
Copyright 2012 Steven Feuerstein
HOW PL/SQL USES THE SGA, PGA AND UGA

THE SGA CONTAINS INFORMATION THAT CAN BE SHARED

ACROSS SCHEMAS CONNECTED TO THE INSTANCE .

FROM THE PL/SQL PERSPECTIVE, THIS IS LIMITED TO PACKAGE

STATIC CONSTANTS .
THE PROCESS GLOBAL AREA CONTAINS SESSION-SPECIFIC DATA THAT IS RELEASED WHEN THE CURRENT
SERVER CALL TERMINATES .
LOCAL DATA
THE USER GLOBAL AREA CONTAINS SESSION-SPECIFIC DATA THAT PERSISTS ACROSS SERVER CALL
BOUNDARIES

PACKAGE-LEVEL DATA
PL-SQL fae !ifting "#!i Lei$a%
Page
(
PACKAGE Pkg is
Nonstatic_Constant CONSTANT PLS_INTEGER := My_Seqence!Ne"t#a$%
Static_Constant CONSTANT PLS_INTEGER := &'%
EN( Pkg%
Copyright 2012 Steven Feuerstein
PROFILING EXECUTION OF PL/SQL
CODE
TWO PROFILERS :
DBMS"PROFILER# LINE BY LINE PERFORMANCE
DBMS"HPROF# HIERARCHICAL PROFILER, ROLLUP TO PROGRAM UNITS
BOTH HELP IDENTIFY BOTTLENECKS IN YOUR CODE .
RELATIVE PERFORMANCE OF EACH LINE OF CODE IN YOUR PROGRAMS AND
PROGRAM UNIT LEVEL PERFORMANCE
CODE COVERAGE ANALYSIS
PL-SQL fae !ifting "#!i Lei$a%
Page
)
)EGIN
()MS_O*TP*T!P*T_LINE +
()MS_PRO,ILER!START_PRO,ILER +
-.y_a//$ication - 00
TO_C1AR +S2S(ATE3 -2222MM(( 11'&:MI:SS-4
4
4%
5n_yo5_a//$ication%
()MS_PRO,ILER!STOP_PRO,ILER%
EN(%
Copyright 2012 Steven Feuerstein
CALCULATING ELAPSED TIME OF PROGRAMS

MANY OPTIONS FOR ANALY!ING ORACLE PERFORMANCE#

TKPROF, SET TIMING ON, ETC .

BUT THEY USUALLY DON$T OFFER THE GRANULARITY I NEED FOR

MY PL/SQL PERFORMANCE ANALYSIS .

ORACLE OFFERS DBMS"UTILITY%GET"TIME AND GET"CPU"TIME

(&'G) TO COMPUTE ELAPSED TIME DOWN TO THE HUNDREDTH
OF A SECOND .

CAN ALSO USE SYSTIMESTAMP

PL-SQL fae !ifting "#!i Lei$a%
Page
*
(ECLARE
$_sta5t_ti.e PLS_INTEGER%
)EGIN
$_sta5t_ti.e := ()MS_*TILIT2!get_ti.e%
66 (o st77 8e5e!!!
()MS_O*TP*T!/t_$ine +
()MS_*TILIT2!get_ti.e 9 $_sta5t_ti.e4%
EN(%
Copyright 2012 Steven Feuerstein
TURBO-CHARGE SQL WITH
BULK PROCESSING STATEMENTS

IMPROVE THE PERFORMANCE OF REPEATED SQL OPERATIONS

BY AN ORDER OF MAGNITUDE OR MORE WITH BULK/ARRAY
PROCESSING IN PL/SQL +
PL-SQL fae !ifting "#!i Lei$a%
Page
,
CREATE OR REPLACE PROCE(*RE /:_7o5_:e/t +
:e/t_in IN e./$oyee!:e/a5t.ent_i:;T2PE
3ne<sa$_in IN e./$oyee!sa$a5y;T2PE4
IS
C*RSOR e./_c5 IS
SELECT e./$oyee_i:3sa$a5y38i5e_:ate
,ROM e./$oyee =1ERE :e/a5t.ent_i: = :e/t_in%
)EGIN
,OR 5ec IN e./_c5 LOOP
a:>st_co./ensation +5ec3 ne<sa$_in4%
*P(ATE e./$oyee SET sa$a5y = 5ec!sa$a5y
=1ERE e./$oyee_i: = 5ec!e./$oyee_i:%
EN( LOOP%
EN( /:_7o5_:e/t%
Copyright 2012 Steven Feuerstein
ROW BY ROW PROCESSING OF DML IN PL/SQL
PL-SQL fae !ifting "#!i Lei$a%
Page
-
.ra!e server
PL/SQL 0unti1e #ngine
SQL #ngine
PL#SQL bloc$
Procedural
statement
e%ecutor
SQL
statement
e%ecutor
,OR 5ec IN e./_c5 LOOP
*P(ATE e./$oyee
SET sa$a5y = !!!
=1ERE e./$oyee_i: =
5ec!e./$oyee_i:%
EN( LOOP%
Performance penalty Performance penalty
for many context for many context
switches switches
Copyright 2012 Steven Feuerstein
BULK PROCESSING WITH FORALL
PL-SQL fae !ifting "#!i Lei$a%
Page
10
.ra!e server
PL/SQL 0unti1e #ngine
SQL #ngine
PL#SQL bloc$
Procedural
statement
e%ecutor
SQL
statement
e%ecutor
,ORALL in:" IN
$ist_o7_e./s!,IRST!!
$ist_o7_e./s!LAST
*P(ATE e./$oyee
SET sa$a5y = !!!
=1ERE e./$oyee_i: =
$ist_o7_e./s+in:"4%
Fewer context switches, Fewer context switches,
same SQL behavior same SQL behavior
Update&&&
Update&&&
Update&&&
Update&&&
Update&&&
Update&&&
Update&&&
Update&&&
Update&&&
Update&&&
Update&&&
Update&&&
Copyright 2012 Steven Feuerstein
BULK PROCESSING IN PL/SQL
FORALL

USE WITH INSERTS, UPDATES AND DELETES .

MOVE DATA FROM COLLECTIONS TO TABLES .

BULK COLLECT

USE WITH IMPLICIT AND EXPLICIT QUERIES .

MOVE DATA FROM TABLES INTO COLLECTIONS .

IN BOTH CASES, THE (BACK BACK( END PROCESSING IN THE SQL ENGINE IS
UNCHANGED .

SAME TRANSACTION AND ROLLBACK SEGMENT

MANAGEMENT

SAME NUMBER OF INDIVIDUAL SQL STATEMENTS WILL BE

EXECUTED .

BUT BEFORE AND AFTER STATEMENT-LEVEL TRIGGERS

ONLY FIRE ONCE PER FORALL STATEMENT .
PL-SQL fae !ifting "#!i Lei$a%
Page
11
Copyright 2012 Steven Feuerstein
USE BULK COLLECT INTO FOR QUERIES
PL-SQL fae !ifting "#!i Lei$a%
Page
12
(ECLARE
T2PE e./$oyees_aat IS TA)LE O, e./$oyees
;RO=T2PE
IN(E? )2 )INAR2_INTEGER%
$_e./$oyees e./$oyees_aat%
)EGIN
SELECT @
)*LK COLLECT INTO $_e./$oyees ,ROM
e./$oyees%

,OR in:" IN A !! $_e./$oyees!CO*NT
LOOP
/5ocess_e./$oyee +$_e./$oyees+in:"44%
EN( LOOP%
EN(%
'eclare a
collection o(
records to hold
the )ueried data&
Use *UL+
,-LL.,/ to
retrieve all rows&
0terate through
the collection
contents with a
loop&
*UL+ ,-LL.,/ will not raise
1-_'/_2-U1' i( no rows are (ound&
,ollection is always (illed se)uentially starting
(rom inde% value 1&
Copyright 2012 Steven Feuerstein
LIMIT THE NUMBER OF ROWS RETURNED BY BULK
COLLECT
PL-SQL fae !ifting "#!i Lei$a%
Page
1&
CREATE OR REPLACE PROCE(*RE B$k_<it8_$i.it
+:e/tno_in IN :e/t!:e/tno;T2PE4
IS
C*RSOR e./s_in_:e/t_c5 IS
SELECT @ ,ROM e./
=1ERE :e/tno = :e/tno_in%
T2PE e./_tt IS TA)LE O,
e./s_in_:e/t_c5;RO=T2PE%
e./s e./_tt%
)EGIN
OPEN e./s_in_:e/t_c5%
LOOP
,ETC1 e./s_in_:e/t_c5
)*LK COLLECT INTO e./s LIMIT ACCC%
E?IT =1EN e./s!CO*NT = C%
/5ocess_e./s +e./s4%
EN( LOOP%
EN( B$k_<it8_$i.it%
Use the L030/ clause with the
01/- to manage the amount o(
memory used with the *UL+
,-LL.,/ operation&
'e(initely the pre(erred
approach in production
applications with large or
varying datasets&
lways chec$ the contents o(
the collection4 as opposed to
the 51-/2-U1' attributes4 to
determine i( you (etched and
processed all rows&
Copyright 2012 Steven Feuerstein
USE THE FORALL BULK BIND STATEMENT
INSTEAD OF EXECUTING REPETITIVE, INDIVIDUAL DML STATEMENTS, YOU CAN
WRITE YOUR CODE LIKE THIS :
THINGS TO BE AWARE OF WHEN USING FORALL :
YOU MUST KNOW HOW TO USE COLLECTIONS TO USE THIS FEATURE 6
ONLY A SINGLE DML STATEMENT IS ALLOWED PER FORALL &
YOU CAN USE STATIC AND DYNAMIC SQL WITH FORALL &
PL-SQL fae !ifting "#!i Lei$a%
Page
1'
PROCE(*RE /:_7o5_:e/t +!!!4 IS
)EGIN
,ORALL in:" IN $ist_o7_e./s!,IRST !!
$ist_o7_e./s!LAST
*P(ATE e./$oyee
SET sa$a5y = ne<sa$_in
=1ERE e./$oyee_i: = $ist_o7_e./s +in:"4%
EN(%
Copyright 2012 Steven Feuerstein
KEY FEATURES AND LIMITATIONS OF FORALL

USE SQL)BULK"ROWCOUNT TO DETERMINE THE NUMBER OF

ROWS MODIFIED BY EACH STATEMENT EXECUTED%
SQL)ROWCOUNT RETURNS TOTAL NUMBER OF ROWS MODIFIED BY
THE ENTIRE FORALL .

USE SAVE"EXCEPTIONS AND SQL)BULK"EXCEPTIONS TO

CONTINUE PAST EXCEPTIONS IN ANY OF THE STATEMENTS .
GRANULAR ERROR RECOVERY AND LOGGING

THE BINDING ARRAY MUST BE SEQUENTIALLY FILLED

THROUGH ORACLE *I .
IN ORACLE&'G, USE INDICES OF OR VALUES OF .

YOU CANNOT REFERENCE FIELDS OF COLLECTIONS OF

RECORDS WITHIN THE DML STATEMENT .
PL-SQL fae !ifting "#!i Lei$a%
Page
1(
Copyright 2012 Steven Feuerstein
FROM OLD+FASHIONED TO MODERN
CODE
TRADITIONAL PL/SQL CODE OFTEN INVOLVES A CURSOR FOR LOOP
AND MULTIPLE DML STATEMENTS INSIDE THE LOOP .
AN INTEGRATED, ROW-BY-ROW APPROACH WITH THE OPTION OF
TRAPPING AND CONTINUING PAST EXCEPTIONS .
ELEGANT AND FLEXIBLE, BUT SLOW .
BULK PROCESSING MEANS A SWITCH TO (PHASED APPROACH 2.
PHASE &# RETRIEVE DATA WITH BULK COLLECT
PHASE ,# PREPARE DATA IN COLLECTIONS
PHASES - + N# EXECUTE A FORALL FOR EACH DML STATEMENT
PL-SQL fae !ifting "#!i Lei$a%
Page
1)
Copyright 2012 Steven Feuerstein
BULK PROCESSING CONCLUSIONS
MOST IMPORTANT PERFORMANCE TUNING FEATURE IN PL/SQL .
ALMOST ALWAYS THE FASTEST WAY TO EXECUTE MULTI-ROW SQL
OPERATIONS IN PL/SQL .
YOU TRADE OFF INCREASED COMPLEXITY OF CODE FOR
DRAMATICALLY FASTER EXECUTION .
BUT IN ORACLE DATABASE &'G AND ABOVE, THE COMPILER WILL
AUTOMATICALLY OPTIMI!E CURSOR FOR LOOPS TO BULK COLLECT
EFFICIENCY .
NO NEED TO CONVERT UNLESS THE LOOP CONTAINS DML .
WATCH OUT FOR THE IMPACT ON PGA/UGA MEMORY +
PL-SQL fae !ifting "#!i Lei$a%
Page
1*
Copyright 2012 Steven Feuerstein
DATA CACHING OPTIONS
WHY CACHE DATA 3
BECAUSE IT IS STATIC AND THEREFORE YOU WANT TO AVOID THE
PERFORMANCE OVERHEAD OF RETRIEVING THAT DATA OVER AND OVER
AGAIN .
OPTIONS FOR CACHING DATA :
THE SGA# ORACLE DOES LOTS OF CACHING FOR US, BUT IT IS NOT
ALWAYS THE MOST EFFICIENT MEANS .
PACKAGE DATA STRUCTURES# PGA MEMORY HAS LESS ACCESS
OVERHEAD THAN SGA .
ORACLE&&G FUNCTION RESULT CACHE
DETERMINISTIC FUNCTIONS
PL-SQL fae !ifting "#!i Lei$a%
Page
1,
Copyright 2012 Steven Feuerstein
PACKAGED COLLECTION CACHING

PRIOR TO ORACLE &&G, THE BEST CACHING OPTION FOR PL/SQL

PROGRAMS INVOLVES DECLARING A PACKAGE-LEVEL DATA
STRUCTURE .
IT PERSISTS FOR THE ENTIRE SESSION .
USUALLY A COLLECTION, TO STORE MULTIPLE ROWS OF DATA .

WHY QUERY INFORMATION FROM THE DATABASE (SGA) IF THAT

DATA DOES NOT CHANGE DURING YOUR SESSION 3
TRIVIAL EXAMPLE# THE USER FUNCTION
MORE INTERESTING# STATIC TABLES, USUALLY LOOKUP OR REFERENCE
CODE TABLES .

INSTEAD, LOAD IT UP IN A PACKAGE VARIABLE +

PL-SQL fae !ifting "#!i Lei$a%
Page
1-
Copyright 2012 Steven Feuerstein
DATA CACHING WITH PL/SQL COLLECTIONS
PL-SQL fae !ifting "#!i Lei$a%
Page
20
Function
PGA
First access
Subsequent accesses
PGA
Function
Database
/ SGA
Not in cache;
Request data
from database
Pass Data
to Cache
Application
Application
Requests Data
Data retrieved
from cache
Data returned
to application
Application
Application
Requests Data
Data returned
to application
Data retrieved
from cache
Database
/ SGA
Data found in
cache. Database
is not needed.
Copyright 2012 Steven Feuerstein
PGA CACHING# THINGS TO KEEP IN
MIND
MUST USE PACKAGE-LEVEL DATA SO THAT IT PERSISTS .

MEMORY IS CONSUMED BY THE PGA AND SO IS

MULTIPLIED FOR ALL USERS OF THE APPLICATION .
CACHE CANNOT BE SHARED ACROSS SESSIONS PRACTICALLY SPEAKING .
VERY DIFFICULT TO UPDATE THE CACHE ONCE THE DATA SOURCE IS
CHANGED .

ESPECIALLY BY OTHER SESSIONS .

USEFUL UNDER SPECIFIC SCENARIOS ....

SMALL, STATIC DATASET OR RUNNING BATCH PROCESS

PL-SQL fae !ifting "#!i Lei$a%
Page
21
Copyright 2012 Steven Feuerstein
THE ORACLE &&G FUNCTION RESULT CACHE
ORACLE OFFERS A FAR SUPERIOR CACHING SOLUTION IN &&G# THE
FUNCTION RESULT CACHE .
THIS CACHE IS ...
STORED IN THE SGA
SHARED ACROSS SESSIONS
PURGED OF DIRTY DATA AUTOMATICALLY
YOU CAN USE AND SHOULD USE IT TO RETRIEVE DATA FROM ANY TABLE
THAT IS QUERIED MORE FREQUENTLY THAN UPDATED .
PL-SQL fae !ifting "#!i Lei$a%
Page
22
Copyright 2012 Steven Feuerstein
HOW THE FUNCTION RESULT CACHE WORKS
ADD THE RESULT"CACHE CLAUSE TO YOUR FUNCTION$S HEADER .
WHEN A CALL IS MADE TO FUNCTION, ORACLE COMPARES IN
ARGUMENT VALUES TO THE CACHE .
IF NO MATCH, THE FUNCTION IS EXECUTED AND THE INPUTS AND
RETURN DATA ARE CACHED .
IF A MATCH IS FOUND, THE FUNCTION IS NOT EXECUTED. CACHED DATA
IS RETURNED .
IF CHANGES TO A (RELIES ON( TABLE ARE COMMITTED, THE CACHE IS
MARKED INVALID AND WILL BE RE-BUILT .
PL-SQL fae !ifting "#!i Lei$a%
Page
2&
Copyright 2012 Steven Feuerstein
FUNCTION RESULT CACHE EXAMPLE
PL-SQL fae !ifting "#!i Lei$a%
Page
2'
CREATE OR REPLACE PACKAGE e./$AAg
IS
,*NCTION one5o< +e./$oyee_i:_in IN e./$oyees!e./$oyee_i:;T2PE4
RET*RN e./$oyees;RO=T2PE
RES*LT_CAC1E%
EN( e./$AAg%
CREATE OR REPLACE PACKAGE )O(2 e./$AAg
IS
,*NCTION one5o< +e./$oyee_i:_in IN e./$oyees!e./$oyee_i:;T2PE4
RET*RN e./$oyees;RO=T2PE
RES*LT_CAC1E RELIES_ON +e./$oyees4
IS
one5o<_5ec e./$oyees;RO=T2PE%
)EGIN
SELECT @ INTO one5o<_5ec
,ROM e./$oyees
=1ERE e./$oyee_i: = e./$oyee_i:_in%
RET*RN one5o<_5ec%
EN( one5o<%
EN( e./$AAg%
Copyright 2012 Steven Feuerstein
RESULT CACHE + THINGS TO KEEP IN MIND - &
IF YOU HAVE UNCOMMITTED CHANGES IN YOUR SESSION, DEPENDENT
CACHES ARE IGNORED .
THE CACHE WILL NOT OVERRIDE YOUR OWN CHANGED DATA .
CACHING IS NOT PERFORMED FOR COMPLEX TYPES# RECORDS WITH
CLOBS, COLLECTIONS, ETC .
THE CACHE IS NOT RELATED TO SQL STATEMENTS IN YOUR FUNCTION .
IT ONLY KEEPS TRACK OF THE INPUT VALUES AND THE RETURN CLAUSE
DATA .
PL-SQL fae !ifting "#!i Lei$a%
Page
2(
Copyright 2012 Steven Feuerstein
RESULT CACHE + THINGS TO KEEP IN MIND - ,
YOU CANNOT USE THE RESULT CACHE WITH INVOKER RIGHTS PROGRAM
UNITS .
BYPASS EXECUTION OF FUNCTION BODY, ORACLE CANNOT RESOLVE
REFERENCES TO OB/ECTS - THE WHOLE POINT OF IR .
FUNCTIONS WITH SESSION-SPECIFIC DEPENDENCIES MUST BE (RESULT-
CACHED( WITH GREAT CARE .
VIRTUAL PRIVATE DATABASE CONFIGURATIONS
REFERENCES TO SYSDATE, RELIANCE ON NLS"DATE"FORMAT, TIME !ONE
CHANGES
APPLICATION CONTEXTS
SOLUTION# MOVE ALL DEPENDENCIES INTO PARAMETER LIST .
PL-SQL fae !ifting "#!i Lei$a%
Page
2)
Copyright 2012 Steven Feuerstein
TUNING THE RESULT CACHE
ORACLE OFFERS A NUMBER OF WAYS TO MANAGE THE RESULT
CACHE AND TUNE IT TO YOUR SPECIFIC APPLICATION NEEDS :
RESULT"CACHE"SI!E INITIALI!ATION PARAMETER
DBMS"RESULT"CACHE MANAGEMENT PACKAGE
V0RESULT"CACHE"1 PERFORMANCE VIEWS
PL-SQL fae !ifting "#!i Lei$a%
Page
2*
Copyright 2012 Steven Feuerstein
DETERMINISTIC FUNCTIONS (CACHING IN ALL
VERSIONS OF ORACLE %
DETERMINISTIC# THE FUNCTION$S RETURN VALUE IS DETERMINED
COMPLETELY BY ITS INPUTS .
SAME INPUTS, SAME RETURN VALUE .
NO SIDE EFFECTS (SQL, FOR EXAMPLE %.
FUNCTION-BASED INDEXES ARE BASED ON DETERMINISTIC FUNCTIONS .
RESULTS OF DETERMINISTIC FUNCTIONS CALLED WITHIN A SQL
STATEMENT WILL BE CACHED .
PASS IN THE SAME INPUTS, AND ORACLE WILL NOT EXECUTE THE
FUNCTION .
PL-SQL fae !ifting "#!i Lei$a%
Page
2,
Copyright 2012 Steven Feuerstein
LOOK FOR OPPORTUNITIES TO CACHE +
WHETHER YOU ARE ON *I, &'G OR &&G, YOU SHOULD ALWAYS
LOOK FOR OPPORTUNITIES TO CACHE .
ARE THERE TABLES THAT ARE ALWAYS STATIC DURING USER SESSIONS 3
ARE THERE TABLES THAT ARE QUERIED MUCH MORE FREQUENTLY THAN
THEY ARE CHANGED 3
APPLY THE MOST APPROPRIATE TECHNIQUE, BUT DON$T LEAVE THE
USERS WAITING ...
PL-SQL fae !ifting "#!i Lei$a%
Page
2-
Copyright 2012 Steven Feuerstein
SPECIALI!ED PERFORMANCE
ENHANCEMENTS
THERE ARE A WHOLE RANGE OF TECHNIQUES FOR IMPROVING
PL/SQL EXECUTION THAT WILL LIKELY ONLY HELP YOU IN MORE
(EXTREME( CIRCUMSTANCES .
THE NOCOPY HINT
TAKE ADVANTAGE OF PIPELINED TABLE FUNCTIONS
PL-SQL fae !ifting "#!i Lei$a%
Page
&0
Copyright 2012 Steven Feuerstein
THE NOCOPY HINT
BY DEFAULT, ORACLE PASSES ALL OUT AND IN OUT ARGUMENTS BY
VALUE, NOT REFERENCE .
THIS MEANS THAT OUT AND IN OUT ARGUMENTS ALWAYS INVOLVE
SOME COPYING OF DATA .
ALL IN ARGUMENTS ARE ALWAYS PASSED BY REFERENCE (NO COPYING %.
WITH NOCOPY, YOU TURN OFF THE COPY PROCESS .
BUT IT COMES WITH A RISK# ORACLE WILL NOT AUTOMATICALLY
(ROLLBACK( OR REVERSE CHANGES MADE TO YOUR VARIABLES IF THE
NOCOPY-ED PROGRAM RAISES AN EXCEPTION .
PL-SQL fae !ifting "#!i Lei$a%
Page
&1
Copyright 2012 Steven Feuerstein
PIPELINED TABLE FUNCTIONS
A TABLE FUNCTION IS A FUNCTION THAT YOU CAN CALL IN THE
FROM CLAUSE OF A QUERY, AND HAVE IT BE TREATED AS IF IT WERE A
RELATIONAL TABLE .
TABLE FUNCTIONS ALLOW YOU TO PERFORM ARBITRARILY COMPLEX
TRANSFORMATIONS OF DATA AND THEN MAKE THAT DATA AVAILABLE
THROUGH A QUERY# (/UST( ROWS AND COLUMNS +
NOT EVERYTHING CAN BE DONE IN SQL .
COMBINED WITH CURSOR VARIABLES, YOU CAN NOW MORE EASILY
TRANSFER DATA FROM WITHIN PL/SQL TO HOST ENVIRONMENTS .
/AVA, FOR EXAMPLE, CAN FETCH NATIVELY FROM A CURSOR VARIABLE .
PL-SQL fae !ifting "#!i Lei$a%
Page
&2
Copyright 2012 Steven Feuerstein
BUILDING A TABLE FUNCTION
A TABLE FUNCTION MUST RETURN A NESTED TABLE OR VARRAY BASED
ON A SCHEMA-DEFINED TYPE .
TYPES DEFINED IN A PL/SQL PACKAGE CAN ONLY BE USED WITH PIPELINED
TABLE FUNCTIONS .
THE FUNCTION HEADER AND THE WAY IT IS CALLED MUST BE SQL-
COMPATIBLE# ALL PARAMETERS USE SQL TYPES. NO NAMED NOTATION .
IN SOME CASES (STREAMING AND PIPELINED FUNCTIONS), THE IN
PARAMETER MUST BE A CURSOR VARIABLE -- A QUERY RESULT SET .
PL-SQL fae !ifting "#!i Lei$a%
Page
&&
Copyright 2012 Steven Feuerstein
STREAMING DATA WITH TABLE FUNCTIONS
YOU CAN USE TABLE FUNCTIONS TO (STREAM( DATA THROUGH SEVERAL
STAGES WITHIN A SINGLE SQL STATEMENT .
EXAMPLE# TRANSFORM ONE ROW IN THE STOCKTABLE TO TWO ROWS IN THE
TICKERTABLE .
PL-SQL fae !ifting "#!i Lei$a%
Page
&'
CREATE TA)LE stocktaB$e +
ticke5 DARC1AR'+'C43
t5a:e_:ate (ATE3
o/en_/5ice N*M)ER3
c$ose_/5ice N*M)ER
4
CREATE TA)LE ticke5taB$e +
ticke5 DARC1AR'+'C43
/5ice:ate (ATE3
/5icety/e DARC1AR'+A43
/5ice N*M)ER
4
Copyright 2012 Steven Feuerstein
USE PIPELINED FUNCTIONS TO ENHANCE
PERFORMANCE .
PIPELINED FUNCTIONS ALLOW YOU TO RETURN DATA ITERATIVELY,
ASYNCHRONOUS TO TERMINATION OF THE FUNCTION .
AS DATA IS PRODUCED WITHIN THE FUNCTION, IT IS PASSED BACK TO THE
CALLING PROCESS/QUERY .
PIPELINED FUNCTIONS CAN ONLY BE CALLED WITHIN A SQL STATEMENT .
THEY MAKE NO SENSE WITHIN NON-MULTI-THREADED PL/SQL BLOCKS .
PL-SQL fae !ifting "#!i Lei$a%
Page
&(
CREATE ,*NCTION StockPi#ot +/ 5e7c5_/kg!5e7c5_t4
RET*RN Ticke5Ty/eSet PIPELINE(
Copyright 2012 Steven Feuerstein
APPLICATIONS FOR PIPELINED
FUNCTIONS
EXECUTION FUNCTIONS IN PARALLEL .
IN ORACLE*I DATABASE RELEASE , AND ABOVE, USE THE PARALLEL"ENABLE
CLAUSE TO ALLOW YOUR PIPELINED FUNCTION TO PARTICIPATE FULLY IN A
PARALLELI!ED QUERY .
CRITICAL IN DATA WAREHOUSE APPLICATIONS .
IMPROVE SPEED OF DELIVERY OF DATA TO USER INTERFACES .
USE A PIPELINED FUNCTION TO (SERVE UP( DATA TO THE WEBPAGE AND
ALLOW USERS TO BEGIN VIEWING AND BROWSING, EVEN BEFORE THE
FUNCTION HAS FINISHED RETRIEVING ALL OF THE DATA .
AND PIPELINED FUNCTIONS USE LESS PGA MEMORY THAN NON-PIPELINED
FUNCTIONS +
PL-SQL fae !ifting "#!i Lei$a%
Page
&)
Copyright 2012 Steven Feuerstein
PIPING ROWS OUT FROM A PIPELINED
FUNCTION
PL-SQL fae !ifting "#!i Lei$a%
Page
&*
CREATE ,*NCTION stock/i#ot +/ 5e7c5_/kg!5e7c5_t4
RET*RN ticke5ty/eset
PIPELINE(
IS
ot_5ec ticke5ty/e :=
ticke5ty/e +N*LL3 N*LL3 N*LL4%
in_5ec /;RO=T2PE%
)EGIN
LOOP
,ETC1 / INTO in_5ec%
E?IT =1EN /;NOT,O*N(%
ot_5ec!ticke5 := in_5ec!ticke5%
ot_5ec!/5icety/e := -O-%
ot_5ec!/5ice := in_5ec!o/en/5ice%
PIPE RO= +ot_5ec4%
EN( LOOP%
CLOSE /%
RET*RN%
EN(%
dd P0P.L01.'
$eyword to header
Pipe a row o( data
bac$ to calling bloc$
or )uery
R./UR1&&&nothing at
all6
Copyright 2012 Steven Feuerstein
ENABLING PARALLEL EXECUTION
YOU CAN USE PIPELINED FUNCTIONS WITH THE PARALLEL QUERY OPTION
TO AVOID SERIALI!ATION OF TABLE FUNCTION EXECUTION .
INCLUDE THE PARALLEL"ENABLE HINT IN THE PROGRAM HEADER .
CHOOSE A PARTITION OPTION THAT SPECIFIES HOW THE FUNCTION$S
EXECUTION SHOULD BE PARTITIONED .
2 ANY( MEANS THAT THE RESULTS ARE INDEPENDENT OF THE ORDER IN WHICH
THE FUNCTION RECEIVES THE INPUT ROWS (THROUGH THE REF CURSOR %.
PL-SQL fae !ifting "#!i Lei$a%
Page
&,
EFOR(ER 0 CL*STERG )2 co$.n_$istH
PARALLEL_ENA)LE +EPARTITION / )2
FAN2 0 +1AS1 0 RANGE4 co$.n_$istGH 4
Copyright 2012 Steven Feuerstein
TABLE FUNCTIONS - SUMMARY
TABLE FUNCTIONS OFFER SIGNIFICANT NEW FLEXIBILITY FOR PL/SQL
DEVELOPERS .
PIPELINED TABLE FUNCTIONS ADD PERFORMANCE ON TOP OF THAT
FLEXIBILITY .
CONSIDER USING THEM WHEN YOU ...
NEED TO PASS BACK COMPLEX RESULT SETS OF DATA THROUGH THE SQL
LAYER (A QUERY %4
WANT TO CALL A USER DEFINED FUNCTION INSIDE A QUERY AND
EXECUTE IT AS PART OF A PARALLEL QUERY .
PL-SQL fae !ifting "#!i Lei$a%
Page
&-
Copyright 2012 Steven Feuerstein
HIGH PERFORMANCE PL/SQL + A
SUMMARY
MAKE SURE YOU TAKE ADVANTAGE OF THE MOST IMPORTANT
OPTIMI!ATION FEATURES :
BULK COLLECT AND FORALL
CACHED DATA
PRIORITI!E MAINTAINABILITY OF CODE OVER OBSESSIVELY OPTIMI!ED
CODE .
THEN IDENTIFY BOTTLENECKS AND APPLY THE MORE SPECIALI!ED
OPTIMI!ATION TECHNIQUES .
PL-SQL fae !ifting "#!i Lei$a%
Page
'0