Typically (1) is not necessary, but performance and/or output may not be optimized if certain options are not set properly.  For instance, if I’ve got a program that creates ~20k local macro variables as part of its processing, it’s probably best that SYMBOLGEN is not turned on when it’s executed.  So, what to do?  Well, by using PROC OPTSAVE and PROC OPTLOAD, you can allow your programs to run the way you want, without overwriting users’ options.

At the beginning of your program, before the options statement, insert the following:

proc optsave out=libref.dataset;

You don’t have to specify the ‘out=’ option – the default is SASUSER.MYOPTS, or WORK.MYOPTS if SASUSER is unavailable.  I prefer to specify the location myself with a data set name that won’t likely interfere with anything the user would not want overwritten – something like WORK.<program name>_OPTSET.  Then, simply set the options that are appropriate for the program.  At the end of the program, insert the following:

proc optload data=libref.dataset;

This will restore the user’s options to those which were in place before the program was run.  Voila! Now your program will run at its best without mucking about with anyone’s preferred options.

For those who deal heavily with the often cumbersome issues of data management, the SAS Macro facility can be an indispensable tool.  I most often find that macro code is used to automate repetitive tasks and to generalize programs across various parameters – these are, of course, very valuable capabilities.  But, aside from these more common uses, I have found great value in using the macro language (with a healthy smattering of %SYSFUNC) to construct stand-alone utilities to be used in a variety of contexts.

So, what is %SYSFUNC?  Well, as always, I would direct the curious SAS programmer to have a gander at the online doc, but for simplicity I’ll just say that it’s a macro function that allows the use of Base SAS functions, outside of the Data Step – a sort of SAS Rosetta Stone, if you will.  So, why is that useful?  Let’s look at a simple example.

Suppose you need your program to iterate some steps over an unknown number of variables in a user-supplied variable list – how would you do that?  Well, as with most programming challenges, I’m quite certain there are many ways – one way is to use the simple macro function, %WORDCOUNT:

%macro wordcount(varlist, delim=' ');
  %let count=%eval(%sysfunc(countc(%qsysfunc(compbl(&varlist)), &delim)) + 1);
  &count
%mend wordcount;

%WORDCOUNT takes as arguments a variable list and the associated delimiter (defaulting to space-delimited).  Then, by using the COUNTC function (this is a Base SAS function, and there is no macro equivalent) nested within %SYSFUNC, it counts the number of delimiters, adds one and saves the result to the macro variable &count.  COMPBL (nested within %QSYSFUNC – see the section below discussing comma-delimited variable lists) is used to collapse multiple blanks into a single blank space – this prevents COUNTC from overcounting when multiple spaces occur between variables in a space-delimited list.  Note on the third line of the program that &count appears without a semicolon, this makes %WORDCOUNT an in-line function.  Let’s see an example of how %WORDCOUNT could work inside of a macro program.

%macro example;
  %let varlist= one two three four;
  %do i=1 %to %wordcount(&varlist);
    %let varname=%scan(&varlist, &i);
    %put  current variable name is &varname;
  %end;
%mend;

Upon execution of the above example program, the following is printed to the log:

current variable name is one
current variable name is two
current variable name is three
current variable name is four

Alternative delimiters may be used in %WORDCOUNT as well.  If the variable is comma-delimited, the macro should be called as follows:

%wordcount(%quote(&varlist), delim=%str(,))

Here, to keep SAS from becoming confused into thinking we are attempting to supply too many parameters, %QUOTE masks the commas in &varlist at execution time, and %STR masks the comma supplied as the delimiter parameter at compilation time.  %QUOTE masks the commas in &varlist only until it is passed to COMPBBL (%SYSFUNC will return an unquoted result, even if a macro quoting function has previously been used – %QSYSFUNC returns a quoted result).  By nesting COMPBL in %QSYSFUNC, the commas in &varlist are re-masked before the string is passed to COUNTC.

Okay, so that could be useful , but it’s not exactly mind-blowing.  Let’s consider a more complex example.  Think of the ways that you would find the number of observations in a data set.  Now, what if you want to find the number of observations satisfying a certain set of conditions?   The %DSWHERE macro takes as arguments a data set name and a where clause (which defaults to true – if the user simply wants the total number of observations), saves the resulting count in a global macro variable and prints the results to the log.

%macro dswhere(dataset, where=1) /cmd;                        /* 1 */
  %let ds=&dataset.(where=(&where));
  %let dsid=%sysfunc(open(&ds));                              /* 2 */
  %if &dsid=^0 %then %do;                                     /* 3 */
    %global number;
    %if &where=1 %then %do;
      %let number=%sysfunc(attrn(&dsid,nlobs));               /* 4 */
      %put &number OBSERVATIONS IN &dataset;
    %end;
    %else %do;
      %let number=%sysfunc(attrn(&dsid,nlobsf));              /* 5 */
      %put &number OBSERVATIONS IN &dataset WHERE &where;
    %end;
  %end;
  %else %do;
    %put %sysfunc(sysmsg());
  %end;
  %let dsid=%sysfunc(close(&dsid));                           /* 6 */
  %if &dsid=^0 %then %do;                                     /* 7 */
    %put THE DATASET: &dataset WAS NOT CLOSED;
  %end;
%mend dswhere;

Okay, there’s quite a lot going on here…

(1) Note the ‘cmd’ option in the %MACRO statement.  If the ‘cmdmac’ system option is turned on (a good option to include in your autoexec file), and the ‘cmd’ option is included in the definition of a macro that contains only macro code and/or command statements, the macro may be called from the command line in standard command syntax (no percent symbol, parentheses or commas to separate parameters).  Command syntax and the aforementioned options aren’t required to call a macro from the command line – any macro containing only macro code and/or command statements may be called from the command line in normal macro syntax.

(2) This is a biggie – the OPEN function is arguably the function that makes %SYSFUNC so powerful.  So, what’s the big deal?  Well, the depth and breadth of what can be achieved by the pairing of %SYSFUNC and the OPEN function cannot be addressed in a single post, but for now we’ll focus on the ability to use this combination to access metadata for our SAS data sets.

(3) If the data set has been successfully opened, the return code, saved in &dsid, will be a unique data set identifier.  If not, &dsid=0;

(4) Once a data set is open, the ATTRN function may be used to obtain certain numeric attributes associated with it (the ATTRC function may be similarly used for character attributes); in this case the ‘nlobs’ parameter indicates that the attribute to be returned is the number of logical observations in the data set.

(5) If the user has supplied a where clause, the ‘nlobsf’ parameter is fed into the ATTRN function to indicate that we wish to return the number of observations satisfying an active where clause (the data set will have been opened with the user-supplied where clause in place).  We could discard the condition on whether or not the user supplied a where clause and simply always use ‘nlobsf’, but it causes ATTRN to be less efficient – better to only use it if we have to.

(6) The CLOSE function is used to, well, close the data set once we are done with it (this is important – don’t forget to close your data sets!).

(7) CLOSE returns 0 if the action was successful.

Now, let’s have an example of this puppy in action, shall we?

/* Create a testing data set with the variable var that randomly takes values of A or B */

data testing;
  do i=1 to 1000;
    if ranuni(-1) le .5 then var='A';
    else var='B';
    output;
  end;
run;

/* Call %dswhere without a where clause */

%dswhere(testing)

/* Call %dswhere with a where clause */

%dswhere(testing, where= var='A')

Upon execution of the above macro calls, the following is printed to the log:

1000 OBSERVATIONS IN testing
511 OBSERVATIONS IN testing WHERE var='A'

Note also that following execution of %DSWHERE the global macro variable &number will contain the result.  So, %DSWHERE can be used within a program to pass its result for further processing or from the command line as part of ad-hoc review.  I have %DSWHERE included in my macro autocall library (a subsequent post) so it is always available for command line use.

So, %SYSFUNC has allowed me to create a handy word-counting macro function and an observation-counting command/utility macro with subsetting capabilities that can be either embedded in a program or used interactively.  There is a lot more that can be achieved through the use of %SYSFUNC – I’m always finding new ways to use it, and I’m sure that many of them will be covered in subsequent posts.