Information for one observation can be spread out over several records. You can write multiple INPUT statements to read each record that comprises a single observation …

…or,youcan write one INPUT statement that contains a line pointer control to specify the record(s) from which values are to be read.

In this chapter, you learn to

You use the forward slash (/) line pointer control to read multiple records sequentially. The / advances the input pointer to the next record. The / line pointer control only moves the input pointer forward and must be specified after the instructions for reading the values in the current record.

The single INPUT statement below reads the values for Lname and Fname in the first record, followed by the values for Department and JobCode in the second record. Then the value for Salary is read in the third record.

Take a closer look at using the forward slash (/) line pointer control in the following example.

The raw data file Memdata contains the mailing list of a professional organization. Your task is to combine the information for each member into one data set observation. We'll begin by reading each member's name, followed by the street address, and finally the city, state, and zip code.

Now that you've learned the basics of using the / line pointer control, let's take a closer look at the sequential processing of multiple records in the DATA step.

The values in the first record are read, and the / line pointer control moves the input pointer to the second record.

The values for Address are read, and the second / line pointer control advances the input pointer to the third record.

The values for City, State, and Zip are read, and the INPUT statement is completely executed.

The values in the program data vector are written to the data set as the first observation.

Control returns to the top of the DATA step, and the variable values are reinitialized to missing.

During the second iteration, values for Fname and Lname are read beginning in column 1 of the fourth record.

The values for Address are read and the / line pointer control advances the input pointer to the fifth record.

The values for City, State, and Zip are read, and the INPUT statement is completely executed.

The values in the program data vector are written to the data set as the second observation.

After the data set is complete, PROC PRINT output for Perm.Members shows that a single observation contains the complete information for each member.

proc print data=perm.members;
run;

Note that the raw data file must contain the same number of records for each observation that is being created.

For example, suppose that there are only two records for the second member. However, the INPUT statement is set up to read three records.

The second member's name and address are read and assigned to corresponding variables. Then the input pointer advances to the next record, as directed by the INPUT statement, and the third member's name is read as a value for City.

The DATA step is still looking for a value for State and Zip, so the input pointer advances to the next record and reads the values for the member's address.

The PROC PRINT output for this data set illustrates the problem.

So, before you write the INPUT statement, make sure the raw data file contains the same number of records for each observation. In this raw data file there are now three records for each observation.

You already know how to read multiple records sequentially by using the / line pointer control. Now let's look at reading multiple records non-sequentially by using the #n line pointer control.

The #n specifies the absolute number of the line to which you want to move the input pointer. The #n pointer control can read records in any order; therefore, it must be specified before the instructions for reading values in a specific record.

The INPUT statement below first reads the values for Department and JobCode in the second record, then the values for Lname and Fname in the first record. Finally, it reads the value for Salary in the third record.

Take a closer look at using the #n line pointer control in the following example.

The raw data file Patdata contains information about the patients of a small group of general surgeons.

The first three records contain a patient's name, address, city, state, and zip code. The fourth record contains the patient's ID number followed by the name of the primary physician.

Suppose you want to read each patient's information in the following order:

The #n pointer controls in the program below cause four records to be read for each execution of the DATA step.

data perm.patients;
   infile patdata;
   input #4 ID $5.
         #1 Fname $ Lname $
         #2 Address $23.
         #3 City $ State $ Zip $
         #4 @7 Doctor $6.;

run;

The first time the DATA step executes, the first four records are read, and an observation is written to the data set.

During the second iteration, the next four records are read, and the second observation is written to the data set, and so on.

The PROC PRINT output of the data set shows how information that was spread over several records has been condensed into one observation.

proc print data=perm.patients noobs;
run;

LIBNAME libref 'SAS-data-library';

FILENAME fileref 'filename';

DATA SAS-data-set;

    INFILE file-specification;

    INPUT #n variable …

          #n @n variable … /

          variable … /

          variable … ;

RUN;

PROC PRINT DATA=SAS-data-set;

RUN;

libname perm 'c:
ecordsempdata';
filename personel 'c:
ecordsempdata
ew.dat';
data perm.emplist3;
   infile personel;
   input #2 Department $ 5-16
         #1 @16 ID $4. @1 Name $14. /
            JobCode 3. /

            Salary comma9.;
run;
proc print data=perm.emplist3;
run;