The following SAS code requests a listing of the contents of the library called sashelp:

PROC CONTENTS data = sashelp._ALL_ nods;
RUN;

First, what are SAS Libraries all about? Let's have you launch your SAS application. If the Explorer Window is not active, then click on the Explorer tab that appears among the bottom tabs.

Double click Libraries, which contains all available libraries. Then you should see a listing of your libraries, that is, something that looks like this:

You should see, at least, three libraries that SAS defines for you by default:

• As you know, Work is a temporary library for files that do not need to be saved from session to session.
• Sashelp is a permanent library that contains more than 200 sample data and other files that control how SAS works at your site. You can download these sample data for practicing or illustrating purposes.
• Sasuser is a permanent library that contains SAS files in the Profile catalog that store your personal settings. You may also opt to store your own files there. (Personally, I don't.)

Now, let's have you run   the SAS code. Upon doing so, you should see an output that looks something like this:

Now, to view the descriptor information for any of the files that appear in the sashelp library, we need to modify our CONTENTS procedure a little bit.

The following SAS code tells SAS to display the descriptor information for the class data set that appears in the sashelp library:

PROC CONTENTS data = sashelp.class;
RUN;

Launch and run   the SAS code. (If, by chance, the class data set is not stored in your sashelp library, modify the code so that it references a data set that is stored in the library.) Review the resulting output to convince yourself that SAS does indeed display the descriptor information. Note in particular that, by default, SAS displays the variable information in alphabetical order:

If we instead preferred to view a listing of the variables in the order in which they appear in the data set, we again need to modify the CONTENTS procedure a bit.

The following SAS code again tells SAS to display the descriptor information for the class data set that appears in the sashelp library. The varnum option requests that SAS display the listing of the variables in the order in which they appear in the data set:

PROC CONTENTS data = sashelp.class varnum;
RUN;

Launch and run   the SAS code. (Again, if the deskact data set is not stored in your sasuser library, modify the code so that it references a data set that is stored in the library.) Review the resulting output to convince yourself that SAS displays the descriptor information, and in particular, the variable information in the order in which the variables appear in the data set:

The following SAS program illustrates the simplest example of list input. Note that there is one blank space between each of the data values. Also note that although the data values need not be lined up in columns, we still recommend doing so because of the difficulty otherwise in "eyeing" the data quickly.

DATA temp;
  input subj name $ gender height weight;
  * The $ that follows name tells SAS that it is
       a character variable;
  * By default, name only allows up to 8 characters
       to be read in;
  CARDS;
  1024 Alice 1 65 125
  1167 Maryann 1 68 140
  1168 Thomas 2 68 190
  1201 Benny 2 72 190
  1302 Felicia 1 63 115
  ;
RUN;
PROC PRINT data=temp;
  title 'Output dataset: TEMP';
RUN;

Output

The INPUT statement is how you tell SAS to read in the data using list input. For list input, simply list the variable names — leaving at least one space between names — in the order in which the variables appear in the data file. Remember to use the dollar sign ($) to distinguish character variables from numeric variables.

Launch and run the SAS program. Review the output from the print procedure to convince yourself that the data are read in properly.

The following SAS program illustrates the necessary use of the missing value (.) placeholder when a data value is missing:

DATA temp;
  input subj name $ gender height weight;
  CARDS;
  1024 Alice 1 65 125
  1167 Maryann 1 68 140
  1168 Thomas 2 68 190
  1201 Benny 2 . 190
  1302 Felicia 1 63 115
  ;
RUN;
PROC PRINT data=temp;
  title 'Output dataset: TEMP';
RUN;

Output

Note that Benny's height is missing. Therefore, since we are using the list input style to read in the data, we have to put in a missing value (.) placeholder.

First, launch and run the SAS program. Review the output from the print procedure to convince yourself that the data are read in properly. Then, edit the program by deleting the missing value (.) placeholder. Rerun   the SAS program to see what happens when you fail to account for the missing value. In the log file, you should see a note that says:

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

And the resulting output:

should indicate that something has clearly gone awry. What is going on here is that, by default, SAS goes to the next data line to find more data if there are more variable names in the INPUT statement then there are values in the data line. In this case, Benny's height becomes 190, the first number to appear in the data line after gender, and Benny's weight becomes 1302, the first number to appear in the next data line.

The following SAS program illustrates how a character variable is, by default, truncated if it contains more than 8 characters. The name 'Benedictine' is saved in the variable name as 'Benedict'.

DATA temp;
  input subj name $ gender height weight;
  CARDS;
  1024 Alice 1 65 125
  1167 Maryann 1 68 140
  1168 Thomas 2 68 190
  1201 Benedictine 2 68 190
  1302 Felicia 1 63 115
  ;
RUN;
PROC PRINT data=temp;
  title 'Output dataset: TEMP';
RUN;

Output

Launch and run the SAS program. Review the output from the print procedure to convince yourself that the name 'Benedictine' is indeed truncated to 'Benedict'. Incidentally, it is possible to use a LENGTH statement to tell SAS to allow the character variable name to contain more than eight characters. We'll learn about the LENGTH statement later.

The following SAS program illustrates how you can use the DELIMITER option of the INFILE statement to use values separators other than blanks. This example, in particular, illustrates it for the commonly used comma (,) as a delimiter:

DATA temp;
  infile cards delimiter=',';
  input subj name $ gender height weight;
  CARDS;
  1024,Alice,1,65,125
  1167,Maryann,1,68,140
  1168,Thomas,2,68,190
  1201,Benny,2,.,190
  1302,Felicia,1,63,115
  ;
RUN;
PROC PRINT data=temp;
  title 'Output dataset: TEMP';
RUN;

Output

By default, SAS assumes data are space-delimited. The DELIMITER option of the INFILE statement here instead warns SAS that the data are comma-delimited — that is, that commas separate the data values rather than blank spaces. You might also have noted that although the INFILE statement typically directs SAS to externally stored data, here the CARDS option included in the INFILE statement alerts SAS that the data are actually included in the code. Launch and run the SAS program. Review the output from the print procedure to convince yourself that the data are indeed read in properly.

Now, let's go investigate another style of input, namely formatted input.

The following SAS program uses the @n column pointer control and standard numeric informats to read three numeric variables — subj, height, and weight — into a temporary SAS data set called temp:

DATA temp;
  input @1  subj 4. 
        @27 height 2. 
        @30 weight 3.;
  DATALINES;
1024 Alice       Smith  1 65 125 12/1/95  2,036
1167 Maryann     White  1 68 140 12/01/95 1,800
1168 Thomas      Jones  2    190 12/2/95  2,302
1201 Benedictine Arnold 2 68 190 11/30/95 2,432
1302 Felicia     Ho     1 63 115 1/1/96   1,972
  ;
RUN;
PROC PRINT data = temp;
  title 'Output dataset: TEMP';
RUN;

Output

If you look at the INPUT statement, you'll see that it uses @n absolute pointer controls to move the input pointer first to column 1 to read subj, then to column 27 to read height, and finally to column 30 to read weight. In general, the @ moves the pointer to column n, the first column of the field that is being read.

The 4. that appears after subj, the 2. that appears after height, and 3. that appears after weight are the informats that tells SAS how to read each of the raw data values. In each case here, we are trying to read in standard numeric data values, and so we use what is called the w.d informat. The w tells SAS the width of the raw data value, that is how many columns it occupies. The d, which is optional, tells SAS the number of implied decimal places for the raw data value. The w and d must be connected by a period (.) delimiter. If the d is not present, you still need to make sure that you include the period in the informat name.

Making this all a little more concrete ... here, the subj values are four columns wide with no decimal places, and hence we use the 4. informat. We alternatively could have specified a 4.0 informat, but we could not have specified 4 (without the period) as the informat. The height values are two columns wide with no decimal places, and hence we use the 2. informat. Finally, the weight values are three columns wide with no decimal places, and hence we use the 3. informat.

Incidentally, the w.d informat ignores any d that we specify if the data value already contains a decimal point. So, for example, if we had a raw data value of 23.001 (occupying 6 columns with 5 digits, 1 decimal point, and 3 decimal places) and specified a 6. informat, SAS would still store the value as 23.001, even though we told SAS not to expect any decimal places.

Okay ... launch and run the SAS program, and review the output obtained from the print procedure to convince yourself that the three variables were read incorrectly. Oh, do you remember when I said that you needn't tell SAS to move the input pointer to the first column because it does so by default? You might want to convince yourself of this by removing the @1 that appears in the INPUT statement. Then, rerun   the program to convince yourself that SAS still reads the data values properly.

The following SAS program uses the @n column pointer control and standard character and numeric informats to read, respectively, two character variables — l_name and f_name — and two numeric variables — weight and height — into a temporabackwardry SAS data set called temp:

DATA temp;
  input @18 l_name $6.
        @6  f_name $11.
		@30 weight 3.
		@27 height 2.;
  DATALINES;
1024 Alice       Smith  1 65 125 12/1/95  2,036
1167 Maryann     White  1 68 140 12/01/95 1,800
1168 Thomas      Jones  2    190 12/2/95  2,302
1201 Benedictine Arnold 2 68 190 11/30/95 2,432
1302 Felicia     Ho     1 63 115 1/1/96   1,972
  ;
RUN;
PROC PRINT data = temp;
  title 'Output dataset: TEMP';
RUN;

Output

The INPUT statement uses @n absolute pointer controls to move the input pointer first to column 18 to read l_name, then back to column 6 to read f_name, forward to column 30 to read weight, and back again to column 27 to read height. This example illustrates, therefore, how you can use @n pointer controls to read data fields in any order ... backwards, forward, and backward again.

The 3. that appears after weight and the 2. that appears after height should look familiar. They are again the numeric informats that tells SAS how to read each of the two numeric variables of interest. Now, if you look at the informats for the two character variables, l_name, and f_name, you should see that they each begin with a dollar sign ($). Because we are trying to read in character data values, we use what is called the $w. informat. The w tells SAS the width of the raw data value, that is how many columns it occupies. The dollar sign ($) and period (.) are required delimiters. In our example, the last name (l_name) occupies as many as 6 columns, hence, the $6. informat, and the first name (f_name) occupies as many as 11 columns hence we use the $11. informat.

Okay ... launch and run the SAS program, and review the output obtained from the print procedure to convince yourself that the four variables were read in correctly.

In addition to using @n absolute pointer controls with numeric and character informats, the following SAS program uses +n relative pointer controls with nonstandard informats to create a temporary SAS data set called temp containing six variables:

DATA temp;
  input @1  subj 4.
        @6  f_name $11.
		@18 l_name $6.
		+3 height 2.
        +5 wt_date mmddyy8.
        +1 calorie comma5.;
  DATALINES;
1024 Alice       Smith  1 65 125 12/1/95  2,036
1167 Maryann     White  1 68 140 12/01/95 1,800
1168 Thomas      Jones  2    190 12/2/95  2,302
1201 Benedictine Arnold 2 68 190 11/30/95 2,432
1302 Felicia     Ho     1 63 115 1/1/96   1,972
  ;
RUN;
PROC PRINT data = temp;
  title 'Output dataset: TEMP';
RUN;

Output

You should now understand the specifications for reading subj, f_name and l_name. The INPUT statement tells SAS to go to column 1 to read the numeric field subj that is four columns wide, then to go to column 6 to read the character field f_name that is 11 columns wide, and then to go to column 18 to read the character field l_name that is 6 columns wide.

The +n relative pointer controls are used to read the remaining three variables — height, wt_date, and calorie. The +n pointer control moves the input pointer forward to a column number that is relative to the current position of the pointer. That is, the + moves the pointer forward n columns. In order to count correctly, it is important to understand where the column pointer is located after each data value is read. In general, when using formatted input, the column pointer moves to the first column that follows the field that was just read.

Again, let's make it more concrete. When SAS finishes reading the l_name field, the column pointer moves to the first column that follows that field, that is, to the column that immediately follows the d in Arnold (column 24). Now, the height field begins 3 columns to the right, so that's why we tell SAS to move +3 before reading the height data. When SAS finishes reading the height field, the column pointer moves to the first column that follows that field, that is, to the empty column that follows the heights (column 29). Now, the wt_date field begins 5 columns to the right, so that's why we tell SAS to move +5 before reading the weight dates. When SAS finished reading the wt_date field, the column pointer moves to the first column that follows the field, that is to the empty column just before the calorie data (column 42). Now, the calorie field begins 1 column to the right, so that's why we tell SAS to move +1 before reading the calorie data.

We'd be all done explaining the INPUT statement if it weren't for the wt_date and calorie fields containing nonstandard numeric data. The wt_date field contains forward slashes (/) for specifying the dates, and the calorie data contains commas (,). To read the wt_date field, we use the mmddyy8. informat to tell SAS to expect dates written in mm/dd/yy form. The 8, of course, tells SAS that the dates could occupy as many as eight columns. To read the calorie field, we use the comma6. informat to tell SAS to read numeric data containing commas and occupying as many as 6 columns.

In general, the COMMAw.d informat is used to read numeric values and to remove embedded blanks, commas, dashes, dollar signs, percent signs, right parentheses, and left parentheses (which are converted to minus signs). The w. tells SAS the width of the field (including dollar signs, decimal places, or other special characters). The d, which is optional, tells SAS the number of implied decimal places for a value.

Whew!!! Now, go ahead and launch and run the SAS program, and review the output obtained from the print procedure. In doing so, note that formatted input does not imply formatted output. For example, note that SAS stores 12/01/95 as the number 13118. We won't worry about this too much yet — it's just that, interestingly enough, SAS stores dates as numeric values equal to the number of days that have passed since January 1, 1960. Yup, that's right —dates after January 1, 1960, are stored as unique positive integers, and dates before January 1, 1960, are stored as unique negative integers. Also, note that SAS prints the values of the variable calorie without commas. In order to get SAS to print the values in a more understandable format, we must tell SAS how to format the output by using a SAS FORMAT statement.

Type in the following statement exactly as it appears:

FORMAT wt_date mmddyy8. calorie comma5.;

between the INPUT statement and the DATALINES statement in your program. Rerun   the SAS program with the now included FORMAT statement, and review the output from the print procedure to convince yourself that the data are now printed as desired. You should now see that it looks something like this: