REGEXP_REPLACE replacing text with the same text in lower case - plsql

Question

I am trying to use REGEXP_REPLACE in PL/SQL to replace some text with the same text in lower case. Actually, the rule is that I want all text between "()" that has only one char to be in lower case.
Here is an example :
SELECT REGEXP_REPLACE(
'i want what what is between <> in lower case : I am a test(E) (A) (HELLO)'
, '(\(\D\))', '<\1>'
) FROM DUAL
Result :
I want what is between <> in lower case : I am a test(e) (a) (HELLO)
or this because I am a little confuse about my exercice:
I want what is between <> in lower case : I am a test<(e)> <(a)> (HELLO)
How can I get my text in lower case ? I tried in several ways but I can't get out with it. I don't know hot to tell REGEXP_REPLACE to put "\1" content in lower case.
Thanks you for your help.
Best regards.
MS

Answer 1

(with Oracle11g) Here is how to replace the first occurrence:
Use REGEXP_instr and REGEXP_substr to be able to apply lower to the matched pattern
SELECT substr(it, 1 , REGEXP_instr( it, '(\(\D\))')-1)
||lower( REGEXP_substr(it, '(\(\D\))') )
||substr(it, REGEXP_instr( it, '(\(\D\))')+3, length(it))
FROM (SELECT 'i want what what is between <> in lower case : I am a test(E) (A) (HELLO)' it from dual) ;
and if you want the weird <> around it:
SELECT substr(it, 1 , REGEXP_instr( it, '(\(\D\))')-1)
|| '<'
||lower( REGEXP_substr(it, '(\(\D\))') )
|| '>'
||substr(it, REGEXP_instr( it, '(\(\D\))')+3, length(it))
FROM (SELECT 'i want what what is between <> in lower case : I am a test(E) (A) (HELLO)' it from dual) ;
I think you cannot have recursive regexp in Oracle. So if you want to be able to replace 2 occurrences:
SELECT substr(rit, 1 , REGEXP_instr( rit, '(\([[:upper:]]{1}\))')-1)
||lower( REGEXP_substr(rit, '(\([[:upper:]]{1}\))') )
||substr(rit, REGEXP_instr( rit, '(\([[:upper:]]{1}\))')+3, length(rit))
from (
(SELECT substr(it, 1 , REGEXP_instr( it, '(\([[:upper:]]{1}\))')-1)
||lower( REGEXP_substr(it, '(\([[:upper:]]{1}\))') )
||substr(it, REGEXP_instr( it, '(\([[:upper:]]{1}\))')+3, length(it)) rit
FROM (SELECT 'i want what what is between <> in lower case : I am a test(E) (A) (HELLO)' it from dual))
) ;
(+ I replace the \D by [[:upper:]]{1} which is more accurate)

Answer 2

To bad this has to be such a difficult problem! Seems like it would be easy.
To handle a variable number of occurrences of the pattern, you need to loop through the string looking for them. Maybe someone will come up with a slick solution using CONNECT BY or something but in the meantime and since you are using PL/SQL why don't you go old-school and create a function that does it? It will arguably be easier to maintain and will be wrapped up in a reusable unit available for all to use too. Pass it a string and have it return the cleaned up version.
SQL> select lower_single_letters('I want what is between in lower case : I am a test(E) (A) (HELLO)') text
from dual;
TEXT
--------------------------------------------------------------------------------
I want what is between in lower case : I am a test(e) (a) (HELLO)
SQL>
Here's some sample code since I wanted an example for use in my utility package:
CREATE OR REPLACE function lower_single_letters(string_in varchar2) return varchar2 is
tmp_string varchar2(1000) := string_in; -- Holds the string
regex_pattern constant varchar2(20) := '\([[:upper:]]\)'; -- Pattern to look for '(A)'
letter_offset integer; -- Offset of the pattern
letter varchar2(1); -- The letter to lower()
BEGIN
-- Loop while the pattern is found in the string passed in
while regexp_like(tmp_string, regex_pattern)
loop
-- Get the offset in the string
letter_offset := regexp_instr(tmp_string, regex_pattern)+1;
-- Get the letter
letter := substr(tmp_string, letter_offset, 1);
-- Replace it in the string
tmp_string := regexp_replace(tmp_string, '.', lower(letter), 1, letter_offset);
end loop;
-- Return it when the pattern is no longer found
return(tmp_string);
END lower_single_letters;