INPUT Statement

Details

• When to Use INPUT
• Input Styles
  • Overview of Input Styles
  • Column Input
  • List Input
  • Formatted Input
  • Named Input
• Multiple Styles in a Single INPUT Statement
• Pointer Controls
  • Overview of Pointers
  • Using Column and Line Pointer Controls
  • Using Line-Hold Specifiers
  • Pointer Location After Reading
• Reading More Than One Record per Observation
  • Using the # Pointer Control
  • Reading Past the End of a Line
  • Positioning the Pointer before the Record
• How Invalid Data Is Handled
• End-of-File
• Arrays

When to Use INPUT

Use the INPUT statement to read raw data from an external file or in-stream data. If your data is stored in an external file, you can specify the file in an INFILE statement. The INFILE statement must execute before the INPUT statement that reads the data records. If your data is in-stream, a DATALINES statement must precede the data lines in the job stream. If your data contains semicolons, use a DATALINES4 statement before the data lines. A DATA step that reads raw data can include multiple INPUT statements.

You can also use the INFILE statement to read in-stream data by specifying a filename of DATALINES in the INFILE statement before the INPUT statement. Using DATALINES in the INFILE statement enables you to use most of the options available in the INFILE statement with in-stream data.

To read data that is already stored in a SAS data set, use a SET statement. To read database or PC file-format data that is created by other software, use the SET statement after you access the data with the LIBNAME statement. For more information, see SAS/ACCESS for Relational Databases: Reference and SAS/ACCESS Interface to PC Files: Reference.

Input Styles

Overview of Input Styles

There are four ways to describe a record's values in the INPUT statement:

• column
• list (simple and modified)
• formatted
• named.

Each variable value is read by using one of these input styles. An INPUT statement can contain any or all of the available input styles, depending on the arrangement of data values in the input records. However, once named input is used in an INPUT statement, you cannot use another input style.

Column Input

With column input, the column numbers follow the variable name in the INPUT statement. These numbers indicate where the variable values are found in the input data records.

input name $ 1-8 age 11-12;

This INPUT statement can read these data records:

----+----1----+----2----+
Peterson  21
Morgan    17

Because NAME is a character variable, a $ appears between the variable name and column numbers. For more information, see INPUT Statement: Column.

List Input

With list input, the variable names are simply listed in the INPUT statement. A $ follows the name of each character variable:

input name $ age;

This INPUT statement can read data values that are separated by blanks or aligned in columns (with at least one blank between):

----+----1----+----2----+
Peterson  21
Morgan  17

For more information, see INPUT Statement: List.

Formatted Input

With formatted input, an informat follows the variable name in the INPUT statement. The informat gives the data type and the field width of an input value. Informats also enable you to read data that are stored in nonstandard form, such as packed decimal, or numbers that contain special characters such as commas.

input name $char8. +2 income comma6.;

This INPUT statement reads these data records correctly:

----+----1----+----2----+
Peterson  21,000
Morgan    17,132

The pointer control of +2 moves the input pointer to the field that contains the value for the variable INCOME. For more information, see INPUT Statement: Formatted.

Named Input

With named input, you specify the name of the variable followed by an equal sign. SAS looks for a variable name and an equal sign in the input record:

input name= $ age=;

This INPUT statement reads these data records correctly:

----+----1----+----2----+
name=Peterson age=21
name=Morgan age=17

For more information, see INPUT Statement: Named.

Multiple Styles in a Single INPUT Statement

An INPUT statement can contain any or all of the different input styles:

input idno name $18. team $ 25-30 startwght endwght;

This INPUT statement reads these data records correctly:

----+----1----+----2----+----3----+----
023 David Shaw         red    189 165
049 Amelia Serrano     yellow 189 165

The value of IDNO, STARTWGHT, and ENDWGHT are read with list input, the value of NAME with formatted input, and the value of TEAM with column input.

Pointer Controls

Overview of Pointers

As SAS reads values from the input data records into the input buffer, it keeps track of its position with a pointer. The INPUT statement provides three ways to control the movement of the pointer:

column pointer controls

reset the pointer's column position when the data values in the data records are read.

line pointer controls

reset the pointer's line position when the data values in the data records are read.

line-hold specifiers

hold an input record in the input buffer so that another INPUT statement can process it. By default, the INPUT statement releases the previous record and reads another record.

With column and line pointer controls, you can specify an absolute line number or column number to move the pointer or you can specify a column or line location relative to the current pointer position. This table lists the pointer controls that are available with the INPUT statement.

You can use the COLUMN= and LINE= options in the INFILE statement to determine the pointer's current column and line location.

Using Column and Line Pointer Controls

Column pointer controls indicate the column in which an input value starts.

Use line pointer controls within the INPUT statement to move to the next input record or to define the number of input records per observation. Line pointer controls specify which input record to read. To read multiple data records into the input buffer, use the N= option in the INFILE statement to specify the number of records. If you omit N=, you need to take special precautions. For more information, see Reading More Than One Record per Observation.

Using Line-Hold Specifiers

Line-hold specifiers keep the pointer on the current input record when

• a data record is read by more than one INPUT statement (trailing @)
• one input line has values for more than one observation (double trailing @)
• a record needs to be reread on the next iteration of the DATA step (double trailing @).

Use a single trailing @ to allow the next INPUT statement to read from the same record. Use a double trailing @ to hold a record for the next INPUT statement across iterations of the DATA step.

Normally, each INPUT statement in a DATA step reads a new data record into the input buffer. When you use a trailing @, the following occurs:

• The pointer position does not change.
• No new record is read into the input buffer.
• The next INPUT statement for the same iteration of the DATA step continues to read the same record rather than a new one.

SAS releases a record held by a trailing @ when

• a null INPUT statement executes:

  input;

• an INPUT statement without a trailing @ executes
• the next iteration of the DATA step begins.

Normally, when you use a double trailing @ (@@), the INPUT statement for the next iteration of the DATA step continues to read the same record. SAS releases the record that is held by a double trailing @

• immediately if the pointer moves past the end of the input record
• immediately if a null INPUT statement executes:

  input;

• when the next iteration of the DATA step begins if an INPUT statement with a single trailing @ executes later in the DATA step:

  input @;

Pointer Location After Reading

Understanding the location of the input pointer after a value is read is important, especially if you combine input styles in a single INPUT statement. With column and formatted input, the pointer reads the columns that are indicated in the INPUT statement and stops in the next column. With list input, however, the pointer scans data records to locate data values and reads a blank to indicate that a value has ended. After reading a value with list input, the pointer stops in the second column after the value.

For example, you can read these data records with list, column, and formatted input:

----+----1----+----2----+----3
REGION1    49670
REGION2    97540
REGION3    86342

This INPUT statement uses list input to read the data records:

input region $ jansales;

After reading a value for REGION, the pointer stops in column 9.

----+----1----+----2----+----3
REGION1    49670
        ↑

These INPUT statements use column and formatted input to read the data records:

• column input

  input region $ 1-7 jansales 12-16;

• formatted input

  input region $7. +4 jansales 5.;
  input region $7. @12 jansales 5.;

To read a value for the variable REGION, the INPUT statements instruct the pointer to read seven columns and stop in column 8.

----+----1----+----2----+----3
REGION1    49670
       ↑

Reading More Than One Record per Observation

Using the # Pointer Control

The highest number that follows the # pointer control in the INPUT statement determines how many input data records are read into the input buffer. Use the N= option in the INFILE statement to change the number of records. For example, in this statement, the highest value after the # is 3:

input @31 age 3. #3 id 3-4 #2 @6 name $20.;

Unless you use N= in the associated INFILE statement, the INPUT statement reads three input records each time the DATA step executes.

When each observation has multiple input records but values from the last record are not read, you must use a # pointer control in the INPUT statement or N= in the INFILE statement to specify the last input record. For example, if there are four records per observation, but only values from the first two input records are read, use this INPUT statement:

input name $ 1-10 #2 age 13-14 #4;

When you have advanced to the next record with the / pointer control, use the # pointer control in the INPUT statement or the N= option in the INFILE statement to set the number of records that are read into the input buffer. To move the pointer back to an earlier record, use a # pointer control. For example, this statement requires the #2 pointer control, unless the INFILE statement uses the N= option, to read two records:

input a / b #1 @52 c #2;

The INPUT statement assigns A a value from the first record. The pointer advances to the next input record to assign B a value. Then the pointer returns from the second record to column 1 of the first record and moves to column 52 to assign C a value. The #2 pointer control identifies two input records for each observation so that the pointer can return to the first record for the value of C.

If the number of input records per observation varies, use the N= option in the INFILE statement to give the maximum number of records per observation. For more information, see N= option.

Reading Past the End of a Line

When you use @ or + pointer controls with a value that moves the pointer to or past the end of the current record and the next value is to be read from the current column, SAS goes to column 1 of the next record to read it. It also writes this message to the SAS log:

NOTE: SAS went to a new line when INPUT statement
      reached past the end of a line.

You can alter the default behavior (the FLOWOVER option) in the INFILE statement.

Use the STOPOVER option in the INFILE statement to treat this condition as an error and to stop building the data set.

Use the MISSOVER option in the INFILE statement to set the remaining INPUT statement variables to missing values if the pointer reaches the end of a record.

Use the TRUNCOVER option in the INFILE statement to read column input or formatted input when the last variable that is read by the INPUT statement contains varying-length data.

Positioning the Pointer before the Record

When a column pointer control tries to move the pointer to a position before the beginning of the record, the pointer is positioned in column 1. For example, this INPUT statement specifies that the pointer is located in column −2 after the first value is read:

data test;
   input a @(a-3) b;
   datalines;
 2
;

Therefore, SAS moves the pointer to column 1 after the value of A is read. Both variables A and B contain the same value.

How Invalid Data Is Handled

When SAS encounters an invalid character in an input value for the variable indicated, it

• sets the value of the variable that is being read to missing or the value that is specified with the INVALIDDATA= system option. For more information, see INVALIDDATA= System Option in SAS System Options: Reference.
• prints an invalid data note in the SAS log.
• prints the input line and column number that contains the invalid value in the SAS log. Unprintable characters appear in hexadecimal. To help determine column numbers, SAS prints a rule line above the input line.
• sets the automatic variable _ERROR_ to 1 for the current observation.

The format modifiers for error reporting control the amount of information that is printed in the SAS log. Both the ? and ?? modifiers suppress the invalid data message. However, the ?? modifier also resets the automatic variable _ERROR_ to 0. For example, these two sets of statements are equivalent:

input x ?? 10-12;

input x ? 10-12; 
_error_=0;

In either case, SAS sets invalid values of X to missing values. For information about the causes of invalid data, see SAS Language Reference: Concepts.

End-of-File

End-of-file occurs when an INPUT statement reaches the end of the data. If a DATA step tries to read another record after it reaches an end-of-file, then execution stops. If you want the DATA step to continue to execute, use the END= or EOF= option in the INFILE statement. Then you can write SAS program statements to detect the end-of-file, and to stop the execution of the INPUT statement but continue with the DATA step. For more information, see INFILE Statement.

Arrays

The INPUT statement can use array references to read input data values. You can use an array reference in a pointer control if it is enclosed in parentheses. See Positioning the Pointer with a Character Variable.

Use the array subscript asterisk (*) to read in all elements of a previously defined explicit array. SAS allows single or multidimensional arrays. Enclose the subscript in braces, brackets, or parentheses. Here is the form of this statement:

inputarray-name{*};

You can use arrays with list, column, or formatted input. However, you cannot read in values to an array that is defined with _TEMPORARY_ and that uses the asterisk subscript. For example, these statements create variables X1 through X100 and assign data values to the variables using the 2. informat:

array x{100};
input x{*} 2.;