Concatenate three variables into a single variable and avoid duplicates

I have three variables. My intention is to concatenate three variables into one new variable and avoid duplicate values.

UPDATE:
Values of the variables are not always the same. For the last example i want to keep both values separated by a semicolon.

Initial data:

Var_1      | Var_2      | Var_3      |
-------------------------------------|
Bucket_001 |            | Bucket_001 |
Bucket_002 | Bucket_002 |            |
Bucket_003 | Bucket_003 | Bucket_003 |
           | Bucket_004 |            |
           | Bucket_005 | Bucket_005 |
           |            | Bucket_006 |
           | Bucket_007 | Bucket_008 |

Result:

Var
----------
Bucket_001
Bucket_002
Bucket_003
Bucket_004
Bucket_005
Bucket_006
Bucket_007;Bucket_008

Any help much appreciated!

With your additional requirement for "Values of the variables are not always the same." the code presented by Stu Sztukowski requires only a bit of polishing with use of the curobs= option and ther Proc Transpose.

Input data:

data have;
infile cards dlm='|' missover;
input (Var_1 Var_2 Var_3 ) (:$20.);
cards;
Bucket_001 |            | Bucket_001 |
Bucket_002 | Bucket_002 |            |
Bucket_003 | Bucket_003 | Bucket_003 |
           | Bucket_004 |            |
           | Bucket_005 | Bucket_005 |
           |            | Bucket_006 |
           | Bucket_007 | Bucket_008 |
;

proc print data=have;
run;

Code based on Stu's idea:

data want;
  set 
    have(keep=var_1 rename=(var_1 = var) )
    have(keep=var_2 rename=(var_2 = var) )
    have(keep=var_3 rename=(var_3 = var) )
  curobs=co
  ;
  where NOT missing(var);
  curobs=co;
run;

proc sort data=want nodupkey;
  by curobs var;
run;

proc transpose data=want out=want(drop=_name_ curobs);
  by curobs;
  var var;
run;

data want;
  set want;
  var = catx(';',of col:);
  keep var;
run;

proc print data=want;
run;

[EDIT:]

My version for "lazy programmers":

data want;
  set have
  curobs=co
  ;
  curobs=co;
run;

proc transpose data=want out=want(drop=_name_);
  by curobs;
  var var:;
run;

proc sort data=want(where=(col1 is not null)) nodupkey;
  by curobs col1;
run;

proc transpose data=want out=want(drop=_name_ curobs);
  by curobs;
  var col1;
run;

data want;
  set want;
  var = catx(';',of col:);
  keep var;
run;

proc print data=want;
run;

The output in both cases is the same :

Stack your initial data on top of itself three times, keeping only one variable in each set of the data. The first will keep var_1, second var_2, and third var_3. Rename each variable to be var so that they stack into a single variable. Remove missing values with a where statement, then remove duplicates with proc sort.

data want;
    set have(keep=var_1 rename=(var_1 = var) )
        have(keep=var_2 rename=(var_2 = var) )
        have(keep=var_3 rename=(var_3 = var) )
    ;
    where NOT missing(var);
run;

We get this:

var
Bucket_001
Bucket_002
Bucket_003
Bucket_002
Bucket_003
Bucket_004
Bucket_005
Bucket_001
Bucket_003
Bucket_005
Bucket_006

Now we'll remove all the duplicates, and we're done.

proc sort data=want nodupkey;
    by var;
run;

var
Bucket_001
Bucket_002
Bucket_003
Bucket_004
Bucket_005
Bucket_006

If you want to get really advanced, you can do this all in a single step with a hash table. Hash tables automatically sort and remove duplicate keys when you read data into them.

data _null_;
    length var $10.;

    set have end=eof;
    array v[*] var_:;

    if(_N_ = 1) then do;
        dcl hash h();
            h.defineKey('var');
        h.defineDone();
        call missing(var);
    end;

    /* Note: when specifying a key in the Add() method with a key-only 
       hash table, the data argument is required even though it does nothing */
    do i = 1 to dim(v);
        if(NOT missing(v[i]) ) then rc = h.Add(key: v[i], data: v[i]);
    end;

    if(eof) then h.Output(dataset: 'want');
run;

In your particular example, the coalescec() function would also work. Not sure it would work in your actual data, in that case use Stu's answer.

data want;
set have;
var = coalescec(var1, var2, var3);
keep var;
run;

A SQL option as I haven't seen one of those posted.

proc sql;
    create table want as select * from
    (select distinct var_1 as var from temperatures 
     union 
     select distinct var_2 as var from temperatures 
     union 
     select distinct var_3 as var from temperatures
     ) as a 
     where not missing(var);
quit;

There is another method: Using a temporary array.
The temporary array is used to store unique value: If a value never showed before, add it to the array, so this array owns every unique value at the end of file. After that, you just output the values of this array, that is what you want.

data temperatures;
  infile cards dlm='|';
  informat Var_1 Var_2 Var_3 $42.;
  input Var_1 Var_2 Var_3 $;
  datalines;
Bucket_001 |            | Bucket_001 |
Bucket_002 | Bucket_002 |            |
Bucket_003 | Bucket_004 | Bucket_005 |
           | Bucket_006 |            |
           | Bucket_007 | Bucket_008 |
           |            | Bucket_006 |
;
run;

data want;
  set temperatures end=eof;
  array _var_ Var_1 Var_2 Var_3;
  array _par_[%eval(&sysnobs.*3)]$42. _temporary_;
  do i=1 to dim(_var_);
    if _var_[i] not in _par_ then _par_[_n_*3+i-3]=_var_[i];
  end;

  if eof then do i=1 to dim(_par_);
    if not missing(_par_[i]) then do;
      var=_par_[i];
      output;
    end;
  end;
run;

The result is:

var
Bucket_001
Bucket_002
Bucket_003
Bucket_004
Bucket_005
Bucket_006
Bucket_007
Bucket_008