[Mostly Sorted] Extracting tags - regexp_substr and count help needed!

Question

My original query got sorted, but additional regexp_substr and count help is required further on down!
Hi,
I have a table on a 10.2.0.3 database which contains a clob field (sql_stmt), with contents that look something like:
SELECT <COB_DATE>, col2, .... coln
FROM   tab1, tab2, ...., tabn
WHERE tab1.run_id = <RUNID>
AND    tab2.other_col = '<OTHER TAG>'(That's a highly simplified sql_stmt example, of course - if they were all that small we'd not be needing a clob field!).
I wanted to extract all the tags from the sql_stmt field for a given row, so I can get my (well not "mine" - I'd never have designed something like this, but hey, it works, sorta, and I'm improving it as and where I can!) pl/sql to replace the tags with the correct values. A tag is anything that's in triangular brackets (eg. <RUNID> from the above example)
So, I did this:
SELECT     SUBSTR (sql_stmt,
                   INSTR (sql_stmt, '<', 1, LEVEL),
                   INSTR (substr(sql_stmt, INSTR (sql_stmt, '<', 1, LEVEL)), '>', 1, 1)
                   ) tag
FROM       export_jobs
WHERE      exp_id =  p_exp_id
CONNECT BY LEVEL <= (LENGTH (sql_stmt) - LENGTH (REPLACE (sql_stmt, '<')))Which I thought would be fine (having tested it on a text column). However, it runs very poorly against a clob column, for some reason (probably doesn't like the substr, instr, etc on the clob, at a guess) - the waits show "direct path read".
When I cast the sql_stmt as a varchar2 like so:
with my_tab as (select cast(substr(sql_stmt, instr(sql_stmt, '<', 1), instr(sql_stmt, '>', -1) - instr(sql_stmt, '<', 1) + 1) as varchar2(4000)) sql_stmt
                from export_jobs
                WHERE      exp_id = p_exp_id)
SELECT     SUBSTR (sql_stmt,
                   INSTR (sql_stmt, '<', 1, LEVEL),
                   INSTR (substr(sql_stmt, INSTR (sql_stmt, '<', 1, LEVEL)), '>', 1, 1)
                   ) tag
FROM       my_tab
CONNECT BY LEVEL <= (LENGTH (sql_stmt) - LENGTH (REPLACE (sql_stmt, '<')))it runs blisteringly fast in comparison, except when the substr'd sql_stmt is over 4000 chars, of course! Using dbms_lob instr and substr etc doesn't help either.
So, I thought maybe I could find an xml related method, and from this link:get xml node name in loop , I tried:
select t.column_value.getrootelement() node
  from (select sql_stmt xml from export_jobs where exp_id = 28) xml,
table (xmlsequence(xml.xml.extract('//*'))) tBut I get this error: ORA-22806: not an object or REF. (It might not be the way to go after all, as it's not proper xml, being as there are no corresponding close tags, but I was trying to think outside the box. I've not needed to use xml stuff before, so I'm a bit clueless about it, really!)
I tried casting sql_stmt into an xmltype, but I got: ORA-22907: invalid CAST to a type that is not a nested table or VARRAY
Is anyone able to suggest a better method of trying to extract my tags from the clob column, please?
Message was edited by:
Boneist

Answer 1

I don't know if it may work for you, but I had a similar activity where I defined sql statements with bind variables (:var_name) and then I simply looked for witch variables to bind in that statement through this query.
with x as (
     select ':var1
     /*a block comment
     :varname_dontcatch
     select hello, --line comment :var_no
          ''a string with double quote '''' and a :variable '',  --:variable
          :var3,
          :var2, '':var1'''':varno'',
     from dual'     as string
     from dual
), fil as (
     select string,
          regexp_replace(string,'(/\*[^*]*\*/)'||'|'||'(--.*)'||'|'||'(''([^'']|(''''))*'')',null) as res
     from x
select string,res,
     regexp_substr(res,'\:[[:alpha:]]([[:alnum:]]|_)*',1,level)
from fil
connect by regexp_instr(res,'\:[[:alpha:]]([[:alnum:]]|_)*',1,level) > 0
/Or through these procedures
     function get_binds(
          inp_string in varchar2
     ) return string_table
     deterministic
     is
          loc_str varchar2(32767);
          loc_idx number;
          out_tab string_table;
     begin
          --dbms_output.put_line('cond = '||inp_string);
          loc_str := regexp_replace(inp_string,'(/\*[^*]*\*/)'||'|'||'(--.*)'||'|'||'(''([^'']|(''''))*'')',null);
          loc_idx := 0;
          out_tab := string_table();
          --dbms_output.put_line('fcond ='||loc_str);
          loop
               loc_idx := regexp_instr(loc_str,'\:[[:alpha:]]([[:alnum:]]|_)*',loc_idx+1);
               exit when loc_idx = 0;
               out_tab.extend;
               out_tab(out_tab.last) := regexp_substr(loc_str,'[[:alpha:]]([[:alnum:]]|_)*',loc_idx+1);
          end loop;
          return out_tab;
     end;
     function divide_string (
          inp_string in varchar2
          --,inp_length in number
     --return string_table
     return dbms_sql.varchar2a
     is
          inp_length number := 256;
          loc_ind_1 pls_integer;
          loc_ind_2 pls_integer;
          loc_string_length pls_integer;
          loc_curr_string varchar2(32767);
          --out_tab string_table;
          out_tab dbms_sql.varchar2a;
     begin
          --out_tab := dbms_sql.varchar2a();
          loc_ind_1 := 1;
          loc_ind_2 := 1;
          loc_string_length := length(inp_string);
          while ( loc_ind_2 < loc_string_length ) loop
               --out_tab.extend;
               loc_curr_string := substr(inp_string,loc_ind_2,inp_length);
               dbms_output.put(loc_curr_string);
               out_tab(loc_ind_1) := loc_curr_string;
               loc_ind_1 := loc_ind_1 + 1;
               loc_ind_2 := loc_ind_2 + length(loc_curr_string);
          end loop;
          dbms_output.put_line('');
          return out_tab;
     end;
     function execute_statement(
          inp_statement in varchar2,
          inp_binds in string_table,
          inp_parameters in parametri
     return number
     is
          loc_stat dbms_sql.varchar2a;
          loc_dyn_cur number;
          out_rows number;
     begin
          loc_stat := divide_string(inp_statement);
          loc_dyn_cur := dbms_sql.open_cursor;
          dbms_sql.parse(c => loc_dyn_cur,
               statement => loc_stat,
               lb => loc_stat.first,
               ub => loc_stat.last,
               lfflg => false,
               language_flag => dbms_sql.native
          for i in inp_binds.first .. inp_binds.last loop
               DBMS_SQL.BIND_VARIABLE(loc_dyn_cur, inp_binds(i), inp_parameters(inp_binds(i)));
               dbms_output.put_line(':'||inp_binds(i)||'='||inp_parameters(inp_binds(i)));
          end loop;
          dbms_output.put_line('');
          --out_rows := DBMS_SQL.EXECUTE(loc_dyn_cur);
          DBMS_SQL.CLOSE_CURSOR(loc_dyn_cur);
          return out_rows;
     end;Bye Alessandro
Message was edited by:
Alessandro Rossi
There is something missing in the functions but if there is something that may interest you you can ask.