Course 4: SAS Macro Language Fundamentals

Welcome to the SAS Macro Language Fundamentals Certificate Program! This course focuses on mastering the SAS Macro Language to automate repetitive tasks, enhance code efficiency, and create dynamic SAS programs. Over one week, you will learn to create and use macro variables, develop macro programs, implement conditional and iterative processing, utilize macro functions, and apply advanced macro techniques. Designed for learners with basic SAS programming knowledge, this course equips you with skills to streamline workflows and build reusable code for data analysis.

Objective: By the end of the course, learners will be proficient in using the SAS Macro Language to automate tasks, create dynamic programs, and enhance code modularity, enabling efficient data processing and reporting.

Scope: The course covers macro variables, macro programs, conditional and iterative processing, macro functions, and advanced techniques, with hands-on exercises and quizzes.

Day 1: Introduction to SAS Macro Language

Introduction: The SAS Macro Language is a powerful tool that enhances SAS programming by enabling automation, dynamic code generation, and code reusability. It allows users to write flexible programs that adapt to changing data or requirements, reducing manual coding efforts. This session introduces the purpose, syntax, and basic components of the SAS Macro Language, setting the foundation for advanced automation.

Learning Objectives: By the end of this session, you will be able to understand the role and benefits of the SAS Macro Language in programming, recognize macro language components such as macro variables and macros, use basic macro statements like %LET and %MACRO, execute simple macro code to automate tasks, and identify use cases for macros in data analysis workflows.

Scope: This session focuses on the fundamentals of the SAS Macro Language, including its syntax, basic statements, and practical applications in SAS programming.

Background Information: Before the Macro Language, SAS programmers relied on repetitive coding, which was time-consuming and error-prone. The Macro Language introduces a layer of abstraction, allowing dynamic code generation and automation through macro variables and programs.

Hands-On Example:

Using a dataset sales_data, demonstrate basic macro language capabilities.

Example 1: Basic %LET Statement

%let region = North;
proc means data=sales_data;
  where Region = "®ion";
  var Sales;
run;

Example 2: Simple Macro Definition

%macro print_sales;
proc print data=sales_data;
  var Region Sales;
run;
%mend print_sales;
%print_sales

Example 3: Macro with Parameter

%macro print_region(region);
proc print data=sales_data;
  where Region = "®ion";
  var Sales Profit;
run;
%mend print_region;
%print_region(North)

Example 4: Global vs. Local Macro Variable

%let year = 2023;
%macro sales_year;
  %local month;
  %let month = Jan;
  proc means data=sales_data;
    where Year = &year and Month = "&month";
    var Sales;
  run;
%mend sales_year;
%sales_year

Example 5: Debugging with %PUT

%let region = South;
%put The region is: ®ion;
proc means data=sales_data;
  where Region = "®ion";
  var Sales;
run;

Interpretation: Example 1 uses %LET to assign a macro variable. Example 2 defines a simple macro to print data. Example 3 introduces a parameterized macro. Example 4 demonstrates variable scope. Example 5 uses %PUT for debugging macro variable values.

Supplemental Information:

Discussion Points:

How does the SAS Macro Language improve coding efficiency?
What are the advantages of using macro variables over hard-coded values?
When should you use a macro instead of standard SAS code?
How can macros simplify repetitive reporting tasks?
What are potential challenges in learning the Macro Language?

Day 2: Macro Variables and Basic Macro Programs

Introduction: Macro variables are the building blocks of the SAS Macro Language, enabling dynamic substitution in SAS code. Basic macro programs encapsulate reusable code, streamlining workflows. This session explores creating, managing, and using macro variables and writing basic macro programs to automate tasks.

Learning Objectives: By the end of this session, you will be able to create and manipulate macro variables using %LET and automatic variables, understand macro variable resolution, develop basic macro programs with %MACRO and %MEND, pass parameters to macros, and apply macro variables and programs in data processing.

Scope: This session focuses on macro variable creation, management, and basic macro program development for automation.

Background Information: Macro variables store text values that SAS substitutes during code execution, enabling dynamic programming. Macro programs group SAS code into reusable units, executed via macro calls.

Hands-On Example:

Using sales_data, create and use macro variables and programs.

Example 1: Multiple Macro Variables

%let region = East;
%let year = 2023;
proc means data=sales_data;
  where Region = "®ion" and Year = &year;
  var Sales Profit;
run;

Example 2: Automatic Macro Variables

%put Today is: &sysdate;
proc print data=sales_data;
  title "Report Generated on &sysdate";
run;

Example 3: Macro with Multiple Parameters

%macro summary_stats(var, region);
proc means data=sales_data;
  where Region = "®ion";
  var &var;
run;
%mend summary_stats;
%summary_stats(Sales, West)

Example 4: Nested Macro Variables

%let var1 = Sales;
%let var2 = &var1;
proc means data=sales_data;
  var &var2;
run;

Example 5: Macro Program with Debugging

%macro check_data;
  %put Checking dataset: sales_data;
  proc contents data=sales_data;
  run;
%mend check_data;
%check_data

Interpretation: Example 1 uses multiple macro variables for filtering. Example 2 leverages automatic variables like &SYSDATE. Example 3 passes multiple parameters to a macro. Example 4 demonstrates nested variable resolution. Example 5 includes debugging with %PUT.

Supplemental Information:

Discussion Points:

How do macro variables enhance code flexibility?
What are the benefits of using automatic macro variables?
When should you pass parameters to a macro?
How can you avoid common errors in macro variable resolution?
What are best practices for naming macro variables and programs?

Day 3: Conditional Processing in Macros

Introduction: Conditional processing in the SAS Macro Language allows programs to execute code selectively based on conditions, enabling dynamic and responsive programming. This session covers macro conditional statements like %IF-%THEN-%ELSE, enhancing macro flexibility.

Learning Objectives: By the end of this session, you will be able to use %IF-%THEN-%ELSE for conditional macro execution, apply comparison operators in macro conditions, combine conditional logic with macro variables, create macros that adapt to data conditions, and debug conditional macro code.

Scope: This session focuses on implementing and debugging conditional logic within macro programs.

Background Information: Macro conditional statements operate at the macro level, controlling which SAS code is generated, unlike DATA step IF-THEN statements that operate on data observations.

Hands-On Example:

Using sales_data, implement conditional macro logic.

Example 1: Basic Conditional Macro

%macro check_sales(region);
  %if ®ion = North %then %do;
    proc means data=sales_data;
      where Region = "®ion";
      var Sales;
    run;
  %end;
%mend check_sales;
%check_sales(North)

Example 2: %IF-%THEN-%ELSE

%macro report_type(type);
  %if &type = summary %then %do;
    proc means data=sales_data;
      var Sales Profit;
    run;
  %end;
  %else %do;
    proc print data=sales_data;
      var Region Sales;
    run;
  %end;
%mend report_type;
%report_type(summary)

Example 3: Numeric Comparison

%macro filter_sales(threshold);
  %if &threshold > 1000 %then %do;
    proc print data=sales_data;
      where Sales > &threshold;
      var Region Sales;
    run;
  %end;
%mend filter_sales;
%filter_sales(1500)

Example 4: Nested Conditions

%macro region_summary(region, year);
  %if ®ion = East %then %do;
    %if &year = 2023 %then %do;
      proc means data=sales_data;
        where Region = "®ion" and Year = &year;
        var Sales;
      run;
    %end;
  %end;
%mend region_summary;
%region_summary(East, 2023)

Example 5: Debugging Conditions

%macro debug_sales(region);
  %put Region is: ®ion;
  %if ®ion = %then %do;
    %put ERROR: Region is missing;
  %end;
  %else %do;
    proc means data=sales_data;
      where Region = "®ion";
      var Sales;
    run;
  %end;
%mend debug_sales;
%debug_sales(South)

Interpretation: Example 1 uses a simple %IF condition. Example 2 introduces %ELSE for alternative logic. Example 3 applies numeric comparisons. Example 4 demonstrates nested conditions. Example 5 includes debugging for missing inputs.

Supplemental Information:

Discussion Points:

How does macro conditional processing differ from DATA step logic?
What are the benefits of using %IF-%THEN in macros?
When would nested conditions be useful in macros?
How can you debug errors in macro conditional logic?
What are best practices for structuring conditional macros?

Day 4: Iterative Processing and Macro Functions

Introduction: Iterative processing in macros enables repetitive task automation, while macro functions provide tools for text manipulation and dynamic code generation. This session covers %DO loops and macro functions like %EVAL and %SCAN, enhancing macro program capabilities.

Learning Objectives: By the end of this session, you will be able to use %DO, %DO %WHILE, and %DO %UNTIL for iterative processing, apply macro functions like %EVAL, %SCAN, and %SUBSTR, combine iteration with macro variables, create macros for batch processing, and debug iterative macro code.

Scope: This session focuses on implementing iterative loops and leveraging macro functions for dynamic programming.

Background Information: Macro loops generate repetitive SAS code, while macro functions manipulate text or perform calculations, enabling complex automation.

Hands-On Example:

Using sales_data, implement iterative processing and macro functions.

Example 1: Basic %DO Loop

%macro yearly_reports;
  %do year = 2021 %to 2023;
    proc means data=sales_data;
      where Year = &year;
      var Sales;
      title "Sales Report for &year";
    run;
  %end;
%mend yearly_reports;
%yearly_reports

Example 2: %DO %WHILE Loop

%macro process_regions;
  %local i region;
  %let i = 1;
  %let region = %scan(North South East West, &i);
  %do %while (®ion ne );
    proc means data=sales_data;
      where Region = "®ion";
      var Sales;
    run;
    %let i = %eval(&i + 1);
    %let region = %scan(North South East West, &i);
  %end;
%mend process_regions;
%process_regions

Example 3: Using %EVAL

%macro calc_totals;
  %let count = 5;
  %let total = %eval(&count * 100);
  %put Total is: &total;
%mend calc_totals;
%calc_totals

Example 4: Using %SCAN

%macro split_vars(varlist);
  %local i var;
  %let i = 1;
  %let var = %scan(&varlist, &i);
  %do %while (&var ne );
    proc means data=sales_data;
      var &var;
    run;
    %let i = %eval(&i + 1);
    %let var = %scan(&varlist, &i);
  %end;
%mend split_vars;
%split_vars(Sales Profit)

Example 5: Using %SUBSTR

%macro extract_year(date);
  %let year = %substr(&date, 1, 4);
  proc means data=sales_data;
    where Year = &year;
    var Sales;
  run;
%mend extract_year;
%extract_year(2023-01-01)

Interpretation: Example 1 uses a %DO loop for yearly reports. Example 2 processes regions with %DO %WHILE. Example 3 performs arithmetic with %EVAL. Example 4 splits a variable list with %SCAN. Example 5 extracts a substring with %SUBSTR.

Supplemental Information:

Discussion Points:

How do macro loops improve automation efficiency?
What are the advantages of using macro functions like %SCAN?
When should you use %DO %WHILE versus %DO %UNTIL?
How can you debug errors in iterative macro code?
What are best practices for managing loop iterations?

Day 5: Advanced Macro Techniques

Introduction: Advanced macro techniques enable complex automation, dynamic code generation, and integration with SAS datasets. This session covers techniques like macro quoting, CALL SYMPUT, and macro interactions with datasets, enhancing macro program sophistication.

Learning Objectives: By the end of this session, you will be able to use CALL SYMPUT to create macro variables from data, apply macro quoting functions like %NRSTR, integrate macros with SAS datasets, create data-driven macros, and debug advanced macro programs.

Scope: This session focuses on advanced macro programming techniques for dynamic and data-driven automation.

Background Information: Advanced macro techniques leverage SAS datasets and macro quoting to handle special characters and dynamic inputs, enabling robust automation.

Hands-On Example:

Using sales_data, implement advanced macro techniques.

Example 1: CALL SYMPUT

data _null_;
  set sales_data end=eof;
  if eof then call symput('total_sales', put(sum(Sales), dollar12.2));
run;
%put Total Sales: &total_sales;

Example 2: Macro Quoting with %NRSTR

%macro special_chars;
  %let text = %nrstr(This & That);
  %put Text is: &text;
%mend special_chars;
%special_chars

Example 3: Data-Driven Macro

proc sql noprint;
  select distinct Region into :region_list separated by ' '
  from sales_data;
quit;
%macro region_reports;
  %local i region;
  %let i = 1;
  %let region = %scan(®ion_list, &i);
  %do %while (®ion ne );
    proc means data=sales_data;
      where Region = "®ion";
      var Sales;
    run;
    %let i = %eval(&i + 1);
    %let region = %scan(®ion_list, &i);
  %end;
%mend region_reports;
%region_reports

Example 4: CALL SYMPUTX

data _null_;
  set sales_data;
  if _n_ = 1 then call symputx('first_region', Region);
run;
%put First Region: &first_region;

Example 5: Debugging Advanced Macros

%macro debug_advanced;
  %put _all_;
  proc means data=sales_data;
    var Sales;
  run;
%mend debug_advanced;
%debug_advanced

Interpretation: Example 1 uses CALL SYMPUT to create a macro variable from data. Example 2 handles special characters with %NRSTR. Example 3 creates a data-driven macro using SQL. Example 4 uses CALL SYMPUTX for cleaner variable creation. Example 5 debugs with %PUT _ALL_.

Supplemental Information:

Discussion Points:

How does CALL SYMPUT enhance macro flexibility?
What are the benefits of data-driven macros?
When should you use macro quoting functions?
How can you debug complex macro programs?
What are best practices for advanced macro development?

Daily Quiz

Practice Lab

Select an environment to practice coding exercises. Use SAS OnDemand for Academics for a free SAS programming environment.

Exercise

Click the "Exercise" link in the sidebar to download the exercise.txt file containing 20 SAS Macro Language exercises with solutions. Use these exercises to practice creating macro variables, programs, and advanced techniques in SAS.

Grade

Day 1 Score: Not completed

Day 2 Score: Not completed

Day 3 Score: Not completed

Day 4 Score: Not completed

Day 5 Score: Not completed

Overall Average Score: Not calculated

Overall Grade: Not calculated

Generate Certificate

Click the button below to generate your certificate for completing the course.

Readme