Update to cursor comparision

utPLSQL · jgebal · Mar 15, 2019 · Oct 6, 2018 · Oct 6, 2018 · Oct 6, 2018
commit 1356f39ef70082d9b7e3933834c40dd869099d1b
diff --git a/source/expectations/data_values/ut_compound_data_helper.pkb b/source/expectations/data_values/ut_compound_data_helper.pkb
@@ -444,6 +444,7 @@ create or replace package body ut_compound_data_helper is
     ut_utils.append_to_clob(a_equal_stmt,l_sql_stmt);
   end;
 
+  --TODO : Scenario where join by is on whole type not a column of type e.g. NESTEDTABLE
   procedure generate_partition_stmt(a_data_info ut_cursor_column, a_partition_stmt in out nocopy clob,a_pk_table in ut_varchar2_list,a_col_name in varchar2) is  
     l_alias varchar2(10) := 'ucd.';
     l_pk_tab ut_varchar2_list := coalesce(a_pk_table,ut_varchar2_list());
@@ -486,10 +487,20 @@ create or replace package body ut_compound_data_helper is
   begin    
     if a_data_info.is_sql_diffable = 0 then 
       l_col_type := 'XMLTYPE';
+    --TODO : Is it right to use timestamp ?
     elsif a_data_info.is_sql_diffable = 1  and a_data_info.column_type = 'DATE' then 
       l_col_type := 'TIMESTAMP';
+    elsif  a_data_info.is_sql_diffable = 1  and a_data_info.column_type in ('TIMESTAMP','TIMESTAMP WITH TIME ZONE') then
+      l_col_type := a_data_info.column_type;
+    --TODO : Oracle bug : https://community.oracle.com/thread/1957521
+    elsif a_data_info.is_sql_diffable = 1  and a_data_info.column_type = 'TIMESTAMP WITH LOCAL TIME ZONE' then
+      l_col_type := 'VARCHAR2(50)';
+    elsif  a_data_info.is_sql_diffable = 1  and a_data_info.column_type in ('INTERVAL DAY TO SECOND','INTERVAL YEAR TO MONTH') then
+      l_col_type := a_data_info.column_type;
     else 
-       l_col_type := a_data_info.column_type||case when a_data_info.column_len is not null then  '('||a_data_info.column_len||')' else null end;
+       l_col_type := a_data_info.column_type||case when a_data_info.column_len is not null then  
+         '('||a_data_info.column_len||')' 
+       else null end;
     end if;
     l_sql_stmt := ' '||a_col_name||' '||l_col_type||q'[ PATH ']'||a_data_info.access_path||q'[',]';   
     ut_utils.append_to_clob(a_sql_stmt, l_sql_stmt);
@@ -654,7 +665,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);
+   --dbms_output.put_line(l_compare_sql);
    return l_compare_sql;
   end;
 
@@ -689,15 +700,17 @@ create or replace package body ut_compound_data_helper is
    l_sql varchar2(32767) :=
     q'[with 
       sorted as
-      (select r_num,regexp_substr(t.column_value, '[^/]+', 1, commas.column_value) as colval,commas.column_value lev
+      (select r_num,regexp_substr(t.column_value, '[^/]+', 1, commas.column_value) as colval,commas.column_value lev,
+       t.column_value access_path
        from (select row_number() over(order by 1) r_num, column_value from ((table(:a_current_list)))) t,
               table(cast(multiset 
               (select level from dual connect by level <= length(regexp_replace(t.column_value,'[^/]+')) + 1) as sys.odcinumberlist)) commas
               order by r_num,lev),
       hier as
-        (select r_num,lev,colval column_name,lag(colval, 1) over(partition by r_num order by lev) parent_name from sorted),
+        (select r_num,lev,colval column_name,lag(colval, 1) over(partition by r_num order by lev) parent_name , access_path 
+         from sorted),
      constructed as (
-     select lev,column_name,parent_name from hier),
+     select lev,column_name,parent_name,access_path 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
@@ -712,7 +725,7 @@ create or replace package body ut_compound_data_helper is
     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)
+     i.hierarchy_level,i.column_position, i.column_type, i.is_collection)
      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)';
@@ -732,7 +745,7 @@ create or replace package body ut_compound_data_helper is
     l_sql varchar2(32767) := get_cursor_vs_list_sql;
     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 
+    l_sql := l_sql || q'[select c.access_path 
      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';

diff --git a/source/expectations/data_values/ut_compound_data_value.tpb b/source/expectations/data_values/ut_compound_data_value.tpb
@@ -229,20 +229,21 @@ create or replace type body ut_compound_data_value as
     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;
-
     l_sql_rowcount := l_sql_rowcount + l_diff_tab.count;
     if (ut_utils.gc_diff_max_rows <= l_sql_rowcount and l_max_rows != ut_utils.gc_bc_fetch_limit ) then
       l_max_rows := ut_utils.gc_bc_fetch_limit;
     end if;
-   end loop;      
+   end loop;
+
+   ut_compound_data_helper.set_rows_diff(l_sql_rowcount); 
         --result is OK only if both are same  
-    if l_sql_rowcount = 0 and ( self.elements_count = l_other.elements_count or a_inclusion_compare )then
-      l_result := 0; 
-    else
-      ut_compound_data_helper.set_rows_diff(l_sql_rowcount); 
-      l_result := 1;
-    end if; 
-    return l_result;
+   if l_sql_rowcount = 0 and ( self.elements_count = l_other.elements_count or a_inclusion_compare )then
+     l_result := 0; 
+   else
+     l_result := 1;
+   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
@@ -34,15 +34,22 @@ create or replace package body ut_curr_usr_compound_helper is
       return ut_utils.boolean_to_int(is_sql_compare_allowed(a_type_name));
   end;
 
-  function is_collection (a_owner varchar2,a_type_name varchar2) return boolean is
+  function is_collection (a_owner varchar2,a_type_name varchar2, a_anytype_code in integer :=null) return boolean is
       l_type_view varchar2(200) := ut_metadata.get_dba_view('dba_types');
       l_typecode varchar2(100);
     begin
-      execute immediate 'select typecode from '||l_type_view ||' 
-      where owner = :owner and type_name = :typename'
-      into l_typecode using a_owner,a_type_name;   
 
-      return l_typecode = 'COLLECTION';
+      if a_anytype_code is null then
+
+        execute immediate 'select typecode from '||l_type_view ||' 
+        where owner = :owner and type_name = :typename'
+        into l_typecode using a_owner,a_type_name; 
+
+        return l_typecode = 'COLLECTION';
+      else
+       return a_anytype_code in (dbms_types.typecode_varray,dbms_types.typecode_table,dbms_types.typecode_namedcollection);
+      end if;
+
     exception
       when no_data_found then
       return false;

diff --git a/source/expectations/data_values/ut_curr_usr_compound_helper.pks b/source/expectations/data_values/ut_curr_usr_compound_helper.pks
@@ -4,7 +4,7 @@ create or replace package ut_curr_usr_compound_helper authid current_user is
 
   function is_sql_compare_int(a_type_name varchar2) return integer;
 
-  function is_collection (a_owner varchar2,a_type_name varchar2) return boolean;
+  function is_collection (a_owner varchar2,a_type_name varchar2, a_anytype_code in integer :=null) return boolean;
 
   --TODO Depracate once switch fully to type
   procedure get_columns_info(

diff --git a/source/expectations/data_values/ut_cursor_column.tpb b/source/expectations/data_values/ut_cursor_column.tpb
@@ -3,8 +3,8 @@ create or replace type body ut_cursor_column as
    member procedure init(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,
-     a_col_max_len integer, a_parent_name varchar2 := null, a_hierarchy_level number := 1,
-     a_col_position number, a_col_type varchar2) is
+     a_col_max_len integer, a_parent_name varchar2 := null, a_hierarchy_level integer := 1,
+     a_col_position integer, a_col_type varchar2, a_collection integer) is
    begin
       self.parent_name     := a_parent_name;
       self.hierarchy_level := a_hierarchy_level;
@@ -29,7 +29,7 @@ create or replace type body ut_cursor_column as
                                 ut_utils.boolean_to_int(ut_curr_usr_compound_helper.is_sql_compare_allowed(self.column_type))
                               end;
       --TODO : Part of the constructor same as has nested ??
-      self.is_collection   := ut_utils.boolean_to_int(ut_curr_usr_compound_helper.is_collection(a_col_schema_name,a_col_type_name));
+      self.is_collection   := a_collection;
       --TODO : fix that as is nasty hardcode
       self.has_nested_col := case when lower(self.column_type) = 'user_defined_type' and self.is_collection = 0 then 1 else 0 end;
    end;
@@ -42,11 +42,11 @@ create or replace type body ut_cursor_column as
    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,
-     a_col_max_len integer, a_parent_name varchar2 := null, a_hierarchy_level number := 1,
-     a_col_position number, a_col_type in varchar2) return self as result is
+     a_col_max_len integer, a_parent_name varchar2 := null, a_hierarchy_level integer := 1,
+     a_col_position integer, a_col_type in varchar2, a_collection integer) return self as result is
    begin
      init(a_col_name, a_col_schema_name, a_col_type_name, a_col_prec,
-       a_col_scale, a_col_max_len, a_parent_name,a_hierarchy_level, a_col_position, a_col_type);
+       a_col_scale, a_col_max_len, a_parent_name,a_hierarchy_level, a_col_position, a_col_type, a_collection);
    return;
    end;
 end;

diff --git a/source/expectations/data_values/ut_cursor_column.tps b/source/expectations/data_values/ut_cursor_column.tps
@@ -20,14 +20,14 @@ create or replace type ut_cursor_column force authid current_user as object
    member procedure init(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,
-     a_col_max_len integer, a_parent_name varchar2 := null, a_hierarchy_level number := 1,
-     a_col_position number, a_col_type in varchar2),
+     a_col_max_len integer, a_parent_name varchar2 := null, a_hierarchy_level integer := 1,
+     a_col_position integer, a_col_type in varchar2, a_collection integer),
 
    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,
-     a_col_max_len integer, a_parent_name varchar2 := null, a_hierarchy_level number := 1,
-     a_col_position number, a_col_type in varchar2) 
+     a_col_max_len integer, a_parent_name varchar2 := null, a_hierarchy_level integer := 1,
+     a_col_position integer, a_col_type in varchar2, a_collection integer) 
    return self as result
 )
 /
diff --git a/source/expectations/data_values/ut_cursor_details.tpb b/source/expectations/data_values/ut_cursor_details.tpb
@@ -3,12 +3,14 @@ create or replace type body ut_cursor_details as
   order member function compare(a_other ut_cursor_details) return integer is
    l_diffs integer;
   begin
+
     select count(1) into l_diffs
     from table(self.cursor_info) a full outer join table(a_other.cursor_info) e
     on  ( decode(a.parent_name,e.parent_name,1,0)= 1 and a.column_name = e.column_name and 
-          REPLACE(a.column_type,'VARCHAR','CHAR') =  REPLACE(e.column_type,'VARCHAR','CHAR')
+          REPLACE(a.column_type,'VARCHAR2','CHAR') =  REPLACE(e.column_type,'VARCHAR2','CHAR')
          and  a.column_position = e.column_position )
     where a.column_name is null or e.column_name is null;
+
     return l_diffs;
   end;
 
@@ -69,7 +71,8 @@ create or replace type body ut_cursor_details as
     l_csid               pls_integer;
     l_csfrm              pls_integer;
     l_attr_elt_type      anytype;
-    l_anytype  anytype;      
+    l_anytype            anytype;     
+    l_is_collection      boolean;
    begin
       self.cursor_info := ut_cursor_column_tab();
       l_cursor_number  := dbms_sql.to_cursor_number(a_cursor);
@@ -79,6 +82,7 @@ create or replace type body ut_cursor_details as
       a_cursor := dbms_sql.to_refcursor(l_cursor_number);
 
       for cur in 1 .. l_columns_count loop
+         l_is_collection := ut_curr_usr_compound_helper.is_collection(l_columns_desc(cur).col_schema_name,l_columns_desc(cur).col_type_name);
          self.cursor_info.extend;
          self.cursor_info(cursor_info.last) := ut_cursor_column(  l_columns_desc(cur).col_name,
                                                                   l_columns_desc(cur).col_schema_name,
@@ -89,11 +93,10 @@ create or replace type body ut_cursor_details as
                                                                   null,
                                                                   1,
                                                                   cur,
-                                                                  ut_curr_usr_compound_helper.get_column_type_desc(l_columns_desc(cur).col_type,true)
+                                                                  ut_curr_usr_compound_helper.get_column_type_desc(l_columns_desc(cur).col_type,true),
+                                                                  ut_utils.boolean_to_int(l_is_collection)
                                                                   );                                                                  
-        if l_columns_desc(cur).col_type = dbms_sql.user_defined_type 
-           and 
-           not ut_curr_usr_compound_helper.is_collection(l_columns_desc(cur).col_schema_name,l_columns_desc(cur).col_type_name) then
+        if l_columns_desc(cur).col_type = dbms_sql.user_defined_type and not l_is_collection then
           l_anytype := get_user_defined_type(l_columns_desc(cur).col_schema_name , l_columns_desc(cur).col_type_name );
           for i in 1 .. get_anytype_attribute_count(l_anytype) loop
            l_attribute_typecode := l_anytype.getattreleminfo(pos           => i, --First attribute
@@ -105,17 +108,19 @@ create or replace type body ut_cursor_details as
                                                            attr_elt_type => l_attr_elt_type,
                                                            aname         => l_aname);
 
+          l_is_collection := ut_curr_usr_compound_helper.is_collection(l_columns_desc(cur).col_schema_name,l_columns_desc(cur).col_type_name,l_attribute_typecode);
           self.cursor_info.extend;
           self.cursor_info(cursor_info.last) := ut_cursor_column( l_aname,
-                                                                  null,
+                                                                  l_columns_desc(cur).col_schema_name,
                                                                   null,
                                                                   l_prec,
                                                                   l_scale,
                                                                   l_len,
                                                                   l_columns_desc(cur).col_name,
                                                                   2,
                                                                   i,
-                                                                  ut_curr_usr_compound_helper.get_column_type_desc(l_attribute_typecode,false)
+                                                                  ut_curr_usr_compound_helper.get_column_type_desc(l_attribute_typecode,false),
+                                                                  ut_utils.boolean_to_int(l_is_collection)
                                                                   );          
           end loop;
         end if;

diff --git a/source/expectations/data_values/ut_data_value_refcursor.tpb b/source/expectations/data_values/ut_data_value_refcursor.tpb
@@ -248,6 +248,7 @@ create or replace type body ut_data_value_refcursor as
       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_actual.cursor_details is not null) and (self.cursor_details != l_actual.cursor_details) then 
         l_result := 1; 

diff --git a/source/expectations/matchers/ut_include.tpb b/source/expectations/matchers/ut_include.tpb
@@ -51,6 +51,7 @@ create or replace type body ut_include as
   overriding member function run_matcher(self in out nocopy ut_include, a_actual ut_data_value) return boolean is
     l_result boolean;
     l_actual ut_data_value;
+    l_result1 integer;
   begin
     --TODO : Join by exclude an include should show differences
     if self.expected.data_type = a_actual.data_type then

diff --git a/source/expectations/ut_expectation.tpb b/source/expectations/ut_expectation.tpb
@@ -33,12 +33,9 @@ create or replace type body ut_expectation as
     l_message       varchar2(32767);
   begin
     --Negated matcher for include option.
-    if (l_matcher is of (ut_include)) then
-      l_expectation_result := l_matcher.run_matcher( self.actual_data );
-    else
-      l_expectation_result := l_matcher.run_matcher_negated( self.actual_data );
-    end if;
+    l_expectation_result := l_matcher.run_matcher_negated( self.actual_data );
     l_expectation_result := coalesce(l_expectation_result,false);
+
     l_message := coalesce( l_matcher.error_message( self.actual_data ), l_matcher.failure_message_when_negated( self.actual_data ) );
     ut_expectation_processor.add_expectation_result( ut_expectation_result( ut_utils.to_test_result( l_expectation_result ), self.description, l_message ) );
   end;

diff --git a/test/core/expectations/test_expectations_cursor.pkb b/test/core/expectations/test_expectations_cursor.pkb
@@ -2442,7 +2442,7 @@ Diff:%
   begin
     --Arrange
     open l_actual for select username,rownum * 10 user_id from all_users where rownum < 5;
-    open l_expected for select username ,rownum user_id from all_users where rownum < 5;
+    open l_expected for select username||to_char(rownum) username ,rownum user_id from all_users where rownum < 5;
 
     --Act
     ut3.ut.expect(l_actual).not_to_contain(l_expected).join_by('USER_ID');
@@ -2456,7 +2456,7 @@ Diff:%
   begin
     --Arrange
     open l_actual for select username,rownum * 10 user_id from all_users where rownum < 5;
-    open l_expected for select username ,rownum user_id from all_users where rownum < 5;
+    open l_expected for select username||to_char(rownum) username ,rownum user_id from all_users where rownum < 5;
 
     --Act
     ut3.ut.expect(l_actual).not_to_include(l_expected).join_by('USER_ID');