regexp_substr for getting correct result - sql

I was trying to use regexp_substr to get each correct column name from a column list string.
The query is like:
select regexp_substr(v_keep, '(^|[(,) ]*)' || r.column_name || '($|[(,) ]+)', 1, 1, 'i')
from dual;
But the result is not correct.
The v_keep can be any column name list like abc, abc_abc, abc1 or (abc, abc_abc, abc1).
The r.column_name can be like abc or ab.
- If the input v_keep is (abc, abc_abc, abc1) and the r.column_name is
ab, it will return null.
- If the input v_keep is (abc, abc_abc, abc1) and the r.column_name is
abc, it will return the column name just abc.
Can anyone help me to fix it by just modify the pattern inside the regexp_substr ?

Why not just use a case and like?
select (case when replace(replace(v_keep, '(', ','), '(', ',')) like '%,' || r.column_name || ',%'
then r.column_name
end)
I don't recommend storing lists in a comma-delimited string, but if you are, this is one way to identify individual elements of the list.

It's pretty simple, you just need to add a subexpression so you can pull out the part of the string you want. (A subexpression is a section of the regexp in parentheses.) In this case the last argument is 2, because you want the part of the match that corresponds to the second group of parentheses.
regexp_substr(v_keep, '(^|[(,) ]*)(' || r.column_name || ')($|[(,) ]+)', 1, 1, 'i', 2)
Gordon's solution will have better performance, though.
Edit: working example -
with testdata as (select '(abc, abc_abc, abc1)' as v_keep, 'abc' as column_name from dual)
select regexp_substr(v_keep, '(^|[(,) ]*)(' || r.column_name || ')($|[(,) ]+)', 1, 1, 'i', 2)
from testdata r;

Since this is PL/SQL code to see if a value is in a string, try this which avoids the overhead of hitting the database, and calling REGEXP. Just keep it straight SQL. I hate the nested REPLACE calls but I was trying to avoid using REGEXP_REPLACE although it could be done in one call if you did use it.
set serveroutput on;
set feedback off;
declare
v_keep varchar2(50) := '(abc, abc_abc, abc1)';
compare varchar2(10) := 'abc_';
begin
if instr(',' || replace(replace(replace(v_keep, ' '), '('), ')') || ',', ',' || compare || ',') > 0 then
dbms_output.put_line('Column ''' || compare ||''' IS in the keep list');
else
dbms_output.put_line('Column ''' || compare ||''' IS NOT in the keep list');
end if;
end;

Related

I am trying to remove email with ';' value from column which has multiple emails

If I use replace(email, ';', '') it will remove all the ';' from the value which has list of emails. My requirement is it will need to remove only the paticular email along with ';' if it is at end or at the begining for that particular email.
EG:
abc#yahoo.com;efg#yahoo.com;hij#yahoo.com;ab1#yahoo.com
If I want to remove abc#yahoo.com; then the result should be
efg#yahoo.com;hij#yahoo.com;ab1#yahoo.com
or if I want to remove hij#yahoo.com; then the result should be
abc#yahoo.com;efg#yahoo.com;ab1#yahoo.com
Query :
DECLARE
v_sql VARCHAR2(5000);
v_email VARCHAR2(5000):= 'abc#yahoo.com';
v_sql:=UPDATE L05460176.SI_Recipient set email = case when (:1||';') then replace (lower (replace (email, :1||';' )), chr(32),'')
when (';'||:1) then email = replace (lower (replace (email, ';'||:1 )),
chr(32),'') WHERE EVENT = 'XYZ'
EXECUTE IMMEDIATE v_sql
USING v_email ;
One method uses trim() and replace():
trim(both ';' from
replace(';' || emails || ';', ';' || 'hij#yahoo.com' || ';', ';')
)
That said, I would recommend a different data model. Oracle has many alternative solutions for storing lists of things -- from a traditional junction/association table to JSON to nested tables.
You can try and use replace + replace:
select
replace(replace('efg#yahoo.com;hij#yahoo.com;ab1#yahoo.com', 'hij#yahoo.com', ''), ';;', ';')
from dual;
Here is the DEMO

Conditionally concatenating fields in Oracle

What I need to do is to concatenate 4 fields in Oracle SQL Developer. The fields are:
Network, Network2, Network3, Network4
However, sometimes not all of the fields are filled in. This would always happen in sequence; it would never be just Network3 that's empty, it's either they fill in the first one only, the first 2 only, etc...
So, how can I write a Select statement that will ignore any fields that are NULL? I need the end result to look like:
Select Network, Network2, Network3, Network4 as Defect
and it should show Defect as something like "ON1, ON2, ON3, ON4" all in one field. But if only the first 2 are filled in, I don't want it to look like, "ON1, ON2, , , ".
Use NVL2(v, valueIfNotNull, valueIfNull)
SELECT
Network
|| nvl2(Network2, ', ' || Network2, '')
|| nvl2(Network3, ', ' || Network3, '')
|| nvl2(Network4, ', ' || Network4, '') AS Defect
FROM my_table
Use the CONCATENATE || operator and COALESCE() function:
SELECT Network
|| COALESCE(' - ' || Network2, '')
|| COALESCE(' - ' || Network3, '')
|| COALESCE(' - ' || Network4, '')
as Defect

Selecting individual values from csv format in oracle pl sql

I have the following value in a column in Oracle db ('abc', 'xyz')
I want to extract the values separately like abc, xyz by removing ' and (). Is there a way to do it using INSTR and SUBSTR functions?
Thanks
Use this query:
with sample as (select '(''abc'', ''xyz'')' text from dual)
select substr(text,instr(text,'''',1,1) + 1,instr(text,'''',1,2) - instr(text,'''',1,1) - 1),
substr(text,instr(text,'''',1,3) + 1,instr(text,'''',1,4) - instr(text,'''',1,3) - 1)
from sample;
It would help to know what you want to do with the data once parsed. How it could be handled in SQL vs PL/SQL to achieve your requirement could be very different.
That said, here's one way to strip surrounding parens and remove single quotes at the same time during the select using the powerful regexp_replace(source_string, pattern_string, replace_string) :
WITH qry AS (SELECT '(' || '''abc''' || ',' || '''xyz''' || ')' orig_string
FROM dual
)
SELECT regexp_replace(orig_string, '[()'']', '' ) clean_string
FROM qry;
The regexp_replace pattern_string says to match a character class (defind by opening and closing square brackets) containing a left paren or a right paren or a single quote (quoted so Oracle sees it) and the replace_string replaces it with nothing.
Then, to parse the values remaining here's an example from by bag of tricks I got somewhere and tweaked for this case:
set serveroutput on
DECLARE
-- Build a string in the format "('abc','xyz')"
orig_string varchar2(20) := '(' || '''abc''' || ',' || '''xyz''' || ')';
CURSOR cur IS
WITH qry AS (SELECT regexp_replace(orig_string, '[()'']','' ) clean_string
FROM dual
)
SELECT regexp_substr(clean_string, '[^,]+', 1, ROWNUM) element
FROM qry
CONNECT BY LEVEL <= LENGTH(regexp_replace (clean_string, '[^,]+')) + 1;
BEGIN
FOR rec IN cur LOOP
dbms_output.put_line('Element:' || rec.element);
END LOOP;
END;
It basically loops through the elements and prints them. I'm sure you can adapt this to your situation.

Concatenate string in Oracle SQL? (wm-concat)

I've got some SQL that I'd like to format correctly for a mailout (generated directly from SQL - don't ask!). The code is as follows:
SELECT wm_concat('<br>• ' || FIELD1 || ' ' || FIELD2 || ' : ' || FIELD 3 || ' text') AS "Team"
Okay, so this kinda works - but it places a comma at the end of each line. Silly question, and possibly quite trivial, but is there anyway at all to remove the comma please? I think it's being added by the wm_concat function
Thanks
Yes the WM_CONCAT function puts a comma between each value it concatenates.
If there are no commas in your data you could do this:
SELECT replace (wm_concat('<br>• ' || FIELD1 || ' ' || FIELD2 || ' : '
|| FIELD 3 || ' text'),
',', null) AS "Team"
If you are on 11G you can use the new LISTAGG function instead:
SELECT LISTAGG ('<br>• ' || FIELD1 || ' ' || FIELD2 || ' : '
|| FIELD 3 || ' text')
WITHIN GROUP (ORDER BY <something>) AS "Team"
That will produce a result without commas.
Just trim the string for trailing commas:
RTRIM( wm_concat(...), ',' )
Oracle 10g provides a very convenient function wm_concat used to solve line reclassified demand, very easy to use this function, but the function provides only ',' this kind of delimiter.
In fact, as long as some simple conversion you can use other delimiters separated, the first thought is replace function
with t as( select 'a' x from dual union select 'b' from dual )
select replace(wm_concat(x),',','-') from t;
But taking into account the string itself may contain ',' character, use the above SQL will lead to erroneous results, but also made some changes to the above SQL.
with t as( select 'a' x from dual union select 'b' y from dual)
select substr(replace(wm_concat('%'||x),',%','-'),2) from t;
In the above SQL by a '%' as a separator, and then replace the '%' to remove the error. The program assumes that the string does not exist within the '%' string to replace the '%' in the SQL can also use other special characters.
Source: http://www.databaseskill.com/3400944/
You can create your own aggregate functions in Oracle and use those to aggregate strings.
Or use the StrAgg function written by Tom Kyte: http://www.sqlsnippets.com/en/topic-11591.html
SELECT StrAgg('<br>• ' || FIELD1 || ' ' || FIELD2 || ' : ' || FIELD 3 || ' text') AS "Team"
FROM Abc

SQL - Handling String

for example, i have the string 'This Is An Example Of The String'
and i want to return this result 'This is an Example of the String'
==> I want all the 'Is', 'An' 'Of' and 'The' in lower cases, the rest should stay in Initcap.
How can be this done in a simple and unique query? here is my query to lower case only the 'Of' :
SELECT 'This Is An Example Of The String',
CASE
WHEN 'This Is An Example Of The String' like '% Of %'
THEN replace('This Is An Example Of The String', ' Of ', ' of ')
END
FROM dual ;
Thanks!
Try this:
SELECT REPLACE(REPLACE(REPLACE(REPLACE('This Is An Example Of The String', 'Of', 'of'), 'The', 'the'), 'An', 'an'), 'Is', 'is') FROM dual;
I feel a little dirty after writing that though.
Edit: Removed the extra 'an' replace, then added indentation, then removed indentation again. It looks ugly no matter how you wrap it.
Basically it's going to take a lot of logic of the nature you've described. There's no quick and easy way. You'd find it quicker and easier to do this type of manipulation in your business logic code rather than at the database.
If you are going to do it in the database consider wrapping up the logic in a function, like this one.
Although it's not a pure SQL solution, another option would be to define a function which transformed the string as desired, perhaps calling it REPLACE_MULTI. The invocation would be something like
SELECT REPLACE_MULTI('This Is An Example Of The String',
'Is|An|Of|The',
'is|an|of|the')
FROM DUAL;
and the implementation would be something along the lines of
CREATE OR REPLACE FUNCTION REPLACE_MULTI(strOriginal IN VARCHAR2,
strTokens_to_replace IN VARCHAR2,
strReplacement_tokens IN VARCHAR2)
RETURN VARCHAR2
IS
strResult VARCHAR2(2000);
arrTokens_to_replace DBMS_SQL.VARCHAR2A;
arrReplacement_tokens DBMS_SQL.VARCHAR2A;
i NUMBER;
FUNCTION extract_tokens(p_string IN VARCHAR2,
p_separators IN VARCHAR2) RETURN DBMS_SQL.VARCHAR2A
IS
arrTokens DBMS_SQL.VARCHAR2A;
BEGIN
WITH sel_string AS
(SELECT p_string AS fullstring FROM DUAL)
SELECT SUBSTR(fullstring, beg + 1, end_p - beg - 1) AS token
BULK COLLECT INTO arrTokens
FROM (SELECT beg, LEAD(beg) OVER (ORDER BY beg) AS end_p, fullstring
FROM (SELECT beg, fullstring
FROM (SELECT LEVEL beg, fullstring
FROM sel_string
CONNECT BY LEVEL <= LENGTH(fullstring))
WHERE INSTR(p_separators, SUBSTR(fullstring, beg, 1)) > 0
UNION ALL
SELECT 0, fullstring FROM sel_string
UNION ALL
SELECT LENGTH(fullstring) + 1, fullstring FROM sel_string))
WHERE end_p IS NOT NULL AND
end_p > beg + 1;
RETURN arrTokens;
END extract_tokens;
BEGIN
arrTokens_to_replace := extract_tokens(strTokens_to_replace, '|');
arrReplacement_tokens := extract_tokens(strReplacement_tokens, '|');
strResult := strOriginal;
FOR i IN 1..arrTokens_to_replace.COUNT LOOP
strResult := REGEXP_REPLACE(strResult,
'^' || arrTokens_to_replace(i) || ' ',
arrReplacement_tokens(i));
strResult := REPLACE(strResult,
' ' || arrTokens_to_replace(i) || ' ',
' ' || arrTokens_to_replace(i) || ' ');
strResult := REGEXP_REPLACE(strResult,
' ' || arrTokens_to_replace(i) || '$',
' ' || arrReplacement_tokens(i));
END LOOP;
RETURN strResult;
END REPLACE_MULTI;
I'm sure that there are token strings which can be created which will break the regular expression-based parsing (try putting a '^' or '$' in there and watch the sparks fly :-) but this is good enough for an initial hack.
(Incidentally, the 'extract_tokens' routine isn't mine - I found it on the web somewhere a while back and am eternally grateful to whoever it was that created this).
Share and enjoy.
I can tell you the algorithm but I am not sure how to do that in SQL. for example:
words[] = string.split(" ")
foreach word in words
---if(word.length<=3) //do that only for short words
-------if(word[i]>=65 && word[i]<=90) //check the ascii code for upper case
------------word[i] += 21; // transfer it into lower case
---new sentence += " " + words[i] //add to the resultant string