Data-Driven Programming Techniques Using SAS®

2 Likes

Paper 1023-2021

Authors

Kirk Paul Lafler, sasNerd

Abstract

Data-driven programming, or data-oriented programming (DOP), is a specific programming paradigm where the data (and/or data structures) controls the flow of a program and not the program logic. Often, data-driven programming approaches are applied in organizations with structured and unstructured data for filtering, aggregating, transforming and calling other programs. This presentation explores several data-driven programming techniques that are available to SAS users. Topics include using the CALL EXECUTE routine to process (or execute) code generated by a DATA step; constructing custom user-defined formats from your data; and using the SQL procedure to create single-value (aggregate) and value-list (array) macro variables along with the macro language to automate a looping process to create exciting data-driven scenarios.

Watch the presentation

Watch Data-Driven Programming Techniques Using SAS® on the SAS Users YouTube channel.

INTRODUCTION

The SAS System collects and populates valuable information (“metadata”) about SAS libraries, data sets (tables), catalogs, indexes, macros, system options, titles, views and a collection of other read-only tables called dictionary tables. Dictionary tables serve a special purpose by providing system-related information about the current SAS session’s SAS databases and applications. When a query is requested against a Dictionary table, SAS automatically launches a discovery process at runtime to collect information pertinent to that table. Metadata content can be very useful for developing data-driven techniques. Other data-driven programming techniques include using the CALL EXECUTE routine to process (or execute) code generated by a DATA step; constructing a user-defined format directly from data; and using the SQL procedure and the macro language to construct an automated looping process.

PROGRAMMING PARADIGMS

Programming languages are often classified by their basic features into one of the many programming paradigms. Three popular programming paradigms in use today by programming professionals are 1) Procedural programming – represented by blocks of code being organized logically by function, such as data input, data processing or manipulation, and data / results output; 2) Object-oriented programming – represented by a combination of functionality (behaviors) and data (attributes) hidden inside an object which can then be arranged into classes; and 3) Data-driven programming – represented by data controlling the flow of execution in a program.

WHAT IS DATA-DRIVEN PROGRAMMING?

Unlike procedural programming languages where a program’s flow of execution is described using a detailed step-by-step logical approach to solving a problem or with object-oriented programming where an object is told how to behave without all the detailed steps that informs the object how to behave. Data-driven programming involves a program that has its decisions and processes (the flow of execution) controlled (or dictated) by the data (or data structures).

Data-driven programming possesses many virtues over rival programming paradigms including having a default action assigned to it, provide greater flexibility, are often shorter in length, and can be easier to maintain due to a reduction, or elimination, of “hard-coded” values.

TRADITIONAL (OR "LEGACY") SAS METADATA SOURCES

SAS users have traditionally been accessing and producing metadata using PROC CONTENTS and PROC DATASETS.

PROC CONTENTS – Produces a directory of the SAS library and the details associated with each member type stored in a SAS library.

PROC DATASETS – SAS users are encouraged to read Michael A. Raithel’s (2018) landmark paper, PROC DATASETS: The Swiss Army Knife of Data Management Procedures. Like PROC CONTENTS, the PROC DATASETS CONTENTS statement produces a directory of the SAS library and the details associated with each member type (e.g., DATA, VIEW, INDEX) stored in a SAS library.

In the next example, PROC CONTENTS is specified to describe the metadata associated with the SAS data set, Movies.

PROC CONTENTS DATA=WORK.Movies ;
RUN ;

In the next example, PROC CONTENTS is specified to print a list of all SAS files that reside in the SAS library.

PROC CONTENTS DATA=WORK.Movies DIRECTORY ;
RUN ;

In the next example, PROC CONTENTS is specified to save the results of a SAS data set’s metadata that resides in the SAS library to a SAS data set.

PROC CONTENTS DATA=WORK.Movies
               OUT=WORK.Contents_Structure
              DIRECTORY ;
RUN ;

PROC PRINT DATA=WORK.Contents_Structure ;
RUN ;

DATA-DRIVEN PROGRAMMING USING DICTIONARY TABLES AND SASHELP VIEWS

SAS users can quickly and conveniently obtain useful information (metadata) about their SAS session with a number of read-only SAS system tables called DICTIONARY tables and SASHELP views. At any time during a SAS session, DICTIONARY tables can be accessed using the libref DICTIONARY in the FROM clause of a PROC SQL SELECT statement to capture information related to currently defined libnames, table names, column names and attributes, formats, and much more. SASHELP views can be accessed using any of your favorite procedures or in the DATA step.

Identifying the Names of the DICTIONARIES Tables and SASHELP Views

SAS users can identify any new Dictionary table release by accessing the read-only DICTIONARIES Dictionary table or VSVIEW SASHELP view. The content of the DICTIONARIES Dictionary table reveals the names of supported Dictionary tables. The following PROC SQL query uses the UNIQUE (or DISTINCT) keyword to generate a listing of existing Dictionary tables.

PROC SQL ;
  SELECT UNIQUE MEMNAME
    FROM DICTIONARY.DICTIONARIES ;
QUIT ;

SAS 9.4 currently supports 32 DICTIONARY tables as is illustrated below. Earlier versions of SAS supported fewer Dictionary tables. SAS 9.3 supported 30 DICTIONARY tables; SAS 9.2 supported 29 Dictionary tables; and SAS 9.1 software supported 22 Dictionary tables.

The contents of the VSVIEW SASHELP view reveals the names of supported SASHELP views in SAS 9.4. The following PROC SQL query uses the DISTINCT (or UNIQUE) keyword along with the SUBSTR function to identify a listing of SASHELP views starting with the character value, “V”.

PROC SQL ;
 SELECT DISTINCT MEMNAME
  FROM SASHELP.VSVIEW
   WHERE UPCASE(SUBSTR(MEMNAME,1,1)) = 'V'
     AND UPCASE(LIBNAME) = 'SASHELP'
    ORDER BY MEMNAME ;
QUIT ;

Names and Purpose of Each DICTIONARY Table and SASHELP View

The names and purpose of the DICTIONARY tables and equivalent SASHELP views appear in the following table.

DICTIONARY Table	SASHELP View	Purpose
CATALOGS	VCATALG	SAS Catalogs and Catalog-specific Information.
CHECK_CONSTRAINTS	VCHKCON	Check Constraints information.
COLUMNS	VCOLUMN	Columns from All Tables.
CONSTRAINT_COLUMN_USAGE	VCNCOLU	Constraint Column Usage.
CONSTRAINT_TABLE_USAGE	VCNTABU	Constraint Table Usage.
DATAITEMS	VDATAIT	Information Map Data Items.
DESTINATIONS	VDEST	Open ODS Destinations.
DICTIONARIES	VDCTNRY	DICTIONARY Tables and their Columns.
ENGINES	VENGINE	Available Engines.
EXTFILES	VEXTFL	Implicitly-defined File Definitions and Files Defined in FILENAME statements.
FILTERS	VFILTER	Information Map Filters.
FORMATS	VFORMAT	Available SAS and User-defined Formats and Informats.
FUNCTIONS	VFUNC	Available Functions.
GOPTIONS	VGOPT	SAS/GRAPH Software Graphics Options.
INDEXES	VINDEX	Information related to Defined Indexes.
INFOMAPS	VINFOMP	Information Maps.
LIBNAMES	VLIBNAM	Information related to SAS Data Libraries.
LOCALES	VLOCALE	Available Locales, Regions, Languages and Currency Symbols.
MACROS	VMACRO	Information about Defined Macros.
MEMBERS	VMEMBER	Information about SAS Defined Tables, Catalogs and Views.
OPTIONS	VOPTION	Information about SAS Default System Options.
PROMPTS	VPROMPT	Information about Information Map Prompts.
PROMPTSXML	VPRMXML	Information Map Prompts XML.
REFERENTIAL_CONSTRAINTS	VREFCON	Information about Referential Constraints.
REMEMBER	VREMEMB	All Remembered Information.
STYLES	VSTYLE	Information about All Styles.
TABLES	VTABLE	SAS Tables and Table-specific Information.
TABLE_CONSTRAINTS	VTABCON	Information about Table Constraints.
TITLES	VTITLE	Information about Defined Titles.
VIEWS	VVIEW	Views and View-specific Information.
VIEW_SOURCES	VSVIEW	Sources Referenced by View.
XATTRS	VXATTR	Extended Attributes.

Displaying DICTIONARY Table Definitions

A dictionary table’s definition can be displayed by specifying a DESCRIBE TABLE statement. The results of the statements and clauses used to create each dictionary table can be displayed on the SAS Log. For example, a DESCRIBE TABLE statement is illustrated below to display the CREATE TABLE statement used in building the OPTIONS dictionary table containing current SAS System option settings.

PROC SQL ;
  DESCRIBE TABLE
    DICTIONARY.OPTIONS ;
QUIT ;

The SAS Log results are displayed, below.

create table DICTIONARY.OPTIONS
  (
   optname char(32) label='Option Name',
   setting char(1024) label='Option Setting',
   optdesc char(160) label='Option Description',
   level char(8) label='Option Location'
  );

The COLUMNS DICTIONARY Table and VCOLUMN SASHELP View

Retrieving information about the columns in one or more data sets or tables is easy with the COLUMNS dictionary table. Similar to the results of the CONTENTS procedure, users are able to capture column-level information including column name, type, length, position, label, format, informat, and indexes, as well as produce cross-reference listings containing the location of columns in a SAS library. For example, the following code requests a cross-reference listing of the tables containing the TITLE column in the WORK library. Note: Care should be used when specifying multiple functions on the WHERE clause since the SQL Optimizer is unable to optimize the query resulting in all allocated SAS session librefs being searched. This can cause the query to run much longer than expected.

PROC SQL ;
  SELECT *
    FROM DICTIONARY.COLUMNS
      WHERE LIBNAME=”WORK”
        AND UPCASE(NAME)=”TITLE” ;
QUIT ;

The TABLES DICTIONARY Table and VTABLE SASHELP View

When users need more information about SAS files consider using the TABLES Dictionary table or the VTABLE SASHELP view. The TABLES dictionary table provides detailed information about the library name, member name and type, date created and last modified, number of observations, observation length, number of variables, password protection, compression, encryption, number of pages, reuse space, buffer size, number of deleted observations, type of indexes, and requirements vector. For example, to obtain a detailed list of files in the WORK library, a PROC SQL SELECT query can be constructed as follows. Note: Because the TABLE Dictionary table produces a considerable amount of information, users should consider specifying a WHERE clause when accessing this table.

PROC SQL ;
  SELECT *
    FROM DICTIONARY.TABLES
      WHERE LIBNAME="WORK" ;
QUIT ;

Accessing Information from SAS DICTIONARY Tables to Do Cool Things

SAS users can quickly and conveniently obtain useful information about their SAS session with a number of read-only SAS system tables called DICTIONARY tables. At any time during a SAS session, DICTIONARY tables can be accessed using the libref DICTIONARY in the FROM clause of a PROC SQL SELECT statement to capture information related to currently defined libnames, table names, column names and attributes, formats, and much more. SASHELP views can be accessed using any of your favorite procedures or in the DATA step. SAS 9.1 software supported 22 Dictionary tables and SASHELP views, SAS 9.2 supported 29 Dictionary tables and SASHELP views, SAS 9.3 supported 30 DICTIONARY tables and SASHELP views, and SAS 9.4 supports 32 DICTIONARY tables and SASHELP views.

Accessing and Displaying the Number of Rows in a Table

The DICTIONARY table, TABLES, can be accessed to capture and display each table name and the number of observations in the user-assigned WORK libref. The following PROC SQL code provides a handy way to quickly determine the number of rows in one or all tables in a libref without having to execute multiple PROC CONTENTS by using the stored information in the Dictionary table TABLES.

PROC SQL ;
  SELECT LIBNAME, MEMNAME, NOBS
    FROM DICTIONARY.TABLES
      WHERE LIBNAME="WORK"
        AND UPCASE(MEMTYPE)="DATA" ;
QUIT ;

Accessing and Displaying the Column Definitions for a “Key” Variable (or Variables) in All Tables

The DICTIONARY table, COLUMNS, is accessed to display all table names (data sets) that contain the variable TITLE in the user-assigned WORK libref as a cross-reference listing. To retrieve the needed type of information, you could execute multiple PROC CONTENTS against selected tables. Or in a more efficient method, you could retrieve the information directly from the read-only Dictionary table COLUMNS with the selected columns LIBNAME, MEMNAME, NAME, TYPE and LENGTH, as shown. For more information about Dictionary tables, readers may want to view the “free” SAS Press Webinar by Kirk Paul Lafler at http://support.sas.com/publishing/bbu/webinar.html#lafler2 or the published paper by Kirk Paul Lafler, Exploring Dictionary Tables and SASHELP Views.

PROC SQL ;
  SELECT LIBNAME, MEMNAME, NAME, TYPE, LENGTH
    FROM DICTIONARY.COLUMNS
      WHERE LIBNAME="WORK"
        AND UPCASE(NAME)="TITLE"
        AND UPCASE(MEMTYPE)="DATA" ;
QUIT ;

Capturing a List of Variables from the COLUMNS Dictionary Table

The DICTIONARY table, COLUMNS, can be accessed to capture and display each column name contained in one or more tables in the WORK libref. The following PROC SQL code provides a handy way to quickly capture the names of any, and all, columns contained in the MOVIES table without having to execute PROC CONTENTS.

PROC SQL NOPRINT ;
  SELECT NAME,
         COUNT(NAME)
         INTO :MVARIABLES SEPARATED BY ' ',
              :MVARIABLESNUM
   FROM DICTIONARY.COLUMNS
    WHERE LIBNAME="WORK"
      AND UPCASE(MEMNAME)="MOVIES" ;
QUIT ;
%PUT &MVARIABLES &MVARIABLESNUM ;

The resulting SAS Log appears, below.

%PUT &MVARIABLES &MVARIABLESNUM ;
Title Length Category Year Studio Rating        6

The previous example can be expanded so only the character-defined variables are saved in the macro variable. The next example illustrates PROC SQL code to capture the names of the character-defined columns contained in the MOVIES table and the contents of the macro variable is then specified in a SELECT statement to produce a report.

PROC SQL NOPRINT ;
  SELECT NAME
         INTO :MVARIABLES SEPARATED BY ', '
   FROM DICTIONARY.COLUMNS
    WHERE LIBNAME="WORK"
      AND UPCASE(MEMNAME)="MOVIES" 
      AND UPCASE(TYPE)="CHAR" ;
  %PUT &MVARIABLES ;
  RESET PRINT ;
  SELECT &MVARIABLES FROM MOVIES ;
QUIT ;

The resulting SAS Log appears, below.

%PUT &MVARIABLES ;
Title, Category, Studio, Rating

DATA-DRIVEN PROGRAMMING USING THE CALL EXECUTE ROUTINE

SAS users have a powerful DATA step routine called CALL EXECUTE that can be used for data-driven processing. The CALL EXECUTE routine accepts a single argument where the value can be a character-string or, when needed, a character expression containing SAS code elements to be executed after they are resolved. The CALL EXECUTE routine permits SAS statements and macro code to be stacked together and then executed, Batkhan (2017).

When the CALL EXECUTE routine contains SAS statement code without macro variables or macro references, the code is appended to the input stack for immediate execution after the DATA step ends. The argument can be specified with single or double quotes, dynamically generating SAS code for execution. To leverage data-driven processes with CALL EXECUTE, a control data set containing four distinct movie ratings (i.e., “G”, “PG”, “PG-13” and “R”) represented as four observations is created. The second DATA step then reads the contents of the control data set populating the unique value for the movie_rating variable in the individual CALL EXECUTE statements. Note: The CATS function is used to strip blanks and concatenate multiple strings together.

data work.movie_list ;  /* Control Data Set */
  length movie_rating $5. ;
  input @1 movie_rating $5. ;
  datalines ;
G
PG
PG-13
R
;
run ;

data _null_ ;  /* Populate Unique Value for the Movie_rating Variable */
  set work.movie_list ;
  call execute(CATS('ods Excel file="D:\',movie_rating,'_Rpt.xlsx"
                              style=styles.barrettsblue
                              options(embedded_titles="yes");')) ;
  call execute(CAT('title ', movie_rating, ' Movies;')) ;
  call execute(CATS('proc freq data=work.Movies(where=
                            (rating="',movie_rating,'"));')) ;
  call execute('tables Title;') ;
  call execute('run;') ;
  call execute('ods Excel close;') ;
run ;

DATA-DRIVEN PROGRAMMING USING CUSTOM-DEFINED FORMATS FROM DATA

The FORMAT procedure is a powerful tool for building user-defined informats and formats. These “custom” user-defined informats and formats provides SAS with instructions on how to read data into SAS variables and write (or display) output. Custom-defined informats and formats are defined as temporary or permanent, and are stored as entries in SAS catalogs. The available operations performed by the FORMAT procedure include the ability to:

Convert character values to numeric values
Convert numeric values to character values
Convert character values to other character values.

To prevent hard-coding VALUE clauses, custom-defined formats can be created dynamically from a SAS data set. This not only can be a more efficient approach than processing sort, merge, and join operations, Droogendyk (2010), it also allows data-driven processes to be leveraged. Consequently, the FORMAT procedure is able to create informats and formats without specifying an INVALUE, PICTURE, or VALUE clause by using a SAS control data set as input.

The control data set is specified with the CNTLIN option of PROC FORMAT. To start the process, the control data set being used must have the following required variables:

FMTNAME - specifies the name of a character variable whose value is the format or informat name.
START - specifies the name of a character variable that contains the value to be converted.
LABEL - specifies the name of a character variable that contains the converted value.

In the next example, the DATA step is specified with IF-THEN/ELSE logic to produce the control data set with the required variables. The contents of the control data set are then displayed with the PRINT procedure. Finally, the control data set is specified in the PROC FORMAT CNTLIN option.

data work.control ;
  fmtname = "$Movie_Rating" ;
  length label $23. ;
  input start $5. ;
  if start = "G"          then label = "General Audience" ;
  else if start = "PG"    then label = "Parental Guidance" ;
  else if start = "PG-13" then label = "Parental Guidance >= 13" ;
  else if start = "R"     then label = "Restricted" ;
  else if start = ""      then label = "ERROR – Movie Rating" ;
  output ;
  datalines ;
G
PG
PG-13
R
;
run ;

proc print data=work.control noobs ;
  title ;
  var fmtname start label ;
run ;

proc format library=work cntlin=control ;
quit ;

proc print data=mydata.movies noobs ;
  format rating $movie_rating. ;
run ;

DATA-DRIVEN PROGRAMMING USING THE SQL PROCEDURE AND THE MACRO LANGUAGE

The SQL procedure and the macro language are two versatile tools found in the Base SAS software. Combining the two together provides users with all the tools necessary to construct highly useful and effective data-driven programs. Lafler (2018) offers a data-driven approach to creating multiple Excel files. Triggered by calling a macro to reduce coding requirements, the process uses the Macro language, PROC SQL, the ODS Excel destination, and PROC FREQ to send output (results) to Excel. The ODS Excel Destination became production in SAS 9.4 (M4). It serves as an interface between SAS and Excel. The ODS Excel features include:

SAS Results and Output can be sent directly to Excel
Offers a Flexible way to create Excel files
Supports Reports, Tables, Statistics and Graphs
Formats Data into Excel Worksheet cells
Permits Automation of Production-level Workbooks.

The ODS Excel destination easily sends output and results to Excel. The ODS Excel syntax simplifies the process of sending output, reports, tables, statistics and graphs to Excel files. The ODS Excel options are able to:

Programmatically generate output and results
Control font used and font sizes
Add special features to row and column headers
Adjust row and column sizes
Format data values
Align data to the left, center or right
Add hyperlinks for drill-down capability.

Producing Multiple Excel Files

In the next example, a data-driven approach using PROC SQL SELECT code embedded inside a user-defined macro routine is constructed to dynamically produce separate Excel spreadsheets containing the frequency results for each unique By-group (e.g., Movie Rating). The SELECT query processes the Movies table, creates a single-value macro variable with the number of unique movie ratings, and a value-list macro variable with a list of the unique movie ratings separated with a tilde “~”. Using the FREQ procedure and a user-defined macro, both macro variables along with their respective values, an iterative macro %DO statement, a %SCAN function, and WHERE= data set option dynamically sends the results to one or more Excel spreadsheets for each By-group.

%macro multExcelfiles ;
  proc sql noprint ;
   select count(distinct rating)
    into :mrating_cnt  /* number of unique movie ratings */
     from WORK.Movies
      order by rating ;
   select distinct rating
    into :mrating_lst separated by "~"  /* list of movies */
     from WORK.Movies
      order by rating ;
  quit ;
  %do i=1 %to &mrating_cnt ;
     ods Excel file="D:/%SCAN(&mrating_lst,&i,~)_Rpt.xlsx"
              style=styles.barrettsblue
              options(embedded_titles="yes") ;
     title "%SCAN(&mrating_lst,&i,~)-Rated Movies" ;
     proc freq data=WORK.Movies(where=(rating="%SCAN(&mrating_lst,&i,~)")) ;
       tables Title ;
     run ;
     ods Excel close ;
  %end ;
  %put &mrating_lst ;
%mend multExcelfiles ;

%multExcelfiles ;

CONCLUSION

Unlike procedural programming languages where a program’s flow of execution is described using a detailed step-by-step logical approach to solving a problem or with object-oriented programming where an object is told how to behave, data-driven programming involves writing code that has its decisions and processes (the flow of execution) controlled (or dictated) by the data (or data structures). Data-driven programming offers SAS users with many virtues over rival programming paradigms including enhanced flexibility and easier to maintain due to a reduction, or elimination, of “hard-coded” values. Several data-driven programming techniques were presented including using the SAS System’s read-only Dictionary tables and SASHELP views to provide valuable information about SAS libraries, data sets, columns and attributes, catalogs, indexes, macros, system options, and views; using the CALL EXECUTE routine to process (or execute) code generated by a DATA step; constructing a user-defined format directly from data; and using the SQL procedure and the macro language to construct an automated looping process.

REFERENCES

Abolafia, Jeff and Frank DiIorio (2008), “Building Intelligent Macros: Using Metadata Functions with the SAS® Macro Language,” Proceedings of the 2008 SAS Global Forum (SGF) Conference.

Batkhan, Leonid, 2017, “CALL EXECUTE made easy for SAS data-driven programming”, a SAS Blog Post.

Batkhan, Leonid, 2016, “Modifying variable attributes in all datasets of a SAS library”, a SAS Blog Post, http://blogs.sas.com/content/sgf/2016/11/25/modifying-variable-attributes-in-all-datasets-of-a-sas-l....

Carpenter, Arthur L. (2017), “Building Intelligent Macros: Using Metadata Functions with the SAS® Macro Language,” 2017 SAS Global Forum (SGF) Conference, California Occidental Consultants, Anchorage, AK, USA.

Davis, Michael (2001), “You Could Look It Up: An Introduction to SASHELP Dictionary Views,” Proceedings of the 2001 SAS Users Group International (SUGI) Conference, Bassett Consulting Services, North Haven, CT, USA.

Droogendyk, Harry (2010). “SAS® Formats: Effective and Efficient,” Proceedings of the 2010 SouthEast SAS Users Group (SESUG) Conference.

Graebner, Robert W. (2001). “Developing Data-Driven SAS ® Programs Using PROC CONTENTS,” Proceedings of the 2001 MidWest SAS Users Group (MWSUG) Conference.

Hamilton, Jack (1998), “Some Utility Applications of the Dictionary Tables in PROC SQL,” Proceedings of the 1998 Western Users of SAS Software (WUSS) Conference, 85-90.

Lafler, Kirk Paul (2019), “Data-driven Programming Using SAS® for Beginners,” Proceedings of the 2019 South Central SAS Users Group (SCSUG) Conference, Software Intelligence Corporation, Spring Valley, CA, USA.

Lafler, Kirk Paul (2019). PROC SQL: Beyond the Basics Using SAS, Third Edition, SAS Institute Inc., Cary, NC, USA.

Lafler, Kirk Paul (2018), “Introduction to Data-driven Programming Using SAS®,” Proceedings of the 2018 South Central SAS Users Group (SCSUG) Conference, Software Intelligence Corporation, Spring Valley, CA, USA.

Lafler, Kirk Paul (2016), “Valuable Things You Can Do with SAS DICTIONARY Tables and SASHELP Views,” Wisconsin Illinois SAS Users (WIILSU) Conference, Software Intelligence Corporation, Spring Valley, CA, USA.

Lafler, Kirk Paul (2012), “Exploring DICTIONARY Tables and SASHELP Views,” South Central SAS Users Group (SCSUG) Conference and Kansas City SAS Users Group (KCSUG) Meeting, Software Intelligence Corporation, Spring Valley, CA, USA.

Lafler, Kirk Paul (2009), “DATA Step versus PROC SQL Programming Techniques,” 2009 South East SAS Users Group (SESUG) Conference, Software Intelligence Corporation, Spring Valley, CA, USA.

Lafler, Kirk Paul (2009), “Exploring DICTIONARY Tables and SASHELP Views,” 2009 Western Users of SAS Software (WUSS) Conference and 2009 Pharmaceutical SAS Users Group (PharmaSUG) Conference, Software Intelligence Corporation, Spring Valley, CA, USA.

Lafler, Kirk Paul (2008), “Undocumented and Hard-to-find PROC SQL Features,” Greater Atlanta SAS Users Group (GASUG) Meeting (June 11^th, 2008); Pharmaceutical SAS Users Group (PharmaSUG) Conference (June 1^st - 4^th, 2008); 2008 Michigan SAS Users Group (MSUG) Meeting (May 29^th, 2008); 2008 Vancouver SAS Users Group Meeting (April 23^rd, 2008); and 2008 PhilaSUG User Group Meeting (March 13^th, 2008); Software Intelligence Corporation, Spring Valley, CA, USA.

Lafler, Kirk Paul (2006), “Exploring Dictionary Tables with PROC SQL,” SAS Press Webinar Series – June 27, 2006.

Lafler, Kirk Paul (2005), “Exploring Dictionary Tables and SASHELP Views,” Proceedings of the Thirteenth Annual Western Users of SAS Software Conference.

Matise, Joe (2016). “Writing Code With Your Data: Basics of Data-Driven Programming Techniques,” Proceedings of the 2016 South East SAS Users Group (SESUG) Conference.

Raithel, Michael A. (2018). “PROC DATASETS; The Swiss Army Knife of SAS® Procedures,” Proceedings of the 2018 SAS Global Forum (SGF) Conference.

Varney, Brian (2000). “How to Think Through the SAS® DATA Step,” Proceedings of the 2000 SAS Users Group International (SUGI) Conference.

Villacorte, Renato G. (2012). “Go Beyond The Wizard With Data-Driven Programming,” Proceedings of the 2012 SAS Global Forum (SGF) Conference.

Wang, Hui (2015). “Creating Data-Driven SAS® Code with CALL EXECUTE,” Proceedings of the 2015 PharmaSUG Conference.

Whitlock, Ian (2006). “How to Think Through the SAS® DATA Step,” Proceedings of the 2006 SAS Users Group International (SUGI) Conference.

Whitlock, Ian (1998). “CALL EXECUTE: How and Why,” Proceedings of the 1998 SAS Users Group International (SUGI) Conference.

ACKNOWLEDGMENTS

The author thanks the 2021 SAS Global Forum Conference Committee for accepting my abstract and paper; the 2021 SAS Global Forum Executive Committee for organizing and supporting this virtual conference event; SAS Institute Inc. for providing SAS users with wonderful software; and SAS users everywhere for being the nicest and most curious people anywhere!

TRADEMARK CITATIONS

SAS and all other SAS Institute Inc. product or service names are registered trademarks or trademarks of SAS Institute Inc. in the USA and other countries. ® indicates USA registration. Other brand and product names are trademarks of their respective companies.

ABOUT THE AUTHOR

Kirk Paul Lafler is an entrepreneur, consultant and programmer, and has been a SAS user since 1979. Kirk is a lecturer and adjunct professor at San Diego State University; an advisor and adjunct professor at the University of California San Diego Extension; and an educator of dozens of SAS, SQL, Python, R and Excel courses, seminars, workshops, and webinars to thousands of users around the world. As the author of several books including PROC SQL: Beyond the Basics Using SAS, Third Edition (SAS Press. 2019) along with hundreds of papers and articles on a variety of SAS topics; Kirk has been selected as an Invited speaker, educator, keynote and section leader at SAS conferences and meetings worldwide; and is the recipient of 25 “Best” contributed paper, hands-on workshop (HOW), and poster awards.

Comments and suggestions can be sent to:

Kirk Paul Lafler

SAS® Consultant, Application Developer, Programmer, Data Analyst, Educator and Author

sasNerd

E-mail: KirkLafler@cs.com

LinkedIn: https://www.linkedin.com/in/KirkPaulLafler/

LinkedIn: https://www.linkedin.com/in/Order-of-Magnitude-Analytics/

Twitter: @SASnerd