List functions to find differences between to delimited sets - sql

Question

I have two delimited lists as follows and need to find what has changed.
Example: ( here | is separator )
old string: Joe | Public | NY
new string: Joe | Smith | NY
Since only second member of list has changed, the output should show only what has changed as follows :
Output:
- | Smith | -
Are there any Oracle functions or standard packages available which can compare these two delimited strings/sets and determine what has changed ?

Answer 1

Storing delimited lists in strings is not a good idea; that's missing the point of relational databases (as #Tim pointed out in a comment).
If you are generating the delimited string in an earlier step then go back to the source data and work directly from that.
If you are really stuck with those strings, there are various methods to tokenise delimited strings into individual values (as rows in a result set). This uses regular expression to split both string at once into two columns - for this I'm using a bind variable for each string to void repeating the literals, but you might be getting your strings from table columns (which would need a bit more work) or PL/SQL variables or whatever:
var old_string varchar2(20);
var new_string varchar2(20);
exec :old_string := 'Joe|Public|NY';
exec :new_string := 'Joe|Smith|NY';
with vals (pos, old_val, new_val) as (
select level,
regexp_substr(:old_string, '(.*?)(\||$)', 1, level, null, 1),
regexp_substr(:new_string, '(.*?)(\||$)', 1, level, null, 1)
from dual
connect by level < greatest(regexp_count(:old_string, '(.*?)(\||$)'),
regexp_count(:new_string, '(.*?)(\||$)'))
)
select * from vals;
POS OLD_VAL NEW_VAL
---------- ---------- ----------
1 Joe Joe
2 Public Smith
3 NY NY
It's now simple to compare the two columns to see what has changed, and then (if you must) aggregate them back into a single string value:
with vals (pos, old_val, new_val) as (
select level,
regexp_substr(:old_string, '(.*?)(\||$)', 1, level, null, 1),
regexp_substr(:new_string, '(.*?)(\||$)', 1, level, null, 1)
from dual
connect by level < greatest(regexp_count(:old_string, '(.*?)(\||$)'),
regexp_count(:new_string, '(.*?)(\||$)'))
)
select listagg(case when (old_val is null and new_val is null)
or old_val = new_val then '-' else new_val end, '|')
within group (order by pos) as diff
from vals;
DIFF
--------------------
-|Smith|-
The case expression determines whether you see a dash, indicating no change, or the new value.
This should handle nulls (empty elements, i.e. two delimiters next to each other); it will also handle different numbers of elements, if that can happen:
exec :old_string := 'Joe|Public|NY||';
exec :new_string := 'Joe|Smith|NY||USA';
... same query ...
DIFF
--------------------
-|Smith|-|-|USA
But you should really fix your data model...
If the old and new strings are currently coming from two columns in a table, you could extend this to compare multiple rows; you just need to refer to a non-deterministic function in the connect by clause:
create table t42 (id, old_string, new_string) as
select 1, 'Joe|Public|NY', 'Joe|Smith|NY' from dual
union all select 2, 'Joe|Public|NY', 'Joe|Smith|NY|USA' from dual;
with vals (id, pos, old_val, new_val) as (
select id, level,
regexp_substr(old_string, '(.*?)(\||$)', 1, level, null, 1),
regexp_substr(new_string, '(.*?)(\||$)', 1, level, null, 1)
from t42
connect by id = prior id
and prior dbms_random.value is not null
and level < greatest(regexp_count(old_string, '(.*?)(\||$)'),
regexp_count(new_string, '(.*?)(\||$)'))
)
select id, listagg(case when (old_val is null and new_val is null)
or old_val = new_val then '-' else new_val end, '|')
within group (order by pos) as diff
from vals
group by id
order by id;
ID DIFF
---------- --------------------
1 -|Smith|-
2 -|Smith|-|USA
If they are coming from different rows or different tables then it's more complicated and #MTOs approach should be considered.
I should also point out that I assumed the spaces around your delimiter were to make the strings easier to read in the question; if they are actually in the data then the pattern can be adjusted (like #MTO's, again).

Answer 2

It's not a simple solution but you can do it in SQL using collections and a hierarchical query that uses regular expressions to match each element of the delimited list.
(Note: This method will work with multiple input rows.)
SQL Fiddle
Oracle 11g R2 Schema Setup:
CREATE TABLE table_name ( id, old_string, new_string ) AS
SELECT 1, 'Joe | Public | NY', 'Joe | Smith | NY' FROM DUAL UNION ALL
SELECT 2, 'Joe | Public | NY', 'Joe | Smith | NY|USA' FROM DUAL
/
CREATE TYPE indexed_string AS OBJECT(
idx INT,
value VARCHAR2(100)
)
/
CREATE TYPE indexed_string_table AS TABLE OF indexed_string
/
Query 1:
SELECT id,
( SELECT LISTAGG(
CASE
WHEN o.value = n.value THEN '-'
WHEN o.value IS NULL AND n.value IS NULL THEN '-'
ELSE n.value
END,
' | '
) WITHIN GROUP ( ORDER BY COALESCE( o.idx, n.idx ) )
FROM TABLE(
CAST(
MULTISET(
SELECT indexed_string(
LEVEL,
REGEXP_SUBSTR(
t.old_string,
'(.*?)($|\s*\|\s*)',
1,
LEVEL,
NULL,
1
)
)
FROM DUAL
CONNECT BY LEVEL < REGEXP_COUNT(
t.old_string,
'(.*?)($|\s*\|\s*)'
)
) AS indexed_string_table
)
) o
FULL OUTER JOIN
TABLE(
CAST(
MULTISET(
SELECT indexed_string(
LEVEL,
REGEXP_SUBSTR(
t.new_string,
'(.*?)($|\s*\|\s*)',
1,
LEVEL,
NULL,
1
)
)
FROM DUAL
CONNECT BY LEVEL < REGEXP_COUNT(
t.new_string,
'(.*?)($|\s*\|\s*)'
)
) AS indexed_string_table
)
) n
ON ( o.idx = n.idx )
) AS changes
FROM table_name t
Results:
| ID | CHANGES |
|----|---------------------|
| 1 | - | Smith | - |
| 2 | - | Smith | - | USA |