function get_columns_filter(

a_exclude_xpath varchar2, a_include_xpath varchar2,

a_table_alias varchar2 := 'ucd', a_column_alias varchar2 := 'item_data'

) return varchar2 is

l_filter varchar2(32767);

l_source_column varchar2(500) := a_table_alias||'.'||a_column_alias;

begin

-- this SQL statement is constructed in a way that we always get the same number and ordering of substitution variables

-- That is, we always get: l_exclude_xpath, l_include_xpath

-- regardless if the variables are NULL (not to be used) or NOT NULL and will be used for filtering

if a_exclude_xpath is null and a_include_xpath is null then

l_filter := ':l_exclude_xpath, :l_include_xpath, '||l_source_column||' as '||a_column_alias;

elsif a_exclude_xpath is not null and a_include_xpath is null then

l_filter := 'deletexml( '||l_source_column||', :l_exclude_xpath ) as '||a_column_alias||', :l_include_xpath';

elsif a_exclude_xpath is null and a_include_xpath is not null then

l_filter := ':l_exclude_xpath, extract( '||l_source_column||', :l_include_xpath ) as '||a_column_alias;

elsif a_exclude_xpath is not null and a_include_xpath is not null then

l_filter := 'extract( deletexml( '||l_source_column||', :l_exclude_xpath ), :l_include_xpath ) as '||a_column_alias;

end if;

return l_filter;

end;

--TODO : removal

function get_rows_diff(

a_expected_dataset_guid raw, a_actual_dataset_guid raw, a_diff_id raw,

a_max_rows integer, a_exclude_xpath varchar2, a_include_xpath varchar2

) return tt_row_diffs is

l_column_filter varchar2(32767);

l_results tt_row_diffs;

begin

l_column_filter := get_columns_filter(a_exclude_xpath,a_include_xpath);

execute immediate q'[

with

diff_info as ( select item_no

from

(select item_no from ut_compound_data_diff_tmp ucdc where diff_id = :diff_guid order by item_no asc)

where rownum <= :max_rows)

select *

from (select rn, diff_type, xmlserialize(content data_item no indent) diffed_row, null pk_value

from (select nvl(exp.rn, act.rn) rn,

xmlagg(exp.col order by exp.col_no) exp_item,

xmlagg(act.col order by act.col_no) act_item

from (select r.item_no as rn, rownum col_no, s.column_value col,

s.column_value.getRootElement() col_name,

s.column_value.getclobval() col_val

from (select ]'||l_column_filter||q'[, ucd.item_no, ucd.item_data item_data_no_filter

from ut_compound_data_tmp ucd,

diff_info i

where ucd.data_id = :self_guid

and ucd.item_no = i.item_no

) r,

table( xmlsequence( extract(r.item_data,'/*/*') ) ) s

) exp

join (

select item_no as rn, rownum col_no, s.column_value col,

s.column_value.getRootElement() col_name,

s.column_value.getclobval() col_val

from (select ]'||l_column_filter||q'[, ucd.item_no, ucd.item_data item_data_no_filter

from ut_compound_data_tmp ucd,

diff_info i

where ucd.data_id = :other_guid

and ucd.item_no = i.item_no

) r,

table( xmlsequence( extract(r.item_data,'/*/*') ) ) s

) act

on exp.rn = act.rn and exp.col_name = act.col_name

where dbms_lob.compare(exp.col_val, act.col_val) != 0

group by exp.rn, act.rn

)

unpivot ( data_item for diff_type in (exp_item as 'Expected:', act_item as 'Actual:') )

)

union all

select nvl(exp.item_no, act.item_no) rn,

case when exp.item_no is null then 'Extra:' else 'Missing:' end as diff_type,

xmlserialize(content nvl(exp.item_data, act.item_data) no indent) diffed_row,

null pk_value

from (select ucd.item_no, extract(ucd.item_data,'/*/*') item_data

from ut_compound_data_tmp ucd

where ucd.data_id = :self_guid

and ucd.item_no in (select i.item_no from diff_info i)

) exp

full outer join (

select ucd.item_no, extract(ucd.item_data,'/*/*') item_data

from ut_compound_data_tmp ucd

where ucd.data_id = :other_guid

and ucd.item_no in (select i.item_no from diff_info i)

)act

on exp.item_no = act.item_no

where exp.item_no is null or act.item_no is null

order by 1, 2]'

bulk collect into l_results

using a_diff_id, a_max_rows,

a_exclude_xpath, a_include_xpath, a_expected_dataset_guid,

a_exclude_xpath, a_include_xpath, a_actual_dataset_guid,

a_expected_dataset_guid, a_actual_dataset_guid;

return l_results;

end;

function get_columns_filter(

a_exclude_xpath varchar2, a_include_xpath varchar2,

a_table_alias varchar2 := 'ucd', a_column_alias varchar2 := 'item_data'

) return varchar2;

function get_rows_diff(

a_expected_dataset_guid raw, a_actual_dataset_guid raw, a_diff_id raw,

a_max_rows integer, a_exclude_xpath varchar2, a_include_xpath varchar2

) return tt_row_diffs;

overriding member function compare_implementation(a_other ut_data_value) return integer is

begin

return compare_implementation( a_other, null );

end;

overriding member function diff( a_other ut_data_value, a_match_options ut_matcher_options ) return varchar2 is

l_result clob;

l_result_string varchar2(32767);

begin

l_result := get_data_diff( a_other, a_match_options );

l_result_string := ut_utils.to_string(l_result,null);

dbms_lob.freetemporary(l_result);

return l_result_string;

end;

-- TODO : Rework to exclude xpath

member function get_data_diff( a_other ut_data_value, a_match_options ut_matcher_options ) return clob is

c_max_rows integer := ut_utils.gc_diff_max_rows;

l_result clob;

l_results ut_utils.t_clob_tab := ut_utils.t_clob_tab();

l_message varchar2(32767);

l_diff_row_count integer;

l_actual ut_compound_data_value;

l_diff_id ut_compound_data_helper.t_hash;

l_row_diffs ut_compound_data_helper.tt_row_diffs;

function get_diff_message (a_row_diff ut_compound_data_helper.t_row_diffs) return varchar2 is

begin

return ' Row No. '||a_row_diff.rn||' - '||rpad(a_row_diff.diff_type,10)||a_row_diff.diffed_row;

end;

begin

if not a_other is of (ut_compound_data_value) then

raise value_error;

end if;

l_actual := treat(a_other as ut_compound_data_value);

dbms_lob.createtemporary(l_result,true);

l_diff_id := ut_compound_data_helper.get_hash(self.data_id||l_actual.data_id);

-- First tell how many rows are different

l_diff_row_count := ut_compound_data_helper.get_rows_diff_count;

if l_diff_row_count > 0 then

l_row_diffs := ut_compound_data_helper.get_rows_diff(

self.data_id, l_actual.data_id, l_diff_id, c_max_rows,

a_match_options.exclude.to_xpath(),

a_match_options.exclude.to_xpath()

);

l_message := chr(10)

||'Rows: [ ' || l_diff_row_count ||' differences'

|| case when l_diff_row_count > c_max_rows and l_row_diffs.count > 0 then ', showing first '||c_max_rows end

||' ]'||chr(10)|| case when l_row_diffs.count = 0 then ' All rows are different as the columns are not matching.' else null end;

ut_utils.append_to_clob( l_result, l_message );

for i in 1 .. l_row_diffs.count loop

l_results.extend;

l_results(l_results.last) := get_diff_message( l_row_diffs(i) );

end loop;

ut_utils.append_to_clob(l_result,l_results);

else

l_message:= chr(10)||'Rows: [ all different ]'||chr(10)||' All rows are different as the columns are not matching.';

ut_utils.append_to_clob( l_result, l_message );

end if;

return l_result;

end;

member function compare_implementation(a_other ut_data_value, a_match_options ut_matcher_options) return integer is

l_other ut_compound_data_value;

l_ut_owner varchar2(250) := ut_utils.ut_owner;

l_column_filter varchar2(32767);

l_diff_id ut_compound_data_helper.t_hash;

l_result integer;

--the XML stylesheet is applied on XML representation of data to exclude column names from comparison

--column names and data-types are compared separately

--user CHR(38) instead of ampersand to eliminate define request when installing through some IDEs

l_xml_data_fmt constant xmltype := xmltype(

q'[<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:strip-space elements="*" />

<xsl:template match="/child::*">

<xsl:for-each select="child::node()">

<xsl:choose>

<xsl:when test="*[*]"><xsl:copy-of select="node()"/></xsl:when>

<xsl:when test="position()=last()"><xsl:value-of select="normalize-space(.)"/><xsl:text>'||CHR(38)||'#xD;</xsl:text></xsl:when>

<xsl:otherwise><xsl:value-of select="normalize-space(.)"/>,</xsl:otherwise>

</xsl:choose>

</xsl:for-each>

</xsl:template>

</xsl:stylesheet>]');

begin

if not a_other is of (ut_compound_data_value) then

raise value_error;

end if;

l_other := treat(a_other as ut_compound_data_value);

l_diff_id := ut_compound_data_helper.get_hash(self.data_id||l_other.data_id);

l_column_filter := ut_compound_data_helper.get_columns_filter( a_match_options.exclude.to_xpath(), a_match_options.include.to_xpath() );

-- Find differences

execute immediate 'insert into ' || l_ut_owner || '.ut_compound_data_diff_tmp ( diff_id, item_no )

select :diff_id, nvl(exp.item_no, act.item_no)

from (select '||l_column_filter||', ucd.item_no

from ' || l_ut_owner || '.ut_compound_data_tmp ucd where ucd.data_id = :self_guid) exp

full outer join

(select '||l_column_filter||', ucd.item_no

from ' || l_ut_owner || '.ut_compound_data_tmp ucd where ucd.data_id = :l_other_guid) act

on exp.item_no = act.item_no '||

'where nvl( dbms_lob.compare(' ||

/*the xmltransform removes column names and leaves column data to be compared only*/

' coalesce( xmltransform(exp.item_data, :l_xml_data_fmt).getclobval(), empty_clob() )' ||

', coalesce( xmltransform(act.item_data, :l_xml_data_fmt).getclobval(), empty_clob() )' ||

')' ||

',1' ||

') != 0'

using in l_diff_id, a_match_options.exclude.to_xpath(), a_match_options.include.to_xpath(), self.data_id,

a_match_options.exclude.to_xpath(), a_match_options.include.to_xpath(), l_other.data_id, l_xml_data_fmt, l_xml_data_fmt;

--result is OK only if both are same

if sql%rowcount = 0 and self.elements_count = l_other.elements_count then

l_result := 0;

else

ut_compound_data_helper.set_rows_diff(sql%rowcount);

l_result := 1;

end if;

return l_result;

end;

overriding member function is_multi_line return boolean,

overriding member function compare_implementation(a_other ut_data_value) return integer,

overriding member function diff( a_other ut_data_value, a_match_options ut_matcher_options ) return varchar2,

member function get_data_diff( a_other ut_data_value, a_match_options ut_matcher_options ) return clob,

member function compare_implementation( a_other ut_data_value, a_match_options ut_matcher_options ) return integer