SQL

By: Raj
Programmatic Approach using DATA Step and PROC SQL
Creating a SAS data set Using DATA Step:
DATA raj;
SET sashelp.class;
WHERE age<13;
LABEL name = 'First Name';
RENAME name = FName;
FORMAT height weight 5.1;
RUN;

Using the Simplest SELECT Step:

To select some/all variables and create a SAS data set.
PROC SQL;
SELECT *
FROM raj
;
QUIT;

A More selective Statement:

To print selected variables:
Using SAS dataset we use var statement to print particular variables:

PROC PRINT NOOBS LABEL DATA=raj;

VAR fname age;
RUN;

Using Proc Step:

PROC SQL;
SELECT fname, age
FROM raj
;
QUIT;

Storing Results:
Very often you don’t want to display results. Instead you want to store them for
use in subsequent computations. That’s what this DATA step will do:

Page 1 of 10
 SQL
By: Raj
DATA new;
SET raj;
RUN;

Using Proc Sql:

PROC SQL;
CREATE TABLE new AS
SELECT *
FROM raj
;
QUIT;

Column Subsets:
If you don’t need all of the variables available in the existing data set? In the
DATA step, a KEEP statement can be used to identify those to be stored in the new
data set. For example:
DATA subset;
SET raj;
KEEP fname sex age;
RUN;

Using Proc SQL we can create subsets.

PROC SQL;
CREATE TABLE subset AS
SELECT fname, sex, age
FROM raj
;
QUIT;

DATA subset;
SET raj;
DROP height weight;
RUN;

However, this approach to subsetting can be implemented if we turn to SAS

features available within PROC SQL. Specifically, we can code the DROP= data
set option for the table being created, as in:

PROC SQL;
CREATE TABLE subset(DROP=height weight) AS
SELECT *

Page 2 of 10
 SQL
By: Raj
FROM raj
;
QUIT;

Creating New Columns:

Using Data step:
DATA ratios;
SET raj;
ATTRIB Ratio FORMAT=5.2 LABEL='Weight:Height Ratio';
ratio = weight / height;
RUN;

Using PROC SQL:

PROC SQL;
CREATE TABLE ratios AS
SELECT *,
weight / height AS Ratio
FORMAT=5.2 LABEL='Weight:Height Ratio'
FROM raj
;
QUIT;

Calculate Descriptive Statistics:

Using Data Step:
PROC SUMMARY DATA=raj;
VAR age height weight;
OUTPUT OUT=overall_averages(DROP = _type_ _freq_)
MIN (age )=Youngest
MAX (age )=Oldest
MEAN(height)=Avg_Height
MEAN(weight)=Avg_Weight;
RUN;

Using proc Step:

PROC SQL;
CREATE TABLE overall_averages AS
SELECT MIN (age) AS Youngest,
MAX (age) AS Oldest,
MEAN(height) AS Avg_Height FORMAT=5.1,
MEAN(weight) AS Avg_Weight FORMAT=5.1
FROM raj

Page 3 of 10
 SQL
By: Raj
;
QUIT;

Creating Subtotals:
Suppose that instead of an overall summary, we want the computations stratified
by SEX. The PROC SUMMARY code shown previously can be adapted by
inserting a CLASS statement and coding the NWAY option (to suppress
production of the grand overall statistics, which we no longer want). Here is the
code:
PROC SUMMARY DATA=raj NWAY;
CLASS sex;
VAR age height weight;
OUTPUT OUT=group_averages(DROP = _type_ _freq_)
MIN (age )=Youngest
MAX (age )=Oldest
MEAN(height)=Avg_Height
MEAN(weight)=Avg_Weight;
RUN;

Using PROC SQL

PROC SQL;
CREATE TABLE group_averages AS
SELECT sex,
MIN (age) AS Youngest,
MAX (age) AS Oldest,
MEAN(height) AS Avg_Height FORMAT=5.1,
MEAN(weight) AS Avg_Weight FORMAT=5.1
FROM raj
GROUP BY sex
;
QUIT;

Conditionality
It is not uncommon to have values that depend on other values—in other words,
conditionality. Probably the most common way of implementing conditionality in
the DATA step is the IF/THEN/ELSE structure.
For example, suppose that students of different ages and sexes are to go on
different field trips. The 11-year-olds (boys and girls) are going to the zoo; girls
who are not going to the zoo (that is, 12-year-old girls) are going to the museum;
and boys who aren’t going to the zoo have to stay behind. Here’s one way of
generating a list of individual student destinations:

Page 4 of 10
 SQL
By: Raj

DATA trip_list;
SET raj;
IF age=11 THEN Trip = 'Zoo ';
ELSE IF sex='F' THEN trip = 'Museum';
ELSE trip = '[None]';
KEEP fname age sex trip;
RUN;

USING PROC SQL:

PROC SQL;
CREATE TABLE trip_list AS
SELECT fname,
age,
sex,
CASE WHEN age=11 THEN 'Zoo'
WHEN sex='F' THEN 'Museum'
ELSE '[None]'
END
AS Trip
FROM raj
;
QUIT;

USING SELECT STATEMENT IN DATA STEP:

DATA trip_list;
SET RAJ;
SELECT;
WHEN (age=11) Trip = 'Zoo ';
WHEN (sex='F') trip = 'Museum';
OTHERWISE trip = '[None]';
END;
KEEP fname age sex trip;
RUN;

FILTERING USING WHERE STATEMENT:

Using DATA STEP:

DATA girls;
SET raj;
WHERE sex='F';

Page 5 of 10
 SQL
By: Raj
RUN;

Using PROC SQL:

PROC SQL;
CREATE TABLE girls AS
SELECT *
FROM raj
WHERE sex='F'
;
QUIT;

PROC SQL;
SELECT *
FROM raj
WHERE age=10
;
QUIT;

PROC SQL;
CREATE TABLE tens AS
SELECT *
FROM raj
WHERE age=10
;
QUIT;

Filtering Aggregated Data:

SQL has a second filtering device, the HAVING clause. The distinction between
this and the WHERE clause is that HAVING conditions can reference summary
statistics and are evaluated after aggregations are performed. Thus they take effect
“downstream,” on the output side of the process.
To illustrate, consider this PROC SUMMARY step, which calculates the extreme
values of the HEIGHT variable and does so separately for each SEX/AGE
combination:

Using Proc Summary in Data Step:

PROC SUMMARY DATA=raj NWAY;

CLASS sex age;

Page 6 of 10
 SQL
By: Raj
OUTPUT MAX(height)=Tallest MIN(height)=Shortest
OUT= hilo(DROP = _type_ _freq_);
RUN;

Using Proc SQL:

PROC SQL;
CREATE TABLE hilo AS
SELECT sex,
age,
MAX(height) AS Tallest,
MIN(height) AS Shortest
FROM raj
GROUP BY sex, age
;
QUIT;

Reordering Rows:
The purpose of PROC SORT is the reordering of observations. For example, if we
run:

PROC SORT DATA=raj OUT=age_sort;

BY DESCENDING age fname;
RUN;

USING PROC SQL:

PROC SQL;
CREATE TABLE age_sort AS
SELECT *
FROM raj
ORDER BY age DESCENDING, fname
;
QUIT;

Elimination of Duplicate Records:

Eliminating duplicate rows from a table is a common task. To illustrate, we first
need to have a data set containing duplicates. We’ll get one by eliminating some of
the columns in Raj:

Page 7 of 10
 SQL
By: Raj
First create Dataset:

PROC SQL;
CREATE TABLE sex_age AS
SELECT sex, age
FROM RAJ
; QUIT;

A commonly used technique for elimination of the duplicates is to use the

NODUPRECS
option of PROC SORT:

PROC SORT DATA=sex_age OUT=sex_age_distinct NODUPRECS;

BY _ALL_;
RUN;

SQL has a special keyword, DISTINCT, to specify that duplicate rows are to be
eliminated. The keyword appears in the SELECT statement or clause, immediately
following SELECT and preceding the list of columns. So the SQL code to
eliminate duplicates from our table is:

PROC SQL;
CREATE TABLE sex_age_distinct AS
SELECT DISTINCT *
FROM sex_age
;
QUIT;

Combining Summary Statistics with Original detail:

Let’s begin by creating a table we will use in the examples:

PROC SQL;
CREATE TABLE teens AS
SELECT name AS FName,
age
FROM sashelp.class
WHERE age>12
;
QUIT;

Page 8 of 10
 SQL
By: Raj
Summary Stats using Proc Freq:
PROC FREQ DATA=teens NOPRINT;
TABLES age / OUT=cohorts(DROP=percent RENAME=(count=Many) );
RUN;

To combine these counts with the original data, we first sort that original data:
PROC SORT DATA=teens OUT=sorted;
BY age;
RUN;
DATA detail_and_counts;
MERGE sorted cohorts;
BY age;
RUN;

We now have all of the data together, but the names are grouped by AGE and thus
not in
alphabetical order.

PROC SORT DATA=detail_and_counts;

BY fname;
run;

Then we combine the original data with the counts, via a MERGE statement:
DATA detail_and_counts;
MERGE sorted cohorts;
BY age;
RUN;
We now have all of the data together, but the names are grouped by AGE and thus
not in alphabetical order. So we sort again to restore the original alphabetical
order:
PROC SORT DATA=detail_and_counts;
BY fname;
run;

It has taken four steps to get the output. In contrast, using SQL, we can simply
write:
PROC SQL;
CREATE TABLE detail_and_counts AS
SELECT fname,
age,
COUNT(*) AS Many

Page 9 of 10
 SQL
By: Raj
FROM teens
GROUP BY age
ORDER BY fname
;
QUIT;

Summary Statistics based on Distinct Values:

Sometimes, when we need summary statistics derived from our data, we want the
computer to ignore repetition of values. For example, suppose we want to know the
average of the AGE values that occur in our TEENS table, ignoring repetitions of
those values. In other words, we need an unweighted mean of AGE, in the sense
that we want to include each particular value (13 and so on) only once, no matter
how many times it may appear. The weighted mean is pretty simple to calculate,
with or without SQL. The non-SQL code is:

PROC MEANS DATA=teens MEAN MAXDEC=3;VAR age;

RUN;

Deriving our unweighted mean via PROC MEANS is more complicated, and is a
twostep proposition. First we have to eliminate repetitions of AGE values; one way
to do this is with PROC FREQ:

PROC FREQ DATA=teens NOPRINT;

TABLES age / out=freq2means(KEEP = age);
RUN;

Now we can proceed to find the average of these distinct (unduplicated) AGE
values, using PROC MEANS:

PROC MEANS DATA=freq2means MEAN MAXDEC=3;

VAR age;
RUN;

This derivation can be done in just one PROC SQL statement. We can even display
the simple weighted mean alongside. The code is:

PROC SQL;
SELECT MEAN( age)
LABEL = 'Weighted' FORMAT=8.3,
MEAN(DISTINCT age)
LABEL = 'Unweighted' FORMAT=8.3
FROM teens; QUIT;

Page 10 of 10