Code updates for pure sql

utPLSQL · jgebal · Mar 15, 2019 · Oct 6, 2018 · Oct 6, 2018 · Oct 6, 2018
commit 9843e143b5fbcf8c5e92fd3c696ac692c16b1079
diff --git a/source/expectations/data_values/ut_compound_data_diff_tmp.sql b/source/expectations/data_values/ut_compound_data_diff_tmp.sql
@@ -18,13 +18,9 @@ create global temporary table ut_compound_data_diff_tmp(
   act_item_data xmltype,
   exp_item_data xmltype,
   item_no      integer,
-  pk_hash      raw(128),
-  item_hash    raw(128),
   duplicate_no integer,
-  constraint ut_compound_data_diff_tmp_uk1 unique (diff_id,duplicate_no,item_no,item_hash, pk_hash),
+  constraint ut_compound_data_diff_tmp_uk1 unique (diff_id,duplicate_no,item_no),
   constraint ut_compound_data_diff_tmp_chk check(
-   item_no is not null and pk_hash is null and duplicate_no is null
-   or item_no is null and item_hash is not null and duplicate_no is not null
-   or item_no is null and pk_hash is not null and duplicate_no is not null
+   item_no is not null
    )
 ) on commit preserve rows;
diff --git a/source/expectations/data_values/ut_compound_data_helper.pkb b/source/expectations/data_values/ut_compound_data_helper.pkb
diff --git a/source/expectations/data_values/ut_compound_data_helper.pks b/source/expectations/data_values/ut_compound_data_helper.pks
@@ -16,10 +16,8 @@ create or replace package ut_compound_data_helper authid definer is
   limitations under the License.
   */
 
-  gc_compare_join_by   constant varchar2(10):='join_by';
   gc_compare_unordered constant varchar2(10):='unordered';
   gc_compare_normal    constant varchar2(10):='normal';
-  gc_compare_sql       constant varchar2(10):='sql';
 
   type t_column_diffs is record(
     diff_type     varchar2(1),
@@ -54,10 +52,12 @@ create or replace package ut_compound_data_helper authid definer is
     act_data_id raw(32), 
     exp_item_data xmltype, 
     exp_data_id raw(32),
-    item_no   integer
+    item_no   integer,
+    dup_no    integer
     );
-  type t_diff_tab is table of t_diff_rec; 
-
+
+  type t_diff_tab is table of t_diff_rec;
+
   function get_column_info_xml(a_column_details ut_key_anyval_pair) return xmltype;
 
   function get_columns_filter(
@@ -71,13 +71,11 @@ create or replace package ut_compound_data_helper authid definer is
 
  function get_pk_value (a_join_by_xpath varchar2,a_item_data xmltype) return clob;
 
- function compare_type(a_join_by_xpath in varchar2,a_unordered boolean, a_is_sql_diffable integer := 0) 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,
-    a_join_by_xpath varchar2,a_unorderdered boolean, a_is_sql_diffable integer
-  ) return tt_row_diffs;
+    a_join_by_xpath varchar2,a_unorderdered boolean
+    ) return tt_row_diffs;
 
   subtype t_hash  is raw(128);
 
@@ -92,9 +90,6 @@ create or replace package ut_compound_data_helper authid definer is
   return tt_missing_pk;
 
   function get_refcursor_matcher_sql(a_owner in varchar2,a_inclusion_matcher boolean := false, a_negated_match boolean := false) return varchar2;
-
-  procedure update_row_and_pk_hash(a_self_data_id in raw, a_other_data_id in raw, a_exclude_xpath varchar2, 
-                                   a_include_xpath varchar2, a_join_by_xpath varchar2);
 
   function gen_compare_sql(a_column_info xmltype, a_exclude_xpath varchar2, 
                                    a_include_xpath varchar2, a_join_by_xpath varchar2) return clob;

diff --git a/source/expectations/data_values/ut_compound_data_value.tpb b/source/expectations/data_values/ut_compound_data_value.tpb
@@ -89,29 +89,25 @@ create or replace type body ut_compound_data_value as
     l_row_diffs         ut_compound_data_helper.tt_row_diffs;
     l_compare_type      varchar2(10);
     l_self              ut_compound_data_value;
-    l_is_sql_diff       integer := 0;
 
-    function get_diff_message (a_row_diff ut_compound_data_helper.t_row_diffs,a_compare_type varchar2) return varchar2 is
+    function get_diff_message (a_row_diff ut_compound_data_helper.t_row_diffs,a_is_unordered boolean) return varchar2 is
     begin
-      if a_compare_type in (ut_compound_data_helper.gc_compare_join_by,ut_compound_data_helper.gc_compare_sql) 
-                            and a_row_diff.pk_value is not null then
-        return  '  PK '||a_row_diff.pk_value||' - '||rpad(a_row_diff.diff_type,10)||a_row_diff.diffed_row;
-      elsif a_compare_type = ut_compound_data_helper.gc_compare_join_by or a_compare_type = ut_compound_data_helper.gc_compare_normal then
+
+      if a_is_unordered then     
+        if a_row_diff.pk_value is not null then
+          return  '  PK '||a_row_diff.pk_value||' - '||rpad(a_row_diff.diff_type,10)||a_row_diff.diffed_row;
+        else
+          return rpad(a_row_diff.diff_type,10)||a_row_diff.diffed_row;
+        end if;
+      else
         return '  Row No. '||a_row_diff.rn||' - '||rpad(a_row_diff.diff_type,10)||a_row_diff.diffed_row;
-      elsif a_compare_type in (ut_compound_data_helper.gc_compare_unordered,ut_compound_data_helper.gc_compare_sql) 
-                              and a_row_diff.pk_value is null then
-        return rpad(a_row_diff.diff_type,10)||a_row_diff.diffed_row;
-      end if;
+      end if; 
     end;
 
   begin
     if not a_other is of (ut_compound_data_value) then
       raise value_error;
-    end if;
-
-    if self is of (ut_data_value_refcursor) then
-      l_is_sql_diff := treat(self as ut_data_value_refcursor).is_sql_diffable;
-    end if;    
+    end if; 
 
     l_actual := treat(a_other as ut_compound_data_value);
 
@@ -122,12 +118,12 @@ create or replace type body ut_compound_data_value as
 
     -- First tell how many rows are different
 
-    --REDO that is a bit mess ??
-    if l_is_sql_diff = 1 then
+    --TODO: that is a bit mess ?? Can we use global variable for all matchers.
+    if a_unordered then
       l_diff_row_count := ut_compound_data_helper.get_rows_diff;
     else
       execute immediate 'select count('
-                      ||case when ( a_join_by_xpath is not null and l_is_sql_diff = 0 ) 
+                      ||case when ( a_join_by_xpath is not null ) 
                           then 'distinct pk_hash' 
                           else '*' 
                         end
@@ -137,10 +133,9 @@ create or replace type body ut_compound_data_value as
     end if;                  
 
     if l_diff_row_count > 0  then
-      l_compare_type := ut_compound_data_helper.compare_type(a_join_by_xpath,a_unordered, l_is_sql_diff);
       l_row_diffs := ut_compound_data_helper.get_rows_diff(
             self.data_id, l_actual.data_id, l_diff_id, c_max_rows, a_exclude_xpath, 
-            a_include_xpath, a_join_by_xpath, a_unordered, l_is_sql_diff);
+            a_include_xpath, a_join_by_xpath, a_unordered);
       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
@@ -150,7 +145,7 @@ create or replace type body ut_compound_data_value as
       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),l_compare_type);
+        l_results(l_results.last) := get_diff_message(l_row_diffs(i),a_unordered);
       end loop;
       ut_utils.append_to_clob(l_result,l_results);
     end if;
@@ -164,6 +159,9 @@ create or replace type body ut_compound_data_value as
     l_column_filter   varchar2(32767);
     l_diff_id         ut_compound_data_helper.t_hash;
     l_result          integer;
+
+    l_sql varchar2(32767);
+
     --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
@@ -184,20 +182,40 @@ create or replace type body ut_compound_data_value as
     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_exclude_xpath, a_include_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
+    execute immediate 'insert into ' || l_ut_owner || '.ut_compound_data_diff_tmp ( diff_id, item_no,exp_item_data, act_item_data,exp_data_id, act_data_id )
+                        select :diff_id, nvl(exp.item_no, act.item_no) , exp.item_data, act.item_data, exp.data_id, act.data_id
+                          from ( select '||l_column_filter||', rownum item_no, ucd.data_id                          
+                                  from
+                                  (select xmlelement(name "ROW" ,xt.item_data) item_data, t.data_id
+                                  from ' || l_ut_owner || q'[.ut_compound_data_tmp t,
+                                  xmltable('/ROWSET/ROW'
+                                  passing t.item_data
+                                  columns
+                                  item_data xmltype path '*'
+                                  ) xt
+                                  where t.data_id = :self_guid) ucd
+                                  ) 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 '||
+                               (select ]'||l_column_filter||', rownum item_no, ucd.data_id                           
+                                  from
+                                  (
+                                   select xmlelement(name "ROW" ,xt.item_data) item_data, t.data_id
+                                   from ' || l_ut_owner || q'[.ut_compound_data_tmp t,
+                                   xmltable('/ROWSET/ROW'
+                                   passing t.item_data
+                                   columns
+                                   item_data xmltype path '*'
+                                   ) xt
+                                   where t.data_id = :l_other_guid
+                                  ) ucd
+                                  ) 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*/
                                      '  xmltransform(exp.item_data, :l_xml_data_fmt).getclobval()' ||
@@ -206,6 +224,7 @@ create or replace type body ut_compound_data_value as
                                  ') != 0'
       using in l_diff_id, a_exclude_xpath, a_include_xpath, self.data_id,
          a_exclude_xpath, a_include_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;
@@ -234,12 +253,6 @@ create or replace type body ut_compound_data_value as
 
     l_diff_id := ut_compound_data_helper.get_hash(self.data_id||l_other.data_id);
 
-    /**
-    * Due to incompatibility issues in XML between 11 and 12.2 and 12.1 versions we will prepopulate pk_hash upfront to
-    * avoid optimizer incorrectly rewrite and causing NULL error or ORA-600
-    **/   
-    ut_compound_data_helper.update_row_and_pk_hash(self.data_id, l_other.data_id, a_exclude_xpath,a_include_xpath,a_join_by_xpath);
-
     /*!* 
     * Comparision is based on type of search, for inclusion based search we will look for left join only.
     * For normal two side diff we will peform minus on two sets two get diffrences.
@@ -283,7 +296,7 @@ create or replace type body ut_compound_data_value as
     l_sql_rowcount integer :=0;
 
   begin
-
+   --TODO : Error on xml when same column is more then once in item data xml.Do we need to cleanup ??  
    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);
 
@@ -292,7 +305,6 @@ create or replace type body ut_compound_data_value as
    loop
     fetch l_loop_curs bulk collect into l_diff_tab limit l_max_rows;
     exit when l_diff_tab.count = 0;
-    --Pass it to helper as authid as definer
     if (ut_utils.gc_diff_max_rows > l_sql_rowcount ) then
       ut_compound_data_helper.insert_diffs_result(l_diff_tab,l_diff_id);     
     end if;
@@ -303,14 +315,15 @@ create or replace type body ut_compound_data_value as
       l_max_rows := ut_utils.gc_bc_fetch_limit;
     end if;
    end loop;
-
+       
    ut_compound_data_helper.set_rows_diff(l_sql_rowcount);     
-        --result is OK only if both are same
+        --result is OK only if both are same         
     if l_sql_rowcount = 0 and self.elements_count = l_other.elements_count then
-      l_result := 0;
+      l_result := 0; 
     else
       l_result := 1;
     end if;
+
     return l_result;
 
   end;  

diff --git a/source/expectations/data_values/ut_compound_data_value.tps b/source/expectations/data_values/ut_compound_data_value.tps
@@ -44,8 +44,8 @@ create or replace type ut_compound_data_value force under ut_data_value(
   overriding member function diff( a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, a_unordered boolean := false ) return varchar2,
   member function get_data_diff(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, a_unordered boolean) return clob,
   member function compare_implementation(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2) return integer,
+  member function compare_implementation_by_sql(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, a_inclusion_compare boolean := false) return integer,
   member function compare_implementation(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, 
-                                         a_unordered boolean , a_inclusion_compare boolean := false, a_is_negated boolean := false) return integer,
-  member function compare_implementation_by_sql(a_other ut_data_value, a_exclude_xpath varchar2, a_include_xpath varchar2, a_join_by_xpath varchar2, a_inclusion_compare boolean := false) return integer
+                                         a_unordered boolean , a_inclusion_compare boolean := false, a_is_negated boolean := false ) return integer
 ) not final not instantiable
 /
diff --git a/source/expectations/data_values/ut_curr_usr_compound_helper.pkb b/source/expectations/data_values/ut_curr_usr_compound_helper.pkb
@@ -6,7 +6,7 @@ create or replace package body ut_curr_usr_compound_helper is
   g_anytype_collection_name t_type_name_map;
   g_user_defined_type       pls_integer := dbms_sql.user_defined_type;
   g_is_collection           boolean := false;
-  g_is_sql_diffable         boolean := false;
+  g_is_sql_diffable         boolean := true;
 
   procedure set_collection_state(a_is_collection boolean) is
   begin
@@ -18,26 +18,34 @@ create or replace package body ut_curr_usr_compound_helper is
 
   procedure set_sql_diff_state(a_is_sql_diff boolean) is
   begin
-    --Make sure that we set a g_is_collection only once so we dont reset from true to false.
-    if not g_is_sql_diffable then
+    --Make sure that we set a g_is_collection only once so we dont reset from false to true.
+    if g_is_sql_diffable then
       g_is_sql_diffable := a_is_sql_diff;
     end if;
   end;
 
   function is_sql_compare_allowed(a_type_name varchar2) return boolean is
   begin
     --clob/blob/xmltype/object/nestedcursor/nestedtable
-    if a_type_name IN (g_anytype_name_map(dbms_types.typecode_blob),
-                       g_anytype_name_map(dbms_types.typecode_clob),
-                       g_anytype_name_map(dbms_types.typecode_bfile),
-                       g_anytype_name_map(dbms_types.typecode_varray))
-    then 
+
+
+    if a_type_name IN (g_type_name_map(dbms_sql.blob_type),
+                       g_type_name_map(dbms_sql.clob_type),
+                       g_type_name_map(dbms_sql.bfile_type),
+                       g_type_name_map(dbms_sql.user_defined_type))
+    then    
       return false;
     else
       return true;
     end if;
   end;
 
+  function is_sql_compare_int(a_type_name varchar2) return integer is
+  begin  
+     --raise_application_error(-20111,'no '||a_type_name||ut_utils.boolean_to_int(is_sql_compare_allowed(a_type_name)));
+      return ut_utils.boolean_to_int(is_sql_compare_allowed(a_type_name));
+  end;
+
   function get_column_type(a_desc_rec dbms_sql.desc_rec3, a_desc_user_types boolean := false) return ut_key_anyval_pair is
     l_data ut_data_value;
     l_result ut_key_anyval_pair;
@@ -54,7 +62,7 @@ create or replace package body ut_curr_usr_compound_helper is
       return l_typecode = 'COLLECTION';
     end;
 
-    begin 
+    begin
       if g_type_name_map.exists(a_desc_rec.col_type) then
         l_data := ut_data_value_varchar2(g_type_name_map(a_desc_rec.col_type));
         set_sql_diff_state(is_sql_compare_allowed(g_type_name_map(a_desc_rec.col_type)));
@@ -76,7 +84,7 @@ create or replace package body ut_curr_usr_compound_helper is
         l_data := ut_data_value_varchar2(a_desc_rec.col_schema_name||'.'||a_desc_rec.col_type_name);
         set_sql_diff_state(false);
       end if;
-
+       
       return ut_key_anyval_pair(a_desc_rec.col_name,l_data);
     end;
 
@@ -281,6 +289,7 @@ create or replace package body ut_curr_usr_compound_helper is
   g_type_name_map( dbms_sql.number_type )                  := 'NUMBER';
   g_type_name_map( dbms_sql.rowid_type )                   := 'ROWID';
   g_type_name_map( dbms_sql.urowid_type )                  := 'UROWID';  
+  g_type_name_map( dbms_sql.user_defined_type )            := 'USER_DEFINED_TYPE'; 
 
 end;
 /
diff --git a/source/expectations/data_values/ut_curr_usr_compound_helper.pks b/source/expectations/data_values/ut_curr_usr_compound_helper.pks
@@ -1,5 +1,9 @@
 create or replace package ut_curr_usr_compound_helper authid current_user is
 
+  function is_sql_compare_allowed(a_type_name varchar2) return boolean;
+
+  function is_sql_compare_int(a_type_name varchar2) return integer;
+
   procedure get_columns_info(
     a_cursor in out nocopy sys_refcursor,
     a_columns_info out nocopy xmltype,
@@ -9,6 +13,6 @@ create or replace package ut_curr_usr_compound_helper authid current_user is
   );
 
   function get_user_defined_type(a_owner varchar2, a_type_name varchar2) return xmltype;
-
+  
 end;
 /