Sas conditional set statement

When you do not specify an argument, the SET statement reads an observation from the most recently created data set.

specifies a one-level name, a two-level name, or one of the special SAS data set names.

specifies actions SAS is to take when it reads variables or observations into the program data vector for processing.

creates and names a temporary variable that contains an end-of-file indicator. The variable, which is initialized to zero, is set to 1 when SET reads the last observation of the last data set listed. This variable is not added to any new data set.

provides nonsequential access to observations in a SAS data set, which are based on the value of an index variable or a key.

If you use the KEY= option without specifying the primary data set, you must include either a STOP statement to stop DATA step processing, or programming logic that uses the _IORC_ automatic variable in conjunction with the SYSRC autocall macro and checks for an invalid value of the _IORC_ variable, or both.

creates and names a variable that stores the name of the SAS data set from which the current observation is read. The stored name can be a data set name or a physical name. The physical name is the name by which the operating environment recognizes the file.

If the variable is previously defined as a character variable with a specific length, that length is not changed. If the value placed into the INDSNAME variable is longer than that length, then the value is truncated.

If the variable is previously defined as a numeric variable, an error will occur.

Featured in: Retrieving the Name of the Data Set from Which the Current Observation Is Read

creates and names a temporary variable whose value is usually the total number of observations in the input data set or data sets. If more than one data set is listed in the SET statement, NOBS= the total number of observations in the data sets that are listed. The number of observations includes those observations that are marked for deletion but are not yet deleted.

allows you to delay the opening of any concatenated SAS data sets until they are ready to be processed.

during the compilation phase, opens all data sets that are listed in the SET statement.

opens the first data set during the compilation phase, and opens subsequent data sets during the execution phase. When the DATA step reads and processes all observations in a data set, it closes the data set and opens the next data set in the list.

1. If a variable on a subsequent data set is of a different type (character versus numeric, for example) than the type of the same-named variable on the first data set, the DATA step will stop processing and produce an error message.
2. If a variable on a subsequent data set was not defined by the first data set in the SET statement, but was defined previously in the DATA step program, the DATA step will stop processing and produce an error message. In this case, the value of the variable in previous iterations might be incorrect because the semantic behavior of SET requires this variable to be set to missing when processing the first observation of the first data set.

specifies a temporary variable whose numeric value determines which observation is read. POINT= causes the SET statement to use random (direct) access to read a SAS data set.

When you use the POINT= option, you must include a STOP statement to stop DATA step processing, programming logic that checks for an invalid value of the POINT= variable, or both. Because POINT= reads only those observations that are specified in the DO statement, SAS cannot read an end-of-file indicator as it would if the file were being read sequentially. Because reading an end-of-file indicator ends a DATA step automatically, failure to substitute another means of ending the DATA step when you use POINT= can cause the DATA step to go into a continuous loop. If SAS reads an invalid value of the POINT= variable, it sets the automatic variable _ERROR_ to 1. Use this information to check for conditions that cause continuous DO-loop processing, or include a STOP statement at the end of the DATA step, or both.

causes a KEY= search always to begin at the top of the index for the data set that is being read.

If the KEY= value does not change on successive executions of the SET statement, the search begins by following the most recently retrieved observation. In other words, when consecutive duplicate KEY= values appear, the SET statement attempts a one-to-one match with duplicate indexed values in the data set that is being read. If more consecutive duplicate KEY= values are specified than exist in the data set that is being read, the extra duplicates are treated as not found.

When KEY= is a unique value, only the first attempt to read an observation with that key value succeeds; subsequent attempts to read the observation with that value of the key will fail. The _IORC_ variable returns a value that corresponds to the SYSRC autocall macro's mnemonic _DSENOM. If you add the /UNIQUE option, subsequent attempts to read the observation with the unique KEY= value will succeed. The _IORC_ variable returns a 0.

Featured in: Performing a Table Lookup When the Master File Contains Duplicate Observations See Also: For extensive examples, see Combining and Modifying SAS Data Sets: Examples .

Each time the SET statement is executed, SAS reads one observation into the program data vector. SET reads all variables and all observations from the input data sets unless you tell SAS to do otherwise. A SET statement can contain multiple data sets; a DATA step can contain multiple SET statements. See Combining and Modifying SAS Data Sets: Examples .

The SET statement is flexible and has a variety of uses in SAS programming. These uses are determined by the options and statements that you use with the SET statement:

• reading observations and variables from existing SAS data sets for further processing in the DATA step
• concatenating and interleaving data sets, and performing one-to-one reading of data sets
• reading SAS data sets by using direct access methods.

You can use data set lists with the SET statement. Data set lists provide a quick way to reference existing groups of data sets. These data set lists must be either name prefix lists or numbered range lists.

Name prefix lists refer to all data sets that begin with a specified character string. For example, set SALES1:; tells SAS to read all data sets starting with "SALES1" such as SALES1, SALES10, SALES11, and SALES12.

Numbered range lists require you to have a series of data sets with the same name, except for the last character or characters, which are consecutive numbers. In a numbered range list, you can begin with any number and end with any number. For example, these lists refer to the same data sets:

sales1 sales2 sales3 sales4 sales1-sales4

Note: If the numeric suffix of the first data set name contains leading zeros, the number of digits in the numeric suffix of the last data set name must be greater than or equal to the number of digits in the first data set name. Otherwise, an error will occur. For example, the data set lists sales001-sales99 and sales01-sales9 will cause an error. The data set list sales001-sales999 is valid. If the numeric suffix of the first data set name does not contain leading zeros, the number of digits in the numeric suffix of the first and last data set names do not have to be equal. For example, the data set list sales1-sales999 is valid.

Some other rules to consider when using numbered data set lists are as follows:

You can specify groups of ranges.

set cost1-cost4 cost11-cost14 cost21-cost24;

set cost1-cost4 cost2: cost33-37;

set cost1 cost10-cost20 cost30;

/* these two lines are the same */ set sales1 - sales4; set 'sales1'n - 'sales4'n;

/* blanks in these statements will cause errors */ set sales 1 - sales 4; set 'sales 1'n - 'sales 4'n; /* trailing blanks in this statement will be ignored */ set 'sales1 'n - 'sales4 'n;

/* this suffix will cause an error */ set prod2000000000-prod2934850239;

/* physical pathnames will cause an error */ &let work_path = %sysfunc(pathname(WORK)); set "&work_path\dept.sas7bdat";

Only one BY statement can accompany each SET statement in a DATA step. The BY statement should immediately follow the SET statement to which it applies. The data sets that are listed in the SET statement must be sorted by the values of the variables that are listed in the BY statement, or they must have an appropriate index. SET, when it is used with a BY statement, interleaves data sets. The observations in the new data set are arranged by the values of the BY variable or variables, and within each BY group, by the order of the data sets in which they occur. See Interleaving SAS Data Sets for an example of BY-group processing with the SET statement.

Use a single SET statement with multiple data sets to concatenate the specified data sets. That is, the number of observations in the new data set is the sum of the number of observations in the original data sets, and the order of the observations is all the observations from the first data set followed by all the observations from the second data set, and so on. See Concatenating SAS Data Sets for an example of concatenating data sets.

Use a single SET statement with a BY statement to interleave the specified data sets. The observations in the new data set are arranged by the values of the BY variable or variables, and within each BY group, by the order of the data sets in which they occur. See Interleaving SAS Data Sets for an example of interleaving data sets.

Use multiple SET statements to perform one-to-one reading (also called one-to-one matching) of the specified data sets. The new data set contains all the variables from all the input data sets. The number of observations in the new data set is the number of observations in the smallest original data set. If the data sets contain common variables, the values that are read in from the last data set replace the values that were read in from earlier ones. See Combining One Observation with Many, Performing a Table Lookup, and Performing a Table Lookup When the Master File Contains Duplicate Observations for examples of one-to-one reading of data sets.

For extensive examples, see Combining and Modifying SAS Data Sets: Examples .

For more information about how to prepare your data sets, see Combining SAS Data Sets: Basic Concepts in SAS Language Reference: Concepts .

• SET reads an observation from an existing SAS data set. INPUT reads raw data from an external file or from in-stream data lines in order to create SAS variables and observations.
• Using the KEY= option with SET enables you to access observations nonsequentially in a SAS data set according to a value. Using the POINT= option with SET enables you to access observations nonsequentially in a SAS data set according to the observation number.

If more than one data set name appears in the SET statement, the resulting output data set is a concatenation of all the data sets that are listed. SAS reads all observations from the first data set, then all from the second data set, and so on, until all observations from all the data sets have been read. This example concatenates the three SAS data sets into one output data set named FITNESS:

data fitness; set health exercise well; run;

To interleave two or more SAS data sets, use a BY statement after the SET statement:

data april; set payable recvable; by account; run;

In this DATA step, each observation in the data set NC.MEMBERS is read into the program data vector. Only those observations whose value of CITY is Raleigh are output to the new data set RALEIGH.MEMBERS:

data raleigh.members; set nc.members; if city='Raleigh'; run;

An observation to be merged into an existing data set can be one that is created by a SAS procedure or another DATA step. In this example, the data set AVGSALES has only one observation:

data national; if _n_=1 then set avgsales; set totsales; run;

In this example, SAS treats each SET statement independently. That is, it reads from one data set as if it were reading from two separate data sets:

data drugxyz; set trial5(keep=sample); if sample>2; set trial5; run;

For each iteration of the DATA step, the first SET statement reads one observation. The next time the first SET statement is executed, it reads the next observation. Each SET statement can read different observations with the same iteration of the DATA step.

You can subset observations from one data set and combine them with observations from another data set by using direct access methods, as follows:

data south; set revenue; if region=4; set expense point=_n_; run;

This example illustrates using the KEY= option to perform a table lookup. The DATA step reads a primary data set that is named INVTORY and a lookup data set that is named PARTCODE. It uses the index PARTNO to read PARTCODE nonsequentially, by looking for a match between the PARTNO value in each data set. The purpose is to obtain the appropriate description, which is available only in the variable DESC in the lookup data set, for each part that is listed in the primary data set:

data combine; set invtory(keep=partno instock price); set partcode(keep=partno desc) key=partno; run;

This example uses the KEY= option to perform a table lookup. The DATA step reads a primary data set that is named INVTORY, which is indexed on PARTNO, and a lookup data set named PARTCODE. PARTCODE contains quantities of new stock (variable NEW_STK). The UNIQUE option ensures that, if there are any duplicate observations in INVTORY, values of NEW_STK are added only to the first observation of the group:

data combine; set partcode(keep=partno new_stk); set invtory(keep=partno instock price) key=partno/unique; instock=instock+new_stk; run;

These statements select a subset of 50 observations from the data set DRUGTEST by using the POINT= option to access observations directly by number:

data sample; do obsnum=1 to 100 by 2; set drugtest point=obsnum; if _error_ then abort; output; end; stop; run;

These statements use NOBS= to set the termination value for DO-loop processing. The value of the temporary variable LAST is the sum of the observations in SURVEY1 and SURVEY2:

do obsnum=1 to last by 100; set survey1 survey2 point=obsnum nobs=last; output; end; stop;

This example uses the END= variable LAST to tell SAS to assign a value to the variable REVENUE and write an observation only after the last observation of RENTAL has been read:

set rental end=last; totdays + days; if last then do; revenue=totdays*65.78; output; end;

This example creates three data sets and stores the data set name in a variable named dsn . The name is split into three parts and the example prints out the results.

/* Create some data sets to read */ data gas_price_option; value=395; run; data gas_rbid_option; value=840; run; data gas_price_forward; value=275; run; /* Create a data set D */ data d; set gas_price_option gas_rbid_option gas_price_forward indsname=dsn; /* split the data set names into 3 parts */ commodity = scan (dsn, 2, "._"); type = scan (dsn, 3, "._"); instrument = scan (dsn, 4, "._"); run; proc print data=d; run;

The SAS System 1 Obs value commodity type instrument 1 395 GAS PRICE OPTION 2 840 GAS RBID OPTION 3 275 GAS PRICE FORWARD

This example uses a numbered range list to input the data sets.

data dept008; emp=13; run; data dept009; emp=9; run; data dept010; emp=4; run; data dept011; emp=33; run; data _null_; set dept008-dept010; put _all_; run;

The following lines are written to the SAS log.

1 data dept008; emp=13; run; NOTE: The data set WORK.DEPT008 has 1 observations and 1 variables. NOTE: DATA statement used (Total process time): real time 0.06 seconds cpu time 0.03 seconds 2 data dept009; emp=9; run; NOTE: The data set WORK.DEPT009 has 1 observations and 1 variables. NOTE: DATA statement used (Total process time): real time 0.00 seconds cpu time 0.00 seconds 3 data dept010; emp=4; run; NOTE: The data set WORK.DEPT010 has 1 observations and 1 variables. NOTE: DATA statement used (Total process time): real time 0.00 seconds cpu time 0.00 seconds 4 data dept011; emp=33; run; NOTE: The data set WORK.DEPT011 has 1 observations and 1 variables. NOTE: DATA statement used (Total process time): real time 0.00 seconds cpu time 0.00 seconds 5 6 data _null_; 7 set dept008-dept010; 8 put _all_; 9 run; emp=13 _ERROR_=0 _N_=1 emp=9 _ERROR_=0 _N_=2 emp=4 _ERROR_=0 _N_=3 NOTE: There were 1 observations read from the data set WORK.DEPT008. NOTE: There were 1 observations read from the data set WORK.DEPT009. NOTE: There were 1 observations read from the data set WORK.DEPT010. NOTE: DATA statement used (Total process time): real time 0.00 seconds cpu time 0.00 seconds

In addition, you could use data set lists to find missing data sets. This example uses a numbered range list to locate the missing data sets. An error occurs for each data set that does not exist. Once you know which data sets are missing, you can correct the SET statement to reflect the data sets that actually exist.

data dept008; emp=13; run; data dept009; emp=9; run; data dept011; emp=4; run; data dept014; emp=33; run; data _null_; set dept008-dept014; put _all_; run;

The following lines are written to the SAS log.

1 data dept008; emp=13; run; NOTE: The data set WORK.DEPT008 has 1 observations and 1 variables. NOTE: DATA statement used (Total process time): real time 0.04 seconds cpu time 0.04 seconds 2 data dept009; emp=9; run; NOTE: The data set WORK.DEPT009 has 1 observations and 1 variables. NOTE: DATA statement used (Total process time): real time 0.00 seconds cpu time 0.00 seconds 3 data dept011; emp=4; run; NOTE: The data set WORK.DEPT011 has 1 observations and 1 variables. NOTE: DATA statement used (Total process time): real time 0.03 seconds cpu time 0.01 seconds 4 data dept014; emp=33; run; NOTE: The data set WORK.DEPT014 has 1 observations and 1 variables. NOTE: DATA statement used (Total process time): real time 0.00 seconds cpu time 0.00 seconds 5 data _null_; 6 set dept008-dept014; ERROR: File WORK.DEPT010.DATA does not exist. ERROR: File WORK.DEPT012.DATA does not exist. ERROR: File WORK.DEPT013.DATA does not exist. 7 put _all_; 8 run; NOTE: The SAS System stopped processing this step because of errors. NOTE: DATA statement used (Total process time): real time 0.00 seconds cpu time 0.00 seconds