Further deprecation of Xpath

utPLSQL · jgebal · Mar 15, 2019 · Oct 6, 2018 · Oct 6, 2018 · Oct 6, 2018
commit 6cb5fe7d629889185ff3fae6db44040b912080d2
diff --git a/source/expectations/data_values/ut_compound_data_helper.pkb b/source/expectations/data_values/ut_compound_data_helper.pkb
@@ -85,81 +85,45 @@ create or replace package body ut_compound_data_helper is
     end if;
     return l_filter;
   end;
-
-  function get_columns_diff(
-    a_expected xmltype, a_actual xmltype, a_exclude_xpath varchar2, a_include_xpath varchar2
-  ) return tt_column_diffs is
+
+  function get_columns_diff(a_expected ut_cursor_column_tab, a_actual ut_cursor_column_tab) 
+  return tt_column_diffs is
     l_column_filter  varchar2(32767);
     l_sql            varchar2(32767);
     l_results        tt_column_diffs;
   begin
-    l_column_filter := get_columns_row_filter(a_exclude_xpath, a_include_xpath);
-    --CARDINALITY hints added to address issue: https://github.com/utPLSQL/utPLSQL/issues/752
-    l_sql := q'[
-      with
-        expected_cols as ( select :a_expected as item_data from dual ),
-        actual_cols as ( select :a_actual as item_data from dual ),
-        expected_cols_info as (
-          select e.*,
-                 replace(expected_type,'VARCHAR2','CHAR') expected_type_compare
-            from (
-                  select /*+ CARDINALITY(xt 100) */
-                         rownum expected_pos,
-                         xt.name expected_name,
-                         xt.type expected_type
-                    from (select ]'||l_column_filter||q'[ from expected_cols ucd) x,
-                         xmltable(
-                           '/ROW/*'
-                           passing x.item_data
-                           columns
-                             name     varchar2(4000)  PATH '@xml_valid_name',
-                             type     varchar2(4000) PATH '/'
-                         ) xt
-                 ) e
-        ),
-        actual_cols_info as (
-          select a.*,
-                 replace(actual_type,'VARCHAR2','CHAR') actual_type_compare
-            from (select /*+ CARDINALITY(xt 100) */
-                         rownum actual_pos,
-                         xt.name actual_name,
-                         xt.type actual_type
-                    from (select ]'||l_column_filter||q'[ from actual_cols ucd) x,
-                         xmltable('/ROW/*'
-                           passing x.item_data
-                           columns
-                             name     varchar2(4000)  path '@xml_valid_name',
-                             type      varchar2(4000) path '/'
-                         ) xt
-                 ) a
-        ),
-        joined_cols as (
-         select e.*, a.*,
-                row_number() over(partition by case when actual_pos + expected_pos is not null then 1 end order by actual_pos) a_pos_nn,
-                row_number() over(partition by case when actual_pos + expected_pos is not null then 1 end order by expected_pos) e_pos_nn
-           from expected_cols_info e
-           full outer join actual_cols_info a on e.expected_name = a.actual_name
-      )
+    with 
+      expected_cols as 
+      (select access_path exp_column_name,column_position exp_col_pos,
+      replace(column_type,'VARCHAR2','CHAR') exp_col_type_compare, column_type exp_col_type
+      from table(a_expected)),
+      actual_cols as
+      (select access_path act_column_name,column_position act_col_pos,
+      replace(column_type,'VARCHAR2','CHAR') act_col_type_compare, column_type act_col_type
+      from table(a_actual)),
+      joined_cols as
+      (select e.*,a.*,
+        row_number() over(partition by case when a.act_col_pos + e.exp_col_pos is not null then 1 end order by a.act_col_pos) a_pos_nn,
+        row_number() over(partition by case when a.act_col_pos + e.exp_col_pos is not null then 1 end order by e.exp_col_pos) e_pos_nn
+      from expected_cols e
+      full outer join actual_cols a on e.exp_column_name = a.act_column_name)
       select case
-               when expected_pos is null and actual_pos is not null then '+'
-               when expected_pos is not null and actual_pos is null then '-'
-               when expected_type_compare != actual_type_compare then 't'
+               when exp_col_pos is null and act_col_pos is not null then '+'
+               when exp_col_pos is not null and act_col_pos is null then '-'
+               when exp_col_type_compare != act_col_type_compare then 't'
                else 'p'
              end as diff_type,
-             expected_name, expected_type, expected_pos,
-             actual_name, actual_type, actual_pos
+             exp_column_name, exp_col_type, exp_col_pos,
+             act_column_name, act_col_type, act_col_pos
+        bulk collect into l_results
         from joined_cols
              --column is unexpected (extra) or missing
-       where actual_pos is null or expected_pos is null
+       where act_col_pos is null or exp_col_pos is null
           --column type is not matching (except CHAR/VARCHAR2)
-          or actual_type_compare != expected_type_compare
+          or act_col_type_compare != exp_col_type_compare
           --column position is not matching (both when excluded extra/missing columns as well as when they are included)
-          or (a_pos_nn != e_pos_nn and expected_pos != actual_pos)
-       order by expected_pos, actual_pos]';
-    execute immediate l_sql
-      bulk collect into l_results
-      using a_expected, a_actual, a_exclude_xpath, a_include_xpath, a_exclude_xpath, a_include_xpath;
-
+          or (a_pos_nn != e_pos_nn and exp_col_pos != act_col_pos)
+       order by exp_col_pos, act_col_pos;
     return l_results;
   end;
 
@@ -690,6 +654,7 @@ create or replace package body ut_compound_data_helper is
    end if;
    ut_utils.append_to_clob(l_compare_sql,l_temp_string);
 
+   dbms_output.put_line(l_compare_sql);
    return l_compare_sql;
   end;
 
@@ -735,12 +700,8 @@ create or replace package body ut_compound_data_helper is
      select lev,column_name,parent_name from hier),
      t1(column_name, parent_name) AS (
      select column_name,parent_name from table(:a_cursor_info) where parent_name is null
-    union all
-    select t2.column_name,t2.parent_name from table(:a_cursor_info) t2, t1 where t2.parent_name = t1.column_name)
-    select ut_cursor_column(i.column_name,i.column_schema,i.column_type_name, i.column_prec,i.column_scale,i.column_len, i.parent_name, 
-     i.hierarchy_level,i.column_position, i.column_type)
-    from t1 join table(:a_cursor_info) i on ( nvl(t1.parent_name,1) = nvl(i.parent_name,1) and t1.column_name = i.column_name)
-    ]';
+     union all
+     select t2.column_name,t2.parent_name from table(:a_cursor_info) t2, t1 where t2.parent_name = t1.column_name)]';
   begin
     return l_sql;
   end;
@@ -750,10 +711,13 @@ create or replace package body ut_compound_data_helper is
     l_sql varchar2(32767) := get_cursor_vs_list_sql;
     l_result ut_cursor_column_tab := ut_cursor_column_tab();
   begin
+   l_sql := l_sql || q'[select ut_cursor_column(i.column_name,i.column_schema,i.column_type_name, i.column_prec,i.column_scale,i.column_len, i.parent_name, 
+     i.hierarchy_level,i.column_position, i.column_type)
+     from t1 join table(:a_cursor_info) i on ( nvl(t1.parent_name,1) = nvl(i.parent_name,1) and t1.column_name = i.column_name)]';
    if a_include then 
     l_sql := l_sql || ' join constructed c on ( nvl(t1.parent_name,1) = nvl(c.parent_name,1) and t1.column_name = c.column_name)';
    else
-    l_sql := l_sql ||'left outer join constructed c on ( nvl(t1.parent_name,1) = nvl(c.parent_name,1) and t1.column_name = c.column_name)
+    l_sql := l_sql ||' left outer join constructed c on ( nvl(t1.parent_name,1) = nvl(c.parent_name,1) and t1.column_name = c.column_name)
     where c.column_name is null';
    end if;
 
@@ -764,18 +728,35 @@ create or replace package body ut_compound_data_helper is
   end;
 
   function compare_cursor_to_columns(a_cursor_info ut_cursor_column_tab, a_current_list ut_varchar2_list) 
-  return ut_cursor_column_tab is
+  return ut_varchar2_list is
     l_sql varchar2(32767) := get_cursor_vs_list_sql;
-    l_result ut_cursor_column_tab := ut_cursor_column_tab();
+    l_result ut_varchar2_list := ut_varchar2_list();
   begin
+    l_sql := l_sql || q'[select c.parent_name || case when c.parent_name is null then null else '/' end ||c.column_name 
+     from t1 join table(:a_cursor_info) i on ( nvl(t1.parent_name,1) = nvl(i.parent_name,1) and t1.column_name = i.column_name)]';
     l_sql := l_sql ||'right outer join constructed c on ( nvl(t1.parent_name,1) = nvl(c.parent_name,1) and t1.column_name = c.column_name)
     where t1.column_name is null';
 
     execute immediate l_sql bulk collect into l_result
     using a_current_list,a_cursor_info,a_cursor_info,a_cursor_info;   
     return l_result;
   end;
-
+
+  function get_missing_pk(a_expected ut_cursor_column_tab, a_actual ut_cursor_column_tab, a_current_list ut_varchar2_list) 
+  return tt_missing_pk is
+    l_actual ut_varchar2_list := coalesce(compare_cursor_to_columns(a_actual,a_current_list),ut_varchar2_list());
+    l_expected  ut_varchar2_list := coalesce(compare_cursor_to_columns(a_expected,a_current_list),ut_varchar2_list());
+    l_missing_pk tt_missing_pk;
+  begin 
+    select name,type
+    bulk collect into l_missing_pk
+    from
+    (select act.column_value name, 'e' type from table(l_expected) act    
+    union all
+    select exp.column_value name, 'a' type from table(l_actual) exp)
+    order by type desc,name;
+    return l_missing_pk;
+  end;
 
   function inc_exc_columns_from_cursor (a_cursor_info ut_cursor_column_tab, a_exclude_xpath ut_varchar2_list, a_include_xpath ut_varchar2_list)
   return ut_cursor_column_tab is
@@ -819,5 +800,13 @@ create or replace package body ut_compound_data_helper is
     return l_result;
   end;
 
+  function contains_collection (a_cursor_info ut_cursor_column_tab) return number is
+    l_collection_elements number;
+  begin
+    select count(1) into l_collection_elements from
+    table(a_cursor_info) c where c.is_collection = 1;
+    return l_collection_elements;
+  end;
+
 end; 
 /
diff --git a/source/expectations/data_values/ut_compound_data_helper.pks b/source/expectations/data_values/ut_compound_data_helper.pks
@@ -65,9 +65,8 @@ create or replace package ut_compound_data_helper authid definer is
     a_table_alias varchar2 := 'ucd', a_column_alias varchar2 := 'item_data'
   ) return varchar2;
 
-  function get_columns_diff(
-    a_expected xmltype, a_actual xmltype, a_exclude_xpath varchar2, a_include_xpath varchar2
-  ) return tt_column_diffs;
+  function get_columns_diff(a_expected ut_cursor_column_tab, a_actual ut_cursor_column_tab) 
+  return tt_column_diffs;
 
  function get_pk_value (a_join_by_xpath varchar2,a_item_data xmltype) return clob;
 
@@ -107,10 +106,15 @@ create or replace package ut_compound_data_helper authid definer is
   return ut_cursor_column_tab;
 
   function compare_cursor_to_columns(a_cursor_info ut_cursor_column_tab, a_current_list ut_varchar2_list) 
-  return ut_cursor_column_tab;
+  return ut_varchar2_list;
+
+  function get_missing_pk(a_expected ut_cursor_column_tab, a_actual ut_cursor_column_tab, a_current_list ut_varchar2_list) 
+  return tt_missing_pk;
 
   function inc_exc_columns_from_cursor (a_cursor_info ut_cursor_column_tab, a_exclude_xpath ut_varchar2_list, a_include_xpath ut_varchar2_list)  
   return ut_cursor_column_tab;
 
+  function contains_collection (a_cursor_info ut_cursor_column_tab) return number;
+
 end;
 /
diff --git a/source/expectations/data_values/ut_compound_data_value.tpb b/source/expectations/data_values/ut_compound_data_value.tpb
@@ -79,6 +79,7 @@ create or replace type body ut_compound_data_value as
     return l_result_string;
   end;
 
+  -- TODO : Rework to exclude xpath 
   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 is
     c_max_rows          integer := ut_utils.gc_diff_max_rows;
@@ -128,15 +129,16 @@ create or replace type body ut_compound_data_value as
       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.' 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),a_unordered);
       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;

diff --git a/source/expectations/data_values/ut_curr_usr_compound_helper.pkb b/source/expectations/data_values/ut_curr_usr_compound_helper.pkb
@@ -20,7 +20,8 @@ create or replace package body ut_curr_usr_compound_helper is
     --clob/blob/xmltype/object/nestedcursor/nestedtable
     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.bfile_type),
+                       g_anytype_name_map(dbms_types.typecode_namedcollection))
     then    
       return false;
     else

diff --git a/source/expectations/data_values/ut_cursor_column.tpb b/source/expectations/data_values/ut_cursor_column.tpb
@@ -34,6 +34,11 @@ create or replace type body ut_cursor_column as
       self.has_nested_col := case when lower(self.column_type) = 'user_defined_type' and self.is_collection = 0 then 1 else 0 end;
    end;
 
+   --TODO : Scenarios : 
+   --namedcollection xmltype getclobhash
+   --collection  xml type get clob hash
+   -- user defined type
+
    constructor function ut_cursor_column( self in out nocopy ut_cursor_column,
      a_col_name varchar2, a_col_schema_name varchar2,
      a_col_type_name varchar2, a_col_prec integer, a_col_scale integer,

diff --git a/source/expectations/data_values/ut_data_value_refcursor.tpb b/source/expectations/data_values/ut_data_value_refcursor.tpb
@@ -116,14 +116,17 @@ create or replace type body ut_data_value_refcursor as
     return l_result_string;
   end;
 
-  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 is
+  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, a_join_by_list ut_varchar2_list:=ut_varchar2_list() ) return varchar2 is
     l_result            clob;
     l_results           ut_utils.t_clob_tab := ut_utils.t_clob_tab();
     l_result_string     varchar2(32767);
     l_actual            ut_data_value_refcursor;
     l_column_diffs      ut_compound_data_helper.tt_column_diffs := ut_compound_data_helper.tt_column_diffs();
     l_exclude_xpath     varchar2(32767) := a_exclude_xpath;
+
     l_missing_pk        ut_compound_data_helper.tt_missing_pk := ut_compound_data_helper.tt_missing_pk();
+    l_col_diffs         ut_compound_data_helper.tt_column_diffs := ut_compound_data_helper.tt_column_diffs();
 
     function get_col_diff_text(a_col ut_compound_data_helper.t_column_diffs) return varchar2 is
     begin
@@ -143,7 +146,6 @@ create or replace type body ut_data_value_refcursor as
     function get_missing_key_message(a_missing_keys ut_compound_data_helper.t_missing_pk) return varchar2 is
       l_message varchar2(200);
     begin
-
       if a_missing_keys.diff_type = 'a' then
         l_message :=  '  Join key '||a_missing_keys.missingxpath||' does not exists in actual';
       elsif a_missing_keys.diff_type = 'e' then
@@ -184,7 +186,7 @@ create or replace type body ut_data_value_refcursor as
 
     --diff columns
     if not self.is_null and not l_actual.is_null then
-      l_column_diffs := ut_compound_data_helper.get_columns_diff(self.columns_info, l_actual.columns_info, a_exclude_xpath, a_include_xpath);
+      l_column_diffs := ut_compound_data_helper.get_columns_diff(self.cursor_details.cursor_info,l_actual.cursor_details.cursor_info);
 
       if l_column_diffs.count > 0 then
         ut_utils.append_to_clob(l_result,chr(10) || 'Columns:' || chr(10));
@@ -199,8 +201,8 @@ create or replace type body ut_data_value_refcursor as
     end if;
 
     --check for missing pk 
-    if (a_join_by_xpath is not null) then
-      l_missing_pk := ut_compound_data_helper.is_pk_exists(self.key_info, l_actual.key_info, a_exclude_xpath, a_include_xpath,a_join_by_xpath);
+    if a_join_by_list.count > 0 then
+      l_missing_pk := ut_compound_data_helper.get_missing_pk(self.cursor_details.cursor_info,l_actual.cursor_details.cursor_info,a_join_by_list);
     end if;
 
     --diff rows and row elements if the pk is not missing 
@@ -213,7 +215,8 @@ create or replace type body ut_data_value_refcursor as
           ut_utils.append_to_clob(l_result, get_missing_key_message(l_missing_pk(i))|| chr(10));
         end loop;
 
-        if ut_utils.int_to_boolean(self.contain_collection) or ut_utils.int_to_boolean(l_actual.contain_collection) then
+        if ut_compound_data_helper.contains_collection(self.cursor_details.cursor_info) > 0 
+           or ut_compound_data_helper.contains_collection(l_actual.cursor_details.cursor_info) > 0 then
           ut_utils.append_to_clob(l_result,'  Please make sure that your join clause is not refferring to collection element'|| chr(10));
         end if;
 
@@ -228,36 +231,29 @@ create or replace type body ut_data_value_refcursor as
                                           a_is_negated boolean := false, a_join_by_list ut_varchar2_list:=ut_varchar2_list()) 
                                           return integer is
     l_result          integer := 0;
-    l_other           ut_data_value_refcursor;
-
-    l_act_pk          ut_cursor_column_tab;
-    l_exp_pk          ut_cursor_column_tab;
+    l_actual          ut_data_value_refcursor;
+
+    l_pk_missing_tab ut_compound_data_helper.tt_missing_pk;
 
-    function is_pk_missing (a_pk_missing_tab ut_compound_data_helper.tt_missing_pk) return integer is
-    begin
-      return case when a_pk_missing_tab.count > 0 then 1 else 0 end;
-    end;
   begin
     if not a_other is of (ut_data_value_refcursor) then
       raise value_error;
     end if;
 
-    l_other   := treat(a_other as ut_data_value_refcursor);
+    l_actual   := treat(a_other as ut_data_value_refcursor);
 
     --if we join by key and key is missing fail and report error
     if a_join_by_list.count > 0 then
-      l_act_pk := ut_compound_data_helper.compare_cursor_to_columns(self.cursor_details.cursor_info ,a_join_by_list);
-      l_exp_pk := ut_compound_data_helper.compare_cursor_to_columns(l_other.cursor_details.cursor_info,a_join_by_list);
-      l_result := case when (l_act_pk.count > 0) or (l_exp_pk.count > 0) then 1 else 0 end;
+      l_pk_missing_tab := ut_compound_data_helper.get_missing_pk(self.cursor_details.cursor_info,l_actual.cursor_details.cursor_info,a_join_by_list);
+      l_result := case when (l_pk_missing_tab.count > 0) then 1 else 0 end;
     end if;
 
-
     if l_result = 0 then     
-      if (self.cursor_details is not null and l_other.cursor_details is not null) and (self.cursor_details != l_other.cursor_details) then 
+      if (self.cursor_details is not null and l_actual.cursor_details is not null) and (self.cursor_details != l_actual.cursor_details) then 
         l_result := 1; 
-      end if;    
+      end if;
       l_result := l_result + (self as ut_compound_data_value).compare_implementation(a_other,a_unordered, a_inclusion_compare, 
-                              a_is_negated, a_join_by_list);  
+                              a_is_negated, a_join_by_list); 
     end if;
 
     return l_result;