PL/SQL XMLType operation performance - oracle

Question

I have a PL/SQL function to parse my XML block and return it into a VARCHAR variable.
My XML block is not too complex. Have only 14 tags and don't have any repeating structure.
Inside my function I made this XMLType operation:
SELECT px_Header
|| 'R5'
|| RPAD (NVL (A1, ' '), 2)
|| RPAD (NVL (A2, ' '), 10)
|| RPAD (NVL (A3, ' '), 3)
|| RPAD (NVL (A4, ' '), 1)
|| RPAD (NVL (A5, ' '), 1)
|| RPAD (NVL (A6, ' '), 10)
|| RPAD (NVL (A7, ' '), 1)
|| RPAD (NVL (A8, ' '), 8)
|| RPAD (NVL (A9, ' '), 1)
|| RPAD (NVL (A10, ' '), 16)
|| RPAD (NVL (A11, ' '), 2)
|| RPAD (NVL (A12, ' '), 8)
|| RPAD (NVL (A13, ' '), 1)
|| RPAD (NVL (A14, ' '), 1)
|| CHR (13)
|| CHR (10)
INTO lv_return
FROM XMLTABLE (
'/IN_DATA'
PASSING px_Block
COLUMNS A1 VARCHAR2 (2) PATH 'A1',
A2 VARCHAR2 (10)
PATH 'A2',
A3 VARCHAR2 (3) PATH 'A3',
A4 VARCHAR2 (1) PATH 'A4',
A5 VARCHAR2 (1)
PATH 'A5',
A6 VARCHAR2 (10)
PATH 'A6',
A7 VARCHAR2 (1)
PATH 'A7',
A8 VARCHAR2 (8) PATH 'A8',
A9 VARCHAR2 (1)
PATH 'A9',
A10 VARCHAR2 (16)
PATH 'A10',
A11 VARCHAR2 (2)
PATH 'A11',
A12 VARCHAR2 (8)
PATH 'A12',
A13 VARCHAR2 (1)
PATH 'A13',
A14 VARCHAR2 (1)
PATH 'A14');
This function takes 0.0945 seconds to perform. Not to so much, I think. But my process need to iterate 100000 times, so I call this function 100000 time.
Is there any faster way to implement this to improve, even if only a few thousandths of a second?

Answer 1

Combine XML and process one large document instead of many little documents. This at least reduces the amount of context switches between SQL and PL/SQL, and
probably allows Oracle to take advantage of other efficiencies as well.
Instead of processing one-row-at-a-time:
<IN_DATA><A1>1</A1><A2>2</A2></IN_DATA>
Process multiple rows:
<ALL_DATA>
<IN_DATA><A1>1</A1><A2>2</A2></IN_DATA>
<IN_DATA><A1>3</A1><A2>4</A2></IN_DATA>
</ALL_DATA>
With code like this:
--Process XML.
declare
v_strings sys.odcivarchar2list;
px_Block xmltype := xmltype('
<ALL_DATA>
<IN_DATA><A1>1</A1><A2>2</A2></IN_DATA>
<IN_DATA><A1>3</A1><A2>4</A2></IN_DATA>
</ALL_DATA>');
begin
--Get strings.
select A1||' '||A2
bulk collect into v_strings
from
xmltable
(
'/ALL_DATA/IN_DATA' passing px_Block columns
a1 varchar2 (2) path 'A1',
a2 varchar2 (10) path 'A2'
);
--Display strings for testing.
for i in 1 .. v_strings.count loop
dbms_output.put_line(v_strings(i));
end loop;
end;
/
Results:
1 2
3 4
EDIT
If the documents cannot be combined, and if the input string is relatively simple and can be trusted, replacing the XML processing with string functions may significantly improve performance.
The example below uses a smaller input string, but changing from XML to string processing shrinks the time from 30 seconds to almost none.
--Process XML.
declare
v_result varchar2(100);
v_xml xmltype := xmltype('<IN_DATA><A1>1</A1><A2>2</A2></IN_DATA>');
v_string varchar2(100) := '<IN_DATA><A1>1</A1><A2>2</A2></IN_DATA>';
function get_string_from_xml(p_xml xmltype) return varchar2 is
v_string varchar2(100);
begin
--Get strings.
select A1||' '||A2
into v_string
from
xmltable
(
'/IN_DATA' passing v_xml columns
a1 varchar2 (2) path 'A1',
a2 varchar2 (10) path 'A2'
);
return v_string;
end get_string_from_xml;
function get_string_from_string(p_string varchar2) return varchar2 is
v_string varchar2(100);
begin
return
substr(p_string, instr(p_string, '<A1>') + 4, instr(p_string, '</A1>') - instr(p_string, '<A1>') - 4)
||' '||
substr(p_string, instr(p_string, '<A2>') + 4, instr(p_string, '</A2>') - instr(p_string, '<A2>') - 4);
end get_string_from_string;
begin
--27 seconds
/*
for i in 1 .. 100000 loop
v_result := get_string_from_xml(v_xml);
end loop;
*/
--0 seconds
for i in 1 .. 100000 loop
v_result := get_string_from_string(v_string);
end loop;
end;
/
Another way of looking at this is that your original function takes 2.5 hours to process 100,000 XML documents with a single thread. That sounds quite reasonable. Some simple parallelism should be able to shrink the time from hours to tens of minutes.