NOTE: PROCEDURE PRINTTO used (Total process time):
      real time           0.01 seconds
      cpu time            0.01 seconds
      

1924  options mlogic SYMBOLGEN MPRINT;

1925  /* check 02: macro count outliers */
1926  %macro macro_outliers (var=);
1927  proc sql; create table upper_bound as select Variable_max from DC.input_analysis_res where
1927!  variable_name="&VAR" ;quit;
1928  proc sql; create table lower_bound as select Variable_min from DC.input_analysis_res where
1928!  variable_name="&VAR" ;quit;
1929  proc sql; create table base as select distinct "&VAR" from in.test ;quit;
1930  proc sql; create table base as select a.*, b.*, c.* from base a, upper_bound b,
1930! lower_bound c ;quit;
1931  proc sql; create table num_ourliers as select
1932  case when &VAR>Variable_max then 1 else 0 end as n_over,
1933  case when &VAR<Variable_min then 1 else 0 end as n_under
1934  from base ;quit;
1935  proc sql; create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as
1935! num_under from num_ourliers ;quit;
1936  proc sql; update DC.input_analysis_res set outliers_up = (select num_over FROM
1936! num_ourliers) where variable_name="&VAR" ;quit;
1937  proc sql; update DC.input_analysis_res set outliers_down = (select num_under FROM
1937! num_ourliers) where variable_name="&VAR" ;quit;
1938  %mend macro_outliers;

1939  /* call macros */
1940  data _null_;
1941    set DC.input_analysis_res;
1942  
1943    /* check 01: unexpected values
1944  if Variable_value_list not in ("") then
1945      call execute('%In_List
1945! (var='||strip(variable_name)||',vals='||strip(variable_value_list)||');');*/
1946  
1947      /* check 02: count outliers */
1948  if (Variable_min ne 0 and Variable_min ne 0) then
1949      call execute('%macro_outliers (var='||strip(variable_name)||');');
1950  
1951      /* check 03: number of missing and default values
1952  call execute ('%macro_missing
1952! (var='||strip(variable_name)||',def_val='||strip(Default_value)||');');*/
1953  run;

MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value ALTERNATIVEBEGIN
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to ALTERNATIVEBEGIN
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="ALTERNATIVEBEGIN" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to ALTERNATIVEBEGIN
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="ALTERNATIVEBEGIN" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to ALTERNATIVEBEGIN
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "ALTERNATIVEBEGIN" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to ALTERNATIVEBEGIN
SYMBOLGEN:  Macro variable VAR resolves to ALTERNATIVEBEGIN
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when 
ALTERNATIVEBEGIN>Variable_max then 1 else 0 end as n_over, case when 
ALTERNATIVEBEGIN<Variable_min then 1 else 0 end as n_under from base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to ALTERNATIVEBEGIN
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="ALTERNATIVEBEGIN" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to ALTERNATIVEBEGIN
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="ALTERNATIVEBEGIN" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value Segment
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="Segment" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="Segment" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "Segment" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when Segment>Variable_max 
then 1 else 0 end as n_over, case when Segment<Variable_min then 1 else 0 end as n_under from 
base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="Segment" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="Segment" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value Segment
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="Segment" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="Segment" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "Segment" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when Segment>Variable_max 
then 1 else 0 end as n_over, case when Segment<Variable_min then 1 else 0 end as n_under from 
base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="Segment" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to Segment
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="Segment" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="VPS_AUFENTHALTSLAND" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="VPS_AUFENTHALTSLAND" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "VPS_AUFENTHALTSLAND" from 
in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when 
VPS_AUFENTHALTSLAND>Variable_max then 1 else 0 end as n_over, case when 
VPS_AUFENTHALTSLAND<Variable_min then 1 else 0 end as n_under from base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="VPS_AUFENTHALTSLAND" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="VPS_AUFENTHALTSLAND" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="VPS_AUFENTHALTSLAND" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="VPS_AUFENTHALTSLAND" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "VPS_AUFENTHALTSLAND" from 
in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when 
VPS_AUFENTHALTSLAND>Variable_max then 1 else 0 end as n_over, case when 
VPS_AUFENTHALTSLAND<Variable_min then 1 else 0 end as n_under from base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="VPS_AUFENTHALTSLAND" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_AUFENTHALTSLAND
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="VPS_AUFENTHALTSLAND" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value VPS_CCNTRY
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_CCNTRY
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="VPS_CCNTRY" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_CCNTRY
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="VPS_CCNTRY" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_CCNTRY
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "VPS_CCNTRY" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_CCNTRY
SYMBOLGEN:  Macro variable VAR resolves to VPS_CCNTRY
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when VPS_CCNTRY>Variable_max 
then 1 else 0 end as n_over, case when VPS_CCNTRY<Variable_min then 1 else 0 end as n_under 
from base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_CCNTRY
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="VPS_CCNTRY" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to VPS_CCNTRY
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="VPS_CCNTRY" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value _begin
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _begin
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="_begin" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _begin
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="_begin" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _begin
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "_begin" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _begin
SYMBOLGEN:  Macro variable VAR resolves to _begin
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when _begin>Variable_max 
then 1 else 0 end as n_over, case when _begin<Variable_min then 1 else 0 end as n_under from 
base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _begin
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="_begin" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _begin
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="_begin" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value _end
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _end
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="_end" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _end
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="_end" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _end
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "_end" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _end
SYMBOLGEN:  Macro variable VAR resolves to _end
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when _end>Variable_max then 
1 else 0 end as n_over, case when _end<Variable_min then 1 else 0 end as n_under from base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _end
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="_end" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _end
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="_end" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value _report
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _report
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="_report" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _report
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="_report" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _report
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "_report" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _report
SYMBOLGEN:  Macro variable VAR resolves to _report
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when _report>Variable_max 
then 1 else 0 end as n_over, case when _report<Variable_min then 1 else 0 end as n_under from 
base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _report
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="_report" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to _report
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="_report" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value start
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to start
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="start" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to start
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="start" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to start
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "start" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to start
SYMBOLGEN:  Macro variable VAR resolves to start
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when start>Variable_max then 
1 else 0 end as n_over, case when start<Variable_min then 1 else 0 end as n_under from base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to start
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="start" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to start
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="start" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
NOTE: DATA statement used (Total process time):
      real time           0.01 seconds
      cpu time            0.01 seconds
      
MLOGIC(MACRO_OUTLIERS):  Beginning execution.
MLOGIC(MACRO_OUTLIERS):  Parameter VAR has value stop
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to stop
MPRINT(MACRO_OUTLIERS):   create table upper_bound as select Variable_max from 
DC.input_analysis_res where variable_name="stop" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to stop
MPRINT(MACRO_OUTLIERS):   create table lower_bound as select Variable_min from 
DC.input_analysis_res where variable_name="stop" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to stop
MPRINT(MACRO_OUTLIERS):   create table base as select distinct "stop" from in.test ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table base as select a.*, b.*, c.* from base a, upper_bound b, 
lower_bound c ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to stop
SYMBOLGEN:  Macro variable VAR resolves to stop
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select case when stop>Variable_max then 
1 else 0 end as n_over, case when stop<Variable_min then 1 else 0 end as n_under from base ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
MPRINT(MACRO_OUTLIERS):   create table num_ourliers as select sum(n_over) as num_over, 
sum(n_under) as num_under from num_ourliers ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to stop
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="stop" ;
MPRINT(MACRO_OUTLIERS):  quit;
MPRINT(MACRO_OUTLIERS):   proc sql;
SYMBOLGEN:  Macro variable VAR resolves to stop
MPRINT(MACRO_OUTLIERS):   update DC.input_analysis_res set outliers_down = (select num_under 
FROM num_ourliers) where variable_name="stop" ;
MPRINT(MACRO_OUTLIERS):  quit;
MLOGIC(MACRO_OUTLIERS):  Ending execution.
NOTE: There were 11 observations read from the data set DC.INPUT_ANALYSIS_RES.

NOTE: CALL EXECUTE generated line.
1    + proc sql;
1    +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="ALTERNATIVEBEGIN" ;
NOTE: Table WORK.UPPER_BOUND created, with 1 rows and 1 columns.

1    +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.01 seconds
      

1    +
proc sql;
1    +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="ALTERNATIVEBEGIN"
2    + ;
NOTE: Table WORK.LOWER_BOUND created, with 1 rows and 1 columns.

2    +  quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

2    +        proc sql;
2    +                  create table base as select distinct "ALTERNATIVEBEGIN" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

2    +                                                                                        
quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           4.78 seconds
      cpu time            0.92 seconds
      

2    +
proc sql;
2    +
 create table base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 1 rows and 3 columns.

2    +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.04 seconds
      

2    +
proc sql;
2    +
 create table num_ourliers as select case when
3    + ALTERNATIVEBEGIN>Variable_max then 1 else 0 end as n_over, case when 
ALTERNATIVEBEGIN<Variable_min then 1 else 0 end as n_under from base ;
ERROR: The following columns were not found in the contributing tables: ALTERNATIVEBEGIN.
3    +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


3    +
proc sql;
3    +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from
4    + num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
4    +               quit;
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.01 seconds
      


4    +                     proc sql;
4    +                               update DC.input_analysis_res set outliers_up = (select 
num_over FROM num_ourliers) where variable_name="ALTERNATIVEBEGIN" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

4    +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

4    +
proc sql;
4    +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers)
5    + where variable_name="ALTERNATIVEBEGIN" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

5    +                                         quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.01 seconds
      

5    +                                              ;
6    + proc sql;
6    +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="Segment" ;
NOTE: Table WORK.UPPER_BOUND created, with 2 rows and 1 columns.

6    +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

6    +
proc sql;
6    +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="Segment" ;
NOTE: Table WORK.LOWER_BOUND created, with 2 rows and 1 columns.

6    +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.01 seconds
      

6    +
proc sql;
7    + create table base as select distinct "Segment" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

7    +                                                              quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.67 seconds
      cpu time            0.60 seconds
      

7    +                                                                    proc sql;
7    +                                                                              create 
table base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 4 rows and 3 columns.

7    +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.03 seconds
      

7    +
proc sql;
7    +
 create table num_ourliers as select case when Segment>Variable_max then 1
8    + else 0 end as n_over, case when Segment<Variable_min then 1 else 0 end as n_under from 
base ;
ERROR: The following columns were not found in the contributing tables: Segment.
8    +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


8    +
proc sql;
8    +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from 
num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
8    +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


8    +
proc sql;
8    +
 update
9    + DC.input_analysis_res set outliers_up = (select num_over FROM num_ourliers) where 
variable_name="Segment" ;
NOTE: 2 rows were updated in DC.INPUT_ANALYSIS_RES.

9    +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

9    +
proc sql;
9    +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers) where 
variable_name="Segment" ;
NOTE: 2 rows were updated in DC.INPUT_ANALYSIS_RES.

9    +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

9    +
;     
10   + proc sql;
10   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="Segment" ;
NOTE: Table WORK.UPPER_BOUND created, with 2 rows and 1 columns.

10   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

10   +
proc sql;
10   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="Segment" ;
NOTE: Table WORK.LOWER_BOUND created, with 2 rows and 1 columns.

10   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

10   +
proc sql;
11   + create table base as select distinct "Segment" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

11   +                                                              quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.68 seconds
      cpu time            0.64 seconds
      

11   +                                                                    proc sql;
11   +                                                                              create 
table base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 4 rows and 3 columns.

11   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

11   +
proc sql;
11   +
 create table num_ourliers as select case when Segment>Variable_max then 1
12   + else 0 end as n_over, case when Segment<Variable_min then 1 else 0 end as n_under from 
base ;
ERROR: The following columns were not found in the contributing tables: Segment.
12   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.00 seconds
      


12   +
proc sql;
12   +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from 
num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
12   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.00 seconds
      


12   +
proc sql;
12   +
 update
13   + DC.input_analysis_res set outliers_up = (select num_over FROM num_ourliers) where 
variable_name="Segment" ;
NOTE: 2 rows were updated in DC.INPUT_ANALYSIS_RES.

13   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

13   +
proc sql;
13   +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers) where 
variable_name="Segment" ;
NOTE: 2 rows were updated in DC.INPUT_ANALYSIS_RES.

13   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

13   +
;     
14   + proc sql;
14   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="VPS_AUFENTHALTSLAND" ;
NOTE: Table WORK.UPPER_BOUND created, with 2 rows and 1 columns.

14   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

14   +
proc sql;
14   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where
15   + variable_name="VPS_AUFENTHALTSLAND" ;
NOTE: Table WORK.LOWER_BOUND created, with 2 rows and 1 columns.

15   +                                      quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

15   +                                            proc sql;
15   +                                                      create table base as select 
distinct "VPS_AUFENTHALTSLAND" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

15   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.68 seconds
      cpu time            0.68 seconds
      

15   +
proc sql;
15   +
 create table base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 4 rows and 3 columns.

15   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

15   +
proc sql;
15   +
 create
16   + table num_ourliers as select case when VPS_AUFENTHALTSLAND>Variable_max then 1 else 0 
end as n_over, case when VPS_AUFENTHALTSLAND<Variable_min then 1 else 0 end as n_under from 
base ;
ERROR: The following columns were not found in the contributing tables: VPS_AUFENTHALTSLAND.
16   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.00 seconds
      


16   +
proc sql;
16   +
 create table num_ourliers as select sum(n_over) as
17   + num_over, sum(n_under) as num_under from num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
17   +                                                        quit;
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


17   +                                                              proc sql;
17   +                                                                        update 
DC.input_analysis_res set outliers_up = (select num_over FROM num_ourliers) where 
variable_name="VPS_AUFENTHALTSLAND" ;
NOTE: 2 rows were updated in DC.INPUT_ANALYSIS_RES.

17   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

17   +
proc sql;
17   +
 update DC.input_analysis_res set
18   + outliers_down = (select num_under FROM num_ourliers) where 
variable_name="VPS_AUFENTHALTSLAND" ;
NOTE: 2 rows were updated in DC.INPUT_ANALYSIS_RES.

18   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

18   +
;     
19   + proc sql;
19   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="VPS_AUFENTHALTSLAND" ;
NOTE: Table WORK.UPPER_BOUND created, with 2 rows and 1 columns.

19   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.04 seconds
      

19   +
proc sql;
19   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where
20   + variable_name="VPS_AUFENTHALTSLAND" ;
NOTE: Table WORK.LOWER_BOUND created, with 2 rows and 1 columns.

20   +                                      quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

20   +                                            proc sql;
20   +                                                      create table base as select 
distinct "VPS_AUFENTHALTSLAND" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

20   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.68 seconds
      cpu time            0.65 seconds
      

20   +
proc sql;
20   +
 create table base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 4 rows and 3 columns.

20   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

20   +
proc sql;
20   +
 create
21   + table num_ourliers as select case when VPS_AUFENTHALTSLAND>Variable_max then 1 else 0 
end as n_over, case when VPS_AUFENTHALTSLAND<Variable_min then 1 else 0 end as n_under from 
base ;
ERROR: The following columns were not found in the contributing tables: VPS_AUFENTHALTSLAND.
21   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.01 seconds
      


21   +
proc sql;
21   +
 create table num_ourliers as select sum(n_over) as
22   + num_over, sum(n_under) as num_under from num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
22   +                                                        quit;
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.00 seconds
      


22   +                                                              proc sql;
22   +                                                                        update 
DC.input_analysis_res set outliers_up = (select num_over FROM num_ourliers) where 
variable_name="VPS_AUFENTHALTSLAND" ;
NOTE: 2 rows were updated in DC.INPUT_ANALYSIS_RES.

22   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

22   +
proc sql;
22   +
 update DC.input_analysis_res set
23   + outliers_down = (select num_under FROM num_ourliers) where 
variable_name="VPS_AUFENTHALTSLAND" ;
NOTE: 2 rows were updated in DC.INPUT_ANALYSIS_RES.

23   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.01 seconds
      

23   +
;     
24   + proc sql;
24   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="VPS_CCNTRY" ;
NOTE: Table WORK.UPPER_BOUND created, with 1 rows and 1 columns.

24   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.06 seconds
      

24   +
proc sql;
24   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="VPS_CCNTRY" ;
NOTE: Table WORK.LOWER_BOUND created, with 1 rows and 1 columns.

24   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

24   +
 proc 
25   + sql;
25   +      create table base as select distinct "VPS_CCNTRY" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

25   +                                                                      quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.67 seconds
      cpu time            0.64 seconds
      

25   +                                                                            proc sql;
25   +                                                                                      
create table base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 1 rows and 3 columns.

25   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

25   +
proc sql;
25   +
 create table num_ourliers as select case when
26   + VPS_CCNTRY>Variable_max then 1 else 0 end as n_over, case when VPS_CCNTRY<Variable_min 
then 1 else 0 end as n_under from base ;
ERROR: The following columns were not found in the contributing tables: VPS_CCNTRY.
26   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


26   +
proc sql;
26   +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from 
num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
26   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


27   + proc sql;
27   +           update DC.input_analysis_res set outliers_up = (select num_over FROM 
num_ourliers) where variable_name="VPS_CCNTRY" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

27   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

27   +
proc sql;
27   +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers) where
28   + variable_name="VPS_CCNTRY" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

28   +                             quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.03 seconds
      

28   +                                  ;
29   + proc sql;
29   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="_begin" ;
NOTE: Table WORK.UPPER_BOUND created, with 1 rows and 1 columns.

29   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.01 seconds
      

29   +
proc sql;
29   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="_begin" ;
NOTE: Table WORK.LOWER_BOUND created, with 1 rows and 1 columns.

29   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

29   +
proc sql;
30   + create table base as select distinct "_begin" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

30   +                                                             quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.67 seconds
      cpu time            0.57 seconds
      

30   +                                                                   proc sql;
30   +                                                                             create table 
base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 1 rows and 3 columns.

30   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.03 seconds
      

30   +
proc sql;
30   +
 create table num_ourliers as select case when _begin>Variable_max then 1 else
31   + 0 end as n_over, case when _begin<Variable_min then 1 else 0 end as n_under from base ;
ERROR: The following columns were not found in the contributing tables: _begin.
31   +                                                                                        
quit;
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


31   +
proc sql;
31   +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from 
num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
31   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


31   +
proc sql;
31   +
 update DC.input_analysis_res
32   + set outliers_up = (select num_over FROM num_ourliers) where variable_name="_begin" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

32   +                                                                                     quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

32   +
proc sql;
32   +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers) where 
variable_name="_begin" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

32   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

32   +
;     
33   + proc sql;
33   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="_end" ;
NOTE: Table WORK.UPPER_BOUND created, with 1 rows and 1 columns.

33   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

33   +
proc sql;
33   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="_end" ;
NOTE: Table WORK.LOWER_BOUND created, with 1 rows and 1 columns.

33   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.03 seconds
      

33   +
proc sql;
33   +
 create
34   + table base as select distinct "_end" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

34   +                                                    quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.65 seconds
      cpu time            0.59 seconds
      

34   +                                                          proc sql;
34   +                                                                    create table base as 
select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 1 rows and 3 columns.

34   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

34   +
proc sql;
34   +
 create table num_ourliers as select case when _end>Variable_max then 1 else 0 end as
35   + n_over, case when _end<Variable_min then 1 else 0 end as n_under from base ;
ERROR: The following columns were not found in the contributing tables: _end.
35   +                                                                             quit;
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.01 seconds
      


35   +                                                                                   proc 
sql;
35   +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from 
num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
35   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.00 seconds
      


35   +
proc sql;
35   +
 update DC.input_analysis_res set
36   + outliers_up = (select num_over FROM num_ourliers) where variable_name="_end" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

36   +                                                                               quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

36   +                                                                                     proc 
sql;
36   +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers) where 
variable_name="_end" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

36   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

36   +
;     
37   + proc sql;
37   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="_report" ;
NOTE: Table WORK.UPPER_BOUND created, with 1 rows and 1 columns.

37   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

37   +
proc sql;
37   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="_report" ;
NOTE: Table WORK.LOWER_BOUND created, with 1 rows and 1 columns.

37   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.03 seconds
      

37   +
proc sql;
38   + create table base as select distinct "_report" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

38   +                                                              quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.68 seconds
      cpu time            0.62 seconds
      

38   +                                                                    proc sql;
38   +                                                                              create 
table base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 1 rows and 3 columns.

38   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.04 seconds
      

38   +
proc sql;
38   +
 create table num_ourliers as select case when _report>Variable_max then 1
39   + else 0 end as n_over, case when _report<Variable_min then 1 else 0 end as n_under from 
base ;
ERROR: The following columns were not found in the contributing tables: _report.
39   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.00 seconds
      


39   +
proc sql;
39   +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from 
num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
39   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


39   +
proc sql;
39   +
 update
40   + DC.input_analysis_res set outliers_up = (select num_over FROM num_ourliers) where 
variable_name="_report" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

40   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

40   +
proc sql;
40   +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers) where 
variable_name="_report" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

40   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.03 seconds
      

40   +
;     
41   + proc sql;
41   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="start" ;
NOTE: Table WORK.UPPER_BOUND created, with 1 rows and 1 columns.

41   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.01 seconds
      

41   +
proc sql;
41   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="start" ;
NOTE: Table WORK.LOWER_BOUND created, with 1 rows and 1 columns.

41   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.01 seconds
      

41   +
proc sql;
42   + create table base as select distinct "start" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

42   +                                                            quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.67 seconds
      cpu time            0.64 seconds
      

42   +                                                                  proc sql;
42   +                                                                            create table 
base as select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 1 rows and 3 columns.

42   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.03 seconds
      

42   +
proc sql;
42   +
 create table num_ourliers as select case when start>Variable_max then 1 else 0
43   + end as n_over, case when start<Variable_min then 1 else 0 end as n_under from base ;
ERROR: The following columns were not found in the contributing tables: start.
43   +                                                                                     quit;
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.00 seconds
      cpu time            0.00 seconds
      


43   +
proc sql;
43   +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from 
num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
43   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.01 seconds
      


43   +
proc sql;
43   +
 update DC.input_analysis_res set
44   + outliers_up = (select num_over FROM num_ourliers) where variable_name="start" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

44   +                                                                                quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.01 seconds
      

44   +                                                                                      
proc sql;
44   +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers) where 
variable_name="start" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

44   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

44   +
;     
45   + proc sql;
45   +           create table upper_bound as select Variable_max from DC.input_analysis_res 
where variable_name="stop" ;
NOTE: Table WORK.UPPER_BOUND created, with 1 rows and 1 columns.

45   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

45   +
proc sql;
45   +
 create table lower_bound as select Variable_min from DC.input_analysis_res where 
variable_name="stop" ;
NOTE: Table WORK.LOWER_BOUND created, with 1 rows and 1 columns.

45   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

45   +
proc sql;
45   +
 create
46   + table base as select distinct "stop" from in.test ;
NOTE: Table WORK.BASE created, with 1 rows and 1 columns.

46   +                                                    quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.67 seconds
      cpu time            0.54 seconds
      

46   +                                                          proc sql;
46   +                                                                    create table base as 
select a.*, b.*, c.* from base a, upper_bound b, lower_bound c ;
NOTE: The execution of this query involves performing one or more Cartesian product joins that 
      can not be optimized.
WARNING: This CREATE TABLE statement recursively references the target table. A consequence of 
         this is a possible data integrity problem.
NOTE: Table WORK.BASE created, with 1 rows and 3 columns.

46   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.07 seconds
      cpu time            0.00 seconds
      

46   +
proc sql;
46   +
 create table num_ourliers as select case when stop>Variable_max then 1 else 0 end as
47   + n_over, case when stop<Variable_min then 1 else 0 end as n_under from base ;
ERROR: The following columns were not found in the contributing tables: stop.
47   +                                                                             quit;
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.00 seconds
      


47   +                                                                                   proc 
sql;
47   +
 create table num_ourliers as select sum(n_over) as num_over, sum(n_under) as num_under from 
num_ourliers ;
ERROR: The SUM summary function requires a numeric argument.
ERROR: The SUM summary function requires a numeric argument.
ERROR: The following columns were not found in the contributing tables: n_over, n_under.
47   +
quit; 
NOTE: The SAS System stopped processing this step because of errors.
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.01 seconds
      cpu time            0.00 seconds
      


47   +
proc sql;
47   +
 update DC.input_analysis_res set
48   + outliers_up = (select num_over FROM num_ourliers) where variable_name="stop" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

48   +                                                                               quit;
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

48   +                                                                                     proc 
sql;
48   +
 update DC.input_analysis_res set outliers_down = (select num_under FROM num_ourliers) where 
variable_name="stop" ;
NOTE: 1 row was updated in DC.INPUT_ANALYSIS_RES.

48   +
quit; 
NOTE: PROCEDURE SQL used (Total process time):
      real time           0.06 seconds
      cpu time            0.00 seconds
      

48   +
;     
1954  
1955  proc printto;
1956  run;