Apostila Curso SASFree

Introdução à
Programação SAS
INCLUINDO:
• Apresentação do Ambiente SAS

• Estrutura Básica da Linguagem
• Manipulação de Arquivos
• Arrays
• Program Data Vector
• Conexão com Banco de Dados
• Operações MERGE e MODIFY
Eduardo Corrêa Gonçalves

eduardo.ence@gmail.com
Versão 1.0 - 29/01/2011
1
ÍNDICE
I. Conhecendo o Sistema SAS............................................................................................... 5

Lição 1 – O que é SAS?..................................................................................................... 5
Lição 2 – SAS: Uma Breve História................................................................................ 5
Lição 3 – A Arquitetura SAS........................................................................................... 5
Lição 4 – Enterprise Guide...............................................................................................8
Lição 5 – O Ambiente SAS .............................................................................................. 9
Módulos Licenciados no Servidor Servidor SAS I (Windows).................................... 10
Módulos Licenciados no Servidor SAS II (Mainframe).............................................. 10
II. Introdução à Linguagem SAS........................................................................................ 11
Lição 6 – Criação de um Projeto no Enterprise Guide ...............................................11
Lição 7 – Configuração de Projetos ............................................................................. 12
Lição 8 – Hello World – o Primeiro Programa SAS .................................................. 13
Lição 9 – Data Sets SAS ............................................................................................... 15
Variáveis e Observações............................................................................................... 16
Tipos de Dados.............................................................................................................. 16
Valores Nulos................................................................................................................ 16
Estrutura de um Data Set SAS...................................................................................... 17
Lição 10 – Libraries SAS ............................................................................................. 17
Lição 11 – DATA e PROC: os Dois Passos de um Programa SAS............................. 18
Programa Exemplo - DATALINES.............................................................................. 19
Características dos Passos DATA e PROC................................................................... 20
Lição 12 – A Library WORK......................................................................................... 21
Lição 13 – LOG do SAS.................................................................................................. 21
III. Manipulação de Arquivos............................................................................................. 23
Lição 14 – INFILE e INPUT: Comandos para Leitura de Arquivos......................... 23
Lição 15 – O Laço Implícito do Passo DATA (Built-in Loop).................................... 24
Lição 16 – Leitura de Arquivos com Caractere Delimitador ..................................... 25
Lição 17 – Mais Opções para Leitura de Arquivos ..................................................... 27
Leitura de Arquivos Delimitados por Tabulação ......................................................... 27
Leitura de Arquivos Delimitados por Espaço .............................................................. 27
FIRSTOBS ................................................................................................................... 27
TRUNCOVER ............................................................................................................. 27
LRECL ......................................................................................................................... 27
INFORMATS: PD e ZD............................................................................................... 28
Lição 18 – FILE e PUT: Comandos para Gravação de Arquivos Texto .................. 29
IV. Transformação de Dados ............................................................................................. 30
Lição 19 – Criação de Variáveis ................................................................................... 30
2
Lição 20 – Instruções de Desvio (1): IF-THEN-ELSE ................................................ 31
IF com apenas um comando subordinado..................................................................... 31
IF com mais de um comando subordinado................................................................... 31
IF / ELSE IF / ELSE .................................................................................................... 31
Lição 21 – Operadores Lógicos e Relacionais ..............................................................32
Lição 22 –Operação de Data Subsetting....................................................................... 33
Lição 23 –Data Set Options............................................................................................ 34
KEEP............................................................................................................................. 34
DROP............................................................................................................................ 34
WHERE.........................................................................................................................35
RENAME...................................................................................................................... 35
Lição 24 – Funções do SAS............................................................................................. 36
Lição 25 – RETAIN......................................................................................................... 37
Lição 26 – LENGTH....................................................................................................... 38
Lição 27 – Instruções de Desvio (2): SELECT-WHEN............................................... 40
Lição 28 – Comando OUTPUT...................................................................................... 42
Lição 29 – Valores Lógicos............................................................................................. 42
Lição 30 – Valores do Tipo Data (Date)........................................................................ 42
Lição 31 – Valores do Tipo Data/Hora: TIME e DATETIME e Função DHMS...... 44
Lição 32 – Funções para Manipulação de Informações do Tipo Data/Hora............. 45
Lição 33 – Estruturas de Repetição (1): DO-WHILE .................................................47
Lição 34 – Estruturas de Repetição (2): DO ................................................................ 48
Lição 35 – Estruturas de Repetição (3): DO-UNTIL................................................... 49
Lição 36 – Program Data Vector (PDV)....................................................................... 50
EXEMPLO 2 – FUNCIONAMENTO DO PDV COM “VARIÁVEL RETAIN”....... 52
V. Conexão com Banco de Dados....................................................................................... 53
Lição 37 – Visão Geral do Método de Acesso à Bancos Relacionais no SAS ........... 53
Lição 38 – Conexão com o Oracle ................................................................................ 54
Lição 40 – Conexão com o DB2 .................................................................................... 55
Lição 39 – Conexão via ODBC (Exemplo DB2).......................................................... 55
Lição 41 – Conexão via ODBC (Exemplo PostGreSQL)........................................... 55
Lição 42 – Boa Prática: Criar um Nó para as Libraries............................................ 56
Lição 43 – PROC SQL – Introdução............................................................................ 56
Lição 44 – PROC SQL – Usando Funções SAS........................................................... 58
Lição 45 – PROC SQL – Criação de Data Sets SAS a Partir de uma Tabela ......... 59
Lição 46 – PROC SQL – Criação de Objetos no Banco Oracle..................................59
VI. Introdução às PROCs do SAS....................................................................................... 61
3
Lição 47 – O que é uma PROC?.................................................................................... 61
A Opção DATA............................................................................................................ 61
Lição 48 – PROC SORT ................................................................................................ 62
Lição 49 – BY VARIABLES, BY VALUES e BY GROUPS ......................................63
Lição 50 – PROC PRINT............................................................................................... 64
Lição 51 – PROC MEANS – Parte 1............................................................................. 65
Lição 52 – PROC MEANS – Parte 2............................................................................. 67
Lição 53 – PROC FREQ................................................................................................. 68
Lição 54 – Comentários Finais....................................................................................... 71
VII. Programação SAS – Além do Básico.......................................................................... 72
Lição 55 – SET................................................................................................................. 72
Lição 56 – Os Comandos KEEP, DROP, RENAME e WHERE................................ 73
Lição 57 – Variáveis Temporárias: FIRST e LAST.................................................... 73
Lição 58 – MERGE - Introdução................................................................................... 74
Lição 59 – MERGE – Exemplo Básico.......................................................................... 75
Lição 60 – MERGE - Como Funciona?.........................................................................78
Lição 61 – MERGE – Opção IN.....................................................................................82
Lição 62 – MERGE – Problemas mais Comuns........................................................... 83
Lição 63 – MERGE Sem BY.......................................................................................... 85
Lição 64 – MERGE x SQL JOIN...................................................................................86
Lição 65 – MODIFY - Introdução................................................................................. 86
Lição 66 – MODIFY com o Comando BY.................................................................... 87
Lição 67 – Arrays............................................................................................................ 90
Lição 68 – Macro Variáveis............................................................................................ 92
Lição 69 – Macro Variáveis Dinâmicas - CALL SYMPUT........................................ 94
Lição 70 – Macros ......................................................................................................... 95
Lição 71 – Macros – Como Funcionam?...................................................................... 97
Lição 72 – É o Fim!........................................................................................................ 98
Referências......................................................................................................................... 100
Anexo A – Data Set do Censo de Washington.................................................................. 102
4
I. Conhecendo o Sistema SAS
Este capítulo apresenta uma breve introdução à arquitetura SAS e descreve a
configuração do ambiente SAS no IBGE.
Lição 1 – O que é SAS?
O sistema SAS pode ser definido como um ambiente de software completo para a
execução do processo de Business Intelligence (BI) nas empresas. Trata-se de um sistema
extremamente versátil, eficiente e poderoso, que é composto por diferentes módulos
especialmente direcionados para realizar o acesso, manipulação, integração e análise de
grandes bases de dados.
Lição 2 – SAS: Uma Breve História
O SAS foi criado por um grupo de pesquisadores da North Carolina State

University, no final dos anos 60 com o objetivo de realizar a análise estatística de dados
provenientes de uma pesquisa agrícola. O nome SAS era usado nesta época como acrônimo
para statistical analysis software1.
Durante a primeira metade dos anos 70 o programa tornou-se extremamente popular
em ambiente acadêmico e também passou a ser utilizado em muitas empresas. Isto motivou
os seus criadores a fundar, no ano de 1976, o SAS Institute2, companhia que passou a ser
responsável pelo desenvolvimento e comercialização de novas versões do produto (que
atualmente se encontra no Release 9.2). Desde então, a SAS consolidou-se como uma das
empresas de desenvolvimento de software mais importantes do mundo, sendo responsável
pela criação de aplicativos voltados não apenas para análise estatística, mas também para
diversas outras tarefas, tais como integração de dados, Data Warehousing, Data Mining e
CRM, entre outras.
Lição 3 – A Arquitetura SAS
O sistema SAS possui uma arquitetura bastante sofisticada e, infelizmente, nada

simples de ser entendida. Para começar a “complicação”, o sistema SAS não é vendido,
mas somente licenciado. Se uma empresa desejar o adquirir, precisará efetuar uma
assinatura anual, que inclui o software e os serviços de suporte necessários para a sua
instalação e manutenção. Ao final de um ano, a licença precisa ser renovada. Atualizações
de release (exemplo: do release 9.1.2 para o 9.1.3) podem ser realizadas sem a necessidade
do pagamento de taxas extras durante a vigência de uma assinatura.
Normalmente, um “ambiente” SAS é compostos por diversos módulos (também
chamados de componentes ou pacotes) de software. Estes são licenciados e integrados de
1
Em http://www.sas.com/presscenter/bgndr_history.html é possível encontrar outras informações sobre a
história do SAS.
2
Alguns anos depois a companhia retirou a palavra “Institute” de seu nome e passou a se chamar apenas SAS.
5
maneira separada pelas empresas, de acordo com as suas necessidades. As subseções a
seguir descrevem alguns dos pacotes do SAS.
BASE SAS
O “coração” do ambiente é o módulo Base SAS. Ele tem a finalidade principal de
oferecer funcionalidades para o acesso e transformação de dados, para a realização de
consultas ad-hoc e para a produção de relatórios em diversos formatos (PDF, HTML,
XML, RTF, XLS, entre outros). Além disso, o Base SAS pode ser utilizado para a
realização de diversos tipos de análise, desde a Estatística Descritiva simples (média,
variância, etc) até análise de freqüências e correlação. Todas essas tarefas são realizadas
com o uso de uma linguagem de programação denominada Linguagem SAS. Trata-se de
uma linguagem interpretada, dotada de recursos extremamente poderosos. A seguir são
relacionadas algumas de suas principais características:
• Possui uma sintaxe é simples (fácil de aprender) e “econômica”. Normalmente um

programa escrito em SAS possui um número de linhas de código significativamente
menor do que um programa escrito em outra linguagem para resolver a mesma
tarefa (como C++, PL/SQL, Transact SQL ou Java);
• Possui centenas de funções e procedures pré-definidas (built-in) para a extração,

transformação e análise de dados, além de rotinas para a produção de relatórios dos
mais diversos tipos;
• Suporta o uso das linguagens SQL e XML;
• Suporta a criação de macros (rotinas reutilizáveis)
IMPORTANTE: este curso possui o objetivo principal de apresentar os principais conceitos e

técnicas para o desenvolvimento de programas na Linguagem SAS.
O pacote Base SAS pode ser estendido através do licenciamento de outros

módulos. A incorporação de um novo módulo faz com que novos comandos e funções
sejam acrescentados de maneira automática à Linguagem SAS. As subseções a seguir
apresentam alguns dos módulos mais populares do Sistema SAS.
SAS/ACCESS
O componentes Base SAS é extremamente flexível para a leitura de arquivos. Ele
possibilita o acesso a arquivos binários, hexadecimais, EBCDIC, ASCII e XML, entre
outros formatos. No entanto, o Base SAS não é capaz de acessar informações armazenadas
em bancos de dados relacionais; ele também não consegue lidar com arquivos MDB e XLS.
Para que isso seja possível é preciso que a empresa adquira uma ou mais interfaces
(drivers) SAS/ACCESS. Cada interface é licenciada de forma separada, ou seja, existe
uma interface SAS/ACCESS específica para Oracle, uma específica para DB2, etc. Duas
interfaces merecem comentários especiais. A primeira delas é a SAS ACCESS to PC File
Formats, utilizada para permitir a manipulação de arquivos MDB, XLS e outros formatos
comuns do PC. A outra é a SAS/ACCESS to ODBC, que permite que qualquer SGBD
possa ser acessado via ODBC em um programa SAS (ou seja, com esse produto instalado é
possível acessar o Oracle, DB2, SQL Server, PostgreSQL ou qualquer outro banco). A
6
Figura 1.1 apresenta um exemplo de utilização do SAS/ACCESS em uma empresa
hipotética.
Figura 1.1 – SAS/ACCESS
Considere que o Sistema SAS da Figura 1.1 esteja instalado no ambiente Windows.
Observe que ele possui, além do módulo Base SAS (responsável pelo acesso a arquivos
texto), dois módulos SAS/ACCESS incorporados: SAS/ACCESS para Oracle (para acesso
ao SGBD Oracle) e SAS/ACCESS para ODBC (responsável pelo acesso aos SGBD’s
PostgreSQL e DB2). Embora o módulo SAS/ACCESS para ODBC também possa ser
utilizado com o banco Oracle, imagine que a empresa exemplo tenha preferido licenciar a
interface específica do Oracle, preocupada com questões relativas a desempenho no acesso
aos dados.
Após essa breve discussão, é possível concluir que o licenciamento de interfaces
SAS/ACCESS é algo praticamente obrigatório nas empresas. Afinal de contas, qual é a
empresa que, nos dias de hoje, não possui um SGBD relacional em operação?
SAS/STAT
Pacote que incorpora inúmeras procedures sofisticadas para análise estatística à
Linguagem SAS (regressão, análise multivariada, análise de dados categóricos, etc). É um
dos módulos mais importantes e populares do SAS (lembre-se de que as raízes do SAS
encontram-se na análise estatística!).
SAS/IML
Pacote de funções para a manipulação de matrizes.
SAS/ETS
Pacote de funções para Econometria e análise de Séries Temporais
7
IMPORTANTE: este não é um curso de Estatística e sim uma introdução à programação na
Linguagem SAS. Por este motivo, nenhuma das funcionalidades contidas nos pacotes SAS/STAT,
SAS/IML e SAS/ETS serão abordadas ao longo dos próximos capítulos.
SAS/GRAPH
Embora o componente Base SAS seja capaz de produzir diferentes tipos de gráficos,
novas funcionalidades para este fim podem ser acrescentadas com o licenciamento do
SAS/GRAPH;
SAS/GIS
Sistema de informações geográficas.
SAS/IT (Integration Technologies)

Módulo responsável por disponibilizar diversas interfaces externas. Com o uso deste
módulo é possível fazer com que programas desenvolvidos em outras linguagens (como
C#, Delphi e Visual Basic) possam acessar data sets do SAS e, até mesmo, executar
comandos na Linguagem SAS (ex: um passo DATA, uma proc FREQ, etc).
SAS/QC
Disponibiliza ferramentas de apoio ao controle de qualidade de processos de análise
estatística.
SAS/Connect
Pacote que torna possível a comunicação entre sessões SAS que estejam executando
em diferentes plataformas.
Conclusões e Comentários Finais

Esta seção apresentou uma breve descrição à arquitetura SAS. Em cada empresa, o
SAS pode ser composto módulos diferentes, de acordo com o tipo de problema para o qual
o produto será utilizado. Uma universidade que deseje utilizar o SAS como ferramenta de
apoio em um curso de Estatística poderia, por exemplo, licenciar os módulos Base SAS,
SAS/STAT, SAS/IML e SAS/ETS, mas não licenciar nenhum dos módulos SAS/ACCESS.
Já uma empresa que deseje utilizar o SAS com objetivo de construir programas que
acessem SGBD’s relacionais, precisaria, certamente, licenciar o Base SAS e pelo menos
uma interface SAS/ACCESS (mas poderia não licenciar o SAS/STAT, por exemplo). Em
[ETL-Tools 2008], é apresentado um exemplo de um Data Warehouse que é inteiramente
construído e gerenciado apenas com o uso do Base SAS. Já o trabalho de [Fernandez 2002]
apresenta diversos programas para Data Mining criados na Linguagem SAS, com o uso de
comandos e procedures disponibilizadas pelos módulos Base SAS, SAS/STAT, SAS/IML
e SAS/GRAPH.
Lição 4 – Enterprise Guide
O SAS Enterprise Guide (ou, simplesmente EG) é a principal ferramenta utilizada

no IBGE para a programação, acesso a dados e produção de relatórios em ambiente SAS.
Trata-se de uma aplicação cliente que roda apenas em ambiente Windows e que se
8
comunica com um Sistema SAS que esteja instalado em um computador remoto (Servidor
SAS). O EG utiliza componentes .NET para se comunicar com o módulo Integration
Technologies (SAS/IT) instalado em um Servidor SAS (ou seja, é preciso licenciar o
componente SAS/IT no servidor). A Figura 1.2 apresenta um esquema que ilustra a
comunicação entre um cliente EG dois servidores SAS.
Figura 1.2 – Comunicação entre o EG e dois Servidores SAS
Na Figura 1.2, um PC Cliente com o EG instalado, pode se comunicar com dois

Servidores SAS que estão executando em ambientes diferentes (Windows e Mainframe). A
comunicação entre o EG e os servidores é feita através do módulo Integration
Technologies.
A arquitetura cliente-servidor permite com que os usuários acessem dados e
executem tarefas no servidor criando, porém, os programas em seu PC. A arquitetura
funciona de maneira eficiente, pois apenas o código e os resultados são transmitidos por
rede entre o PC e o servidor [Holland 2007].
Atualmente, o EG encontra-se na versão 4. Informações sobre as características
dessa aplicação serão apresentadas ao longo do Capítulo II.
Lição 5 – O Ambiente SAS
A Figura 1.2, mostrada na lição anterior, representa um exemplo de como o

ambiente SAS poderia estar configurado em uma empresa. Existem dois servidores SAS
release 9.2, um deles operando em ambiente Windows (Servidor SAS I) e o outro no
mainframe (Servidor SAS II). O Enteprise Guide 4 é a principal ferramenta utilizada para a
criação de programas na Linguagem SAS. Os programas criados no EG podem ser
submetidos para execução tanto no Servidor SAS I como no servidor Servidor SAS II.
Cada servidor poderia ter diferentes módulos licenciados, conforme exemplificado a seguir:
9
Módulos Licenciados no Servidor SAS I (Windows)
Base SAS
SAS/IT
SAS/STAT
SAS/IML
SAS/ETS
SAS/QC
SAS/GRAPH
SAS/ACCESS to Oracle
SAS/ACCESS to ODBC
SAS/ACCESS to PC File Formats
Módulos Licenciados no Servidor SAS II (Mainframe)
Base SAS
SAS/IT
SAS/STAT
SAS/ACCESS to DB2
10
II. Introdução à Linguagem SAS
Um programa SAS é composto por uma seqüência de instruções submetidas ao
servidor SAS para interpretação e execução. Neste capítulo, os conceitos básicos sobre
programação em SAS serão apresentados.
Lição 6 – Criação de um Projeto no Enterprise Guide
Qualquer tipo de tarefa realizada no Enterprise Guide (EG) precisa ser organizada
em um projeto. Um projeto pode conter uma coleção de programas, logs, anotações,
tarefas, data sets e relatórios, entre outros objetos do SAS. Isto significa que, para que seja
possível criar um novo programa SAS é preciso, antes de tudo, criar um novo projeto ou
abrir um projeto existente no EG. Para criar um novo projeto basta executar uma das
seguintes ações:
- Iniciar o software (e fechar a janela de boas vindas); ou
- Se você já estiver com um projeto aberto, acessar o menu File / New / Project. No
EG, você pode ter apenas um projeto aberto de cada vez.
Uma tela similar à apresentada pela Figura 2.1 (tela principal do EG) será aberta.
Figura 2.1 – Tela Principal do Enterprise Guide
Observe a janela Project Explorer, localizada no canto esquerdo. Ela é responsável

por apresentar o nome do projeto e todos os seus componentes. Note que, por enquanto, o
projeto possui apenas um componente, do tipo Process Flow. Ele foi criado
automaticamente no momento em que o novo projeto foi iniciado. O Process Flow é um
diagrama que permite com que o usuário do EG possa especificar uma seqüência de
programas ou ações a serem executadas em um projeto. No canto direito da tela, localiza-se
outra janela importante, a Server List, que apresenta as informações relacionadas aos
11
servidores SAS da empresa. É preciso efetuar o login na rede Windows ou no MVS, para
que seja possível expandir as pastas dos servidores Windows e MVS, respectivamente.
Lição 7 – Configuração de Projetos
As configurações dos projetos criados no EG podem ser feitas através do menu

Tools / Options. Antes de criarmos o primeiro programa deste curso, vamos efetuar
algumas configurações:
1. Definição do Formato para Apresentação dos Resultados: depois de acessar o

menu Tools / Options, selecione a opção Results / Results General. No painel
Results Formats, deixe apenas a opção HTML selecionada (Figura 2.2).
Figura 2.2 – Definição do Formato dos Resultados em HTML
2. Definição do Servidor SAS Default: O servidor SAS que será utilizado para a
maioria dos exercícios apresentados neste curso será o SERVIDOR I. Para definir
este servidor como o servidor SAS default, selecione a opção Administration /
Repository and Server. Selecione SERVIDOR I e clique em OK (Figura 2.3).
12
Figura 2.3 – Definição do Servidor SAS default
Basta realizar esta configuração uma única vez, para que ela seja utilizada em
qualquer novo projeto SAS a ser criado futuramente.
IMPORTANTE: este curso não objetiva ensinar a utilização do Enterprise Guide. Ao invés disso é
um curso de Linguagem SAS onde os programas serão escritos e executados no EG. Por
este motivo apenas as informações essenciais sobre este software serão apresentadas ao longo
das lições.
Leitores que desejarem conhecer detalhes sobre a utilização do Enterprise Guide poderão
consultar as seguintes referências: [Bennett 2008], [Slaughter e Delwiche 2006] e [Slaughter e
Delwiche 2008].
Lição 8 – Hello World – o Primeiro Programa SAS
Esta lição tem o objetivo principal de demonstrar a forma como um programa pode
ser criado e executado no Enterprise Guide. Escreveremos um programa bem simples na
linguagem SAS, que irá criar um data set com a mensagem “Hello World!”. O programa
será executado no servidor SERVIDOR I (na rede de nossa empresa hipotética, suponha
que o nome dessa máquina seja S01). Para você criar o programa, siga as etapas descritas a
seguir:
1. Criar um nó do tipo código: Para acrescentar um programa a um projeto SAS é
necessário inserir um novo nó do tipo código no projeto. Isto pode ser feito
através do menu File / New / Code. Após executar esta ação, um ícone de código
será adicionado automaticamente à janela Project Explorer. Além disso, o editor de
código será disponibilizado (Figura 2.4).
13
Figura 2.4 – Nó do Tipo “Código” em um Projeto do Enteprise Guide
2. Alterar o Nome do Programa: é possível renomear qualquer programa inserido

em um projeto do EG (embora isso não seja obrigatório). Clique com o botão direito
sobre o nó “Code”, selecione a opção Rename e digite um novo nome (por exemplo
“ProgHello”.
3. Digitação do Programa: digite, na janela do editor, o código apresentado a seguir.
/*--------------------------------------------------------
Hello World - Meu primeiro programa SAS
---------------------------------------------------------*/
* cria um "data set" chamado Hello. Ele conterá;

* apenas uma variável (MSG) e uma observação (Hello World!);
DATA Hello;
MSG = 'Hello World!';
RUN;
Este programa cria um data set SAS (tabela) chamado Hello, que contém apenas
uma variável (coluna), chamada MSG, e uma única observação (linha) com o valor
‘Hello World!’. Note que:
1. Toda instrução SAS é encerrada com um ponto-e-vírgula (“ ; ”).
2. Os comentários podem ser definidos entre os símbolos “/*” e “*/” ou entre os

símbolos “ * ” e “ ; ”.
4. Execução do Programa: Agora que o programa está pronto, basta executá-lo.

Clique com o botão direito sobre o nó do programa e escolha a opção Run
ProgHello on S01 (Figura 2.5). Será solicitado o seu login e senha de rede (caso
você não use o SAS local). Entre com seus dados e clique em OK.
Figura 2.5 – Executando “ProgHello” no Servidor SERVIDOR I
14
5. Examinando os Resultados: após a execução do programa, dois nós serão
acrescentados ao projeto, todos subordinados ao nó do código.
a. O primeiro nó chamado Log apresenta informações a respeito da execução

do programa. A Lição 13 abordará a análise dos Logs do SAS.
b. O segundo nó, chamado HELLO, representa o data set criado como

resultado da execução do programa. Efetue dois cliques sobre este nó para
examinar o seu conteúdo. Conforme a Figura 2.6 mostra, o data set gerado
possui apenas uma coluna e uma linha.
Figura 2.6 – O Data Set HELLO
6. Salvando o Projeto: para salvar o projeto, clique em File / Save Project. Escolha a
opção Local Computer, para que o projeto seja gravado em sua estação de
trabalho. Conforme foi descrito na Lição 4, embora os programas sejam
executados no servidor SAS SERVIDOR I, eles devem ser gravados dentro dos
projetos, na estação do programador. Escolha uma pasta e salve o projeto com o
nome prjCapitulo1. Ele será gravado com a extensão *.egp (Enteprise Guide
Project).
OBSERVAÇÃO: na versão 2 do Enterprise Guide (anteriormente utilizada) os projetos são salvos

com a extensão *.seg.
Lição 9 – Data Sets SAS
O data set é o objeto utilizado pelo SAS para o armazenamento de dados. É similar
a uma tabela de um SGBD relacional, porém estruturada no formato interno do SAS. A
Figura 2.7 ilustra um data set que contém os dados oriundos do censo da cidade de
Washington, EUA (consulte o Anexo A para obter informações sobre este data set).
15
Figura 2.7 –Data Set com dados do Censo de Washington (1990)
IMPORTANTE: para que seja possível realizar a análise estatística, produzir relatórios ou
manipular dados com o uso dos comandos e procedures do SAS, primeiro é preciso importar os
dados que serão trabalhados para um data set.
A seguir algumas características dos data sets SAS:
Variáveis e Observações
No vocabulário SAS as linhas de uma data set são chamadas de observações e as
colunas são chamadas de variáveis.
Tipos de Dados
As variáveis de um data set suportam apenas dois tipos: numérico e caractere. As
variáveis numéricas podem ser positivas ou negativas, inteiras ou reais com qualquer
número de casas decimais. Elas são armazenadas na representação em ponto flutuante e
ocupam 8 bytes. No SAS um valor do tipo data/hora também é armazenado internamente
como um número. As variáveis do tipo caractere podem conter até 32767 caracteres. No
data set da Figura 2.7 existem duas variáveis numéricas (Age e HoursPerWeek) e quatro
variáveis caractere (Sex, Race, MaritalStatus e Education). Note que o EG usa ícones
diferentes para apresentar variáveis numéricas e caractere (Figura 2.7).
Valores Nulos
Um valor nulo em uma variável é chamado de missing no “vocabulário” SAS. Em
um data set SAS, as variáveis do tipo caractere representam um valor missing com um
espaço em branco, enquanto as variáveis numéricas representam o missing com um
ponto (“ . ”). Veja que na Figura 2.7 existem alguns valores missing para as variáveis Age e
Race.
16
Estrutura de um Data Set SAS
Além dos dados, um data set SAS também contém um descritor que armazena
informações sobre a estrutura do data set. Por exemplo: nome, data de criação, versão do
SAS em que o data set foi criado, propriedades das variáveis, etc.
Os data sets criados no SAS são gravados com a extensão *.sas7bdat no ambiente
Windows.
Lição 10 – Libraries SAS
Uma library SAS é um repositório de data sets SAS.

No ambiente Windows, a uma library SAS é uma pasta qualquer de alguma
máquina da rede. O comando LIBNAME indica ao SAS a localização da library. Para que
o servidor S01 possa ler ou gravar na library é necessário que a pasta correspondente esteja
compartilhada, com direito de leitura e/ou gravação cedido ao usuário que está em sessão
(logged in). Também já observamos que o firewall do Windows cliente precisa estar
desativado.
Para que o conceito fique mais claro, será apresentado um exemplo de definição e
acesso a uma library pelo EG. Execute os seguintes passos:
1. Insira um novo nó de código em seu projeto, digite e execute o programa abaixo.

Esse programa defina uma library denominada CURSO que está associada com o
compartilhamento de rede3 “\\CursoSAS”.
* Programa 2.2;
* cria a library CURSO;
* que corresponde ao repositório de dados do curso de SAS;
libname CURSO '\\CursoSAS';
2. Após a execução do programa, acesse a janela de servidores (servers). Expanda o

servidor SERVIDOR I e a pasta Libraries (Figura 2.8). Observe que a library
CURSO será apresentada. Ela contém data sets SAS que poderão ser manipulados
por seu projeto. Para visualizar o conteúdo de um data set clique duas vezes sobre o
nome do mesmo.
As outras libraries - MAPS, SASHELP, SASUSER e WORK são criadas

automaticamente pelo SAS sempre que uma sessão é iniciada. A mais importante
delas é a library WORK, a ser discutida em breve.
3
Consulte o instrutor para saber o nome do compartilhamento utilizado em seu curso.
17
Figura 2.8 – Visualizando as Libnames em uma Sessão SAS
IMPORTANTE: Para que você possa acessar arquivos usando Programas SAS, é preciso que
estes estejam armazenados em algum compartilhamento de rede que possa ser enxergado pelo
seu login de rede. Caso o seu programa precise gravar dados, será preciso que o seu login possua
direito de gravação no compartilhamento.
Nos programas SAS, os SGBD’s relacionais também são enxergados como libraries, conforme
será discutido no Capítulo 5.
Lição 11 – DATA e PROC: os Dois Passos de um

Programa SAS
Todo programa SAS é construído a partir de apenas dois tipos de passos: DATA e
PROC. As instruções que compõem o programa são colocadas dentro de cada passo. O
esquema apresentado na Figura 2.9 - adaptado de [Garrido et al 1996] - ilustra o fluxo de
um programa SAS simples.
Figura 2.9 – um Programa SAS Típico
18
• No fluxo da Figura 2.9, o programa começa com o passo DATA que é responsável
pela criação de um data set SAS. O data set pode ser construído a partir de fontes
de dados distintas como, por exemplo, tabelas de SGBD’s relacionais e arquivos
texto.
• A seguir, o programa vai para o passo PROC, responsável pela análise do data set
dados e produção de relatórios.
Programa Exemplo - DATALINES
Para que o conceito fique mais claro, digite e execute o seguinte programa:
* Programa 2.3: cria um data set e produz relatório a partir do mesmo;

* Passo Data – cria o data set “PAISES”;
DATA PAISES;
INPUT NOME $ POPULACAO;
DATALINES;
BRASIL 191790900
URUGUAI 3339701
CHILE 16634758
;
RUN;
* Passo PROC – gera relatório a partir do data set “PAISES”;
PROC PRINT DATA=PAISES;
RUN;
OBSERVAÇÃO: a Linguagem SAS não é case-sensitive, ou seja, os comandos podem ser

escritos em letra maiúscula ou minúscula.
O programa-exemplo possui um passo DATA (linhas 3-10) e um passo PROC

(linhas 12-13). A primeira instrução do passo DATA é:
DATA PAISES;
Todo passo DATA começa com a palavra reservada DATA seguida por um nome,
que representa o nome do data set que será produzido ao final da execução do passo (no
exemplo, PAISES). Normalmente os dados usados para montar um data set são obtidos
através de fontes externas. No entanto, no programa, o data set PAISES é populado com
dados internos (dados especificados no próprio código fonte), como o uso dos comandos:
CARDS e INPUT.
O comando INPUT é um dos mais importantes do SAS e será discutido com
detalhes no Capítulo III. No programa-exemplo ele foi utilizado com o propósito de
especificar as variáveis do data set PAISES. Estas variáveis são NOME, do tipo caractere
e POPULACAO do tipo numérico. O símbolo “ $ ” ao lado da palavra NOME indica ao
SAS que esta variável é do tipo caractere.
O comando DATALINES é usado para o lançamento das observações do data set.
Todas as linhas que forem encontradas após a palavra DATALINES serão consideradas como
novas observações até que o SAS encontre um ponto-e-vírgula (linha 9). Os valores de cada
19
variável devem ser separados com espaço em branco. O comando DATALINES não é muito
utilizado em aplicações práticas, pois normalmente os dados de um data set são montados a
partir de fontes externas. No entanto, ele costuma ser muito utilizado para fins didáticos
(em exemplos e manuais do SAS). Ele possui um comando equivalente (que funciona do
mesmo modo), chamado CARDS.
O comando RUN marca o fim do passo DATA. Um passo DATA ou PROC é
encerrado quando o SAS encontra um novo passo (marcado pelas palavras-chave DATA ou
PROC), quando o fim do programa é alcançado, ou quando o comando RUN é encontrado.
Apesar de não ser obrigatório, o comando RUN é muito utilizado porque melhora a
legibilidade do código e do log gerado. Após o final do passo DATA, inicia-se o passo
PROC, que é composto por apenas uma instrução:
PROC PRINT DATA=PAISES;
Um passo PROC do SAS começa com a palavra PROC seguida do nome da

procedure a ser executada (como PRINT, FREQ, MEANS, entre outras). A procedure PRINT é
uma das mais utilizadas do SAS e sua função é produzir um relatório com o conteúdo de
um data set. Maiores detalhes sobre a PROC PRINT serão apresentados em capítulos
posteriores. O formato do relatório gerado pela PROC PRINT no Enterprise Guide é
determinado pela escolha feita na Figura 2.2 (ver Lição 7).
Características dos Passos DATA e PROC

No exemplo mostrado nessa lição, o programa continha apenas um passo DATA e
um passo PROC. No entanto, um programa SAS pode ser composto por inúmeros passos
DATA e PROC, que podem ser intercalados da forma que o programador desejar. Além
disso, é possível criar programas que possuam apenas passos DATA (algo até certo ponto
comum) ou apenas passos PROC (situação bem menos comum).
Existem comandos do SAS que devem ser utilizados apenas dentro dos passos
DATA e aqueles usados apenas dentro de passos PROC. Um erro cometido por muitos
iniciantes é o de tentar utilizar um comando no passo errado. Para que você não cometa
esse erro, procure lembrar das diferenças básicas entre os dois passos [Slaughter e
Delwiche 2003]:
• Passo DATA
 Começa com a palavra DATA.
 É usado para leitura e modificação de dados, oriundos de fontes
diversas.
 Cria um data set.
• Passo PROC
 Começa com a palavra PROC.
 É normalmente usado para invocar alguma procedure para análise de
dados do SAS.
 Produz um conjunto de resultados ou um relatório.
IMPORTANTE: Na prática, nem sempre as diferenças entre os dois passos são tão claras e
rígidas. Existem situações onde é possível criar um data set dentro de um passo PROC ou gerar
relatórios dentro de um passo DATA!
20
IMPORTANTE: existem alguns comandos de configuração que devem ser especificados fora dos
passos DATA e PROC. Um exemplo é o comando LIBNAME.
A Linguagem SAS é uma linguagem orientada a passos [Whitlock 2007] e não

uma linguagem procedural ou orientada a objetos. Nas linguagens convencionais as
informações são passadas entre as rotinas através do uso de parâmetros e estruturas em
memória. No SAS, a comunicação entre os passos é feita, tipicamente, com o uso de data
sets. Inicialmente, a estrutura de um programa SAS pode parecer estranha, se comparada
com a de outras linguagens. No entanto, lembre-se de que o SAS não é uma linguagem de
propósito geral, como C ou Java, que são utilizadas para a criação de sistemas. Na realidade
a linguagem SAS tem um propósito específico: criar programas para a integração,
modificação e análise de grandes volumes de dados.
Lição 12 – A Library WORK
WORK é uma library especial criada automaticamente pelo SAS sempre que uma
sessão é iniciada e destruída, também de forma automática, quando uma sessão encerrada.
Cada sessão SAS possui a sua library WORK associada.
Todo data set é criado dentro da WORK, caso nenhum outro local seja especificado
no código de um programa SAS. A Figura 2.10 ilustra esse fato: o data set PAISES, gerado
pelo programa da lição anterior, encontra-se armazenado nessa library.
Figura 2.10 – A Libname WORK
Como a WORK é uma library temporária, todo conteúdo nela armazenado também
é excluído ao final de uma sessão SAS. De maneira mais clara, isto quer dizer que os data
sets da WORK também morrem no momento uma sessão SAS é finalizada! Se você
desejar persistir um data set, precisará criá-lo em outra library.
Lição 13 – LOG do SAS
Uma dos “artefatos” mais interessantes do SAS é o seu log de execução de

programas. Sempre que um programa é submetido para execução, o SAS produz
21
automaticamente um arquivo de log associado, que contém as linhas de código do
programa adicionadas de mensagens do SAS com relação ao status da execução.
No EG, um “nó de log” é acrescido a um código quando este é executado. A Figura
2.11 apresenta alguns trechos do log associado à execução do programa que gerou e
imprimiu o data set PAISES, apresentado na Lição 11.
1 The SAS System 16:45 Monday, March 31, 2008
...
14 * Programa 2.3: cria um data set e produz relatório a partir do mesmo
15
16 * Passo Data - cria data set;
17 DATA PAISES;
18
19 INPUT NOME $ POPULACAO;
20 CARDS;
2 NOTE: The data set WORK.PAISES has 3 observations and 2 variables.

NOTE: DATA statement used (Total process time):
real time 0.00 seconds
cpu time 0.00 seconds
24 ;
25 RUN;
26
27 * Passo PROC - gera relatório a partir do data set criado;
28 PROC PRINT DATA=PAISES;
29 RUN;
3 NOTE: There were 3 observations read from the data set WORK.PAISES.
NOTE: PROCEDURE PRINT used (Total process time):
real time 0.79 seconds
cpu time 0.01 seconds
...
43 QUIT; RUN;
44
Figura 2.11 – Arquivo de Log de um Programa SAS
Veja que o log inicia (1) com informações sobre a data e hora de execução do
programa. A seguir (2) apresenta informações a respeito do passo DATA que gerou o data
set PAISES: número de observações, variáveis e tempo de execução. A mesma coisa é feita
com relação à execução da PROC PRINT (3).
O comando put pode ser utilizado para escrever mensagens no log. Este é um
recurso útil no processo de depuração de programas.
DATA T_XY;
INPUT X Y;
PUT 'ISSO VAI SER ESCRITO TRÊS VEZES';
DATALINES;
1 11
2 12
3 13
;
RUN;
Em resumo, qualquer erro, aviso ou informação relevante sobre a execução de um

programa é colocada de forma automática pelo SAS em seu arquivo de log. E você também
pode escrever as suas mensagens nele, se assim desejar.
22
III. Manipulação de Arquivos
Este capítulo apresenta a maneira pela qual arquivos podem ser acessados e,
posteriormente, transformados em data sets SAS
Lição 14 – INFILE e INPUT: Comandos para Leitura de

Arquivos
Os comandos INFILE e INPUT são utilizados no passo DATA para possibilitar a

leitura de arquivos. O arquivo a ser lido é especificado na instrução INFILE, enquanto as
variáveis que serão obtidas a partir dele são indicadas com o uso do INPUT. A seguir será
apresentado um exemplo de utilização destes comandos na leitura de um arquivo texto
seqüencial separado por colunas. O arquivo contém a tabela de NATUREZA JURÍDICA
20034, cujo formato é apresentado na Figura 3.1.
Figura 3.1 – Tabela de Natureza Jurídica 2003 (CONCLA)
O arquivo possui duas variáveis: código da natureza jurídica (campo numérico,

iniciado na coluna 1 e com tamanho 4) e descrição (campo caractere, iniciado na coluna 5 e
com tamanho fixo de 80 caracteres. Descrições com menos de 80 caracteres estão
completadas com brancos). O programa abaixo apresenta o código necessário para abrir
este arquivo e transferir o seu conteúdo para um data set SAS. Note que o programa fica
muito pequeno. Como já foi comentado, o código SAS costuma ficar menor do que o de
outras linguagens.
* Programa 3.1: cria data set NATUREZA a partir do arquivo NJUR.TXT;

DATA NATUREZA;
INFILE '\\CursoSAS\NJUR.TXT';
INPUT
@1 CODIGO 4.
@5 DESCRICAO $CHAR80.;
RUN;
A primeira instrução do programa - DATA NATUREZA - serve para dizer ao SAS:
“crie um data set chamado NATUREZA na pasta WORK”. A seguir, o comando INFILE
especifica que o data set será gerado a partir de informações obtidas no arquivo
'\\CursoSAS\NJUR.TXT'. Esta é a forma mais simples de usar o comando: escrever
4
Disponível em http://www.ibge.gov.br/concla/naturezajuridica/2003.php
23
INFILE e depois o nome do arquivo a ser acessado. A instrução aceita alguns parâmetros
que serão apresentados nas Lições 16 e 17.
Nas linhas 4-6 do programa, o comando INPUT é usado para determinar as variáveis
que farão parte do data set NATUREZA e indicar a forma pela qual elas podem ser obtidas
no arquivo de origem,. Existem várias maneiras de utilizar a instrução INPUT. No programa
exemplo desta seção, foi utilizada a seguinte sintaxe:
@coluna_inicial1 NOME_DA_VARIAVEL1 tipo_e_tamanho1.

@coluna_inicial2 NOME_DA_VARIAVEL2 tipo_e_tamanho2.
...
@coluna_inicialn NOME_DA_VARIAVELn tipo_e_tamanhon.
;
Cada variável é especificada em uma linha, bastando indicar a coluna inicial no

arquivo do INFILE, um nome (que representará o nome da variável no data set) e o tipo e
tamanho da variável. Variáveis do tipo caractere precisam ser especificadas com uso da
máscara $CHAR. O comando INPUT é finalizado com o uso de ponto-e-vírgula.
IMPORTANTE: o programa apresentado nesta seção funcionou corretamente pelo fato de que o
arquivo de entrada foi montado com um comprimento fixo para cada linha (84 caracteres, 4 para o
código da natureza e 80 para a sua descrição). As linhas onde a descrição da natureza jurídica
possui menos de 80 caracteres foram completadas com espaços em branco.
Este tipo de formato é comum no mainframe, mas nem sempre é utilizado no Windows. Na Lição
17 será demonstrada uma forma de abrir arquivos que não possuem comprimento fixo.
Lição 15 – O Laço Implícito do Passo DATA (Built-in Loop)
Você deve ter notado que, no exemplo anterior, não foi preciso programar nenhum
tipo de laço dentro do passo DATA para percorrer o arquivo texto e importar o seu
conteúdo para um data set SAS. Isto ocorre porque o passo DATA funciona baseado em
um laço implícito (built-in loop), ou seja, o loop que é executado de forma automática.
Esta é uma característica bastante inusitada, porém extremamente interessante da
Linguagem SAS, pois ela contribui decisivamente para que o código de um programa SAS
seja mais simples e curto do que o código produzido em outras linguagens. De agora em
diante, é importantíssimo que você memorize a regra apresentada na página a seguir:
Todos os comandos de um passo DATA são executados para

cada observação do arquivo de entrada.
Para que este conceito fique mais claro, observe o esquema apresentado na Figura
3.2 [Slaughter e Delwiche 2003]. Ela mostra como uma observação lida de um arquivo de
entrada é tratada dentro de um passo DATA.
24
Figura 3.2 – O laço implícito do passo DATA
O SAS lê a primeira observação do arquivo de entrada e processa esta observação

usando o primeiro comando do passo DATA. Depois processa a observação usando o
segundo comando, o terceiro, até processar contra o último comando. Nesse momento, a
observação é copiada para o data set de saída. Uma vez que o SAS termine de processar a
primeira observação o controle do programa é retornado automaticamente ao início do
passo DATA, para que a segunda observação seja processada da mesma forma. Quando a
última observação é processada, o laço termina de forma automática e o controle do
programa passa para o passo seguinte (que pode ser outro passo DATA ou um passo
PROC).
Lição 16 – Leitura de Arquivos com Caractere Delimitador
Para fazer a leitura de arquivos que utilizam caracteres delimitadores para a

separação das variáveis, utilizam-se os parâmetros DLM e DSD do comando INFILE. O
primeiro parâmetro serve para especificar o delimitador; já o parâmetro DSD é colocado no
INFILE para que o SAS possa tratar valores nulos (ex: duas vírgulas consecutivas em um
arquivo CSV).
O programa mostrado na página seguinte demonstra a leitura do arquivo
apresentado na Figura 3.3. Observe que é um arquivo CSV (separado por vírgula), que
contém informações sobre o CEP de municípios do estado do Rio de Janeiro.
23900000,23959999,3300100,ANGRA DOS REIS

28495000,28495000,3300159,APERIBÉ
28970000,28970000,3300209,ARARUAMA
...
Figura 3.3 – Observações iniciais do arquivo CSV de faixa de CEPs
DATA CEP;
INFILE '\\CursoSAS\CEP_RJ.CSV' DLM=',' DSD;
INPUT CEP_INICIAL CEP_FINAL COD_MUNIC NOME_MUNIC $;
RUN;
25
Após a importação você perceberá que o data set gerado possui um problema na
variável NOME_MUNIC. Todos os nomes são gerados com o comprimento fixo de 8
caracteres (Figura 3.4).
Figura 3.4 – Nomes truncados em 8 caracteres.
Esta situação ocorre porque o SAS, por default considera que o tamanho de uma
variável caractere é igual a 8. Para que o problema possa ser resolvido é preciso utilizar o
comando LENGTH para declarar a variável “grande” antes do INPUT.
DATA CEP;
INFILE '\\CursoSAS\CEP_RJ.CSV' DLM=',' DSD;
LENGTH NOME_MUN $ 50;
INPUT CEP_INICIAL CEP_FINAL COD_MUNIC NOME_MUNIC $;
RUN;
IMPORTANTE: o comando LENGTH voltará a ser abordado no Capítulo IV.
A Figura 3.5 ilustra o resultado da execução do programa, após a alteração.
Figura 3.5 – Nomes corretos.
26
Lição 17 – Mais Opções para Leitura de Arquivos
Leitura de Arquivos Delimitados por Tabulação

Neste caso, usa-se a opção DLM = ‘09’x (especificação do valor hexadecimal do
código ASCII para o caractere TAB).
DATA UFS;
INFILE '\\CursoSAS\ARQ_TAB.TXT' DLM='09'x DSD;
LENGTH UF $ 30;
INPUT SIGLA $ UF $;
RUN;
Leitura de Arquivos Delimitados por Espaço

Para este tipo de arquivo, não é preciso especificar nenhum parâmetro no INFILE
DATA NUMEROS;
INFILE '\\CursoSAS\ARQ_ESP.TXT';
INPUT N1 N2 N3;
RUN;
FIRSTOBS
Começa a leitura do arquivo a partir de uma linha específica.
DATA UFS;
INFILE '\\CursoSAS\ARQ_TAB.TXT' DLM='09'x DSD FIRSTOBS=5;
LENGTH UF $ 30;
INPUT SIGLA $ UF $;
RUN;
TRUNCOVER
A tentativa de ler um campo com tamanho que exceda o comprimento de uma
observação poderá fazer com que o SAS faça a leitura de forma errada. A opção
TRUNCOVER é usada para resolver este problema. Ela é especialmente útil quando se
deseja realizar a leitura de um arquivo separado por colunas que não possui comprimento
fixo.
DATA NATUREZA;
INFILE '\\CursoSAS\NJUR_NOTFIX.TXT' TRUNCOVER;
INPUT
@1 CODIGO 4.
RUN;
LRECL
No ambiente Windows, o SAS assume que as linhas de um arquivo têm um
comprimento máximo de 256 caracteres. Caso seja preciso abrir um arquivo de entrada com
comprimento maior, é preciso usar a opção LRECL do comando INFILE. O exemplo a
27
seguir mostra a forma de utilizar a opção para ler o arquivo COMPRIDO.TXT, da Figura
3.6, que possui comprimento de 260 caracteres.
Figura 3.6 – Arquivo “COMPRIDO.TXT” - comprimento de 260 caracteres
DATA COMPRIDO;
INFILE '\\CursoSAS\COMPRIDO.TXT' LRECL=260;
INPUT
@01 CODIGO 1.
RUN;
No exemplo acima, o arquivo COMPRIDO.TXT possui comprimento de 260

caracteres (sem contar os dois caracteres que marcam o fim de linha no Windows).
IMPORTANTE: no ambiente Windows, a opção LRECL precisa ser usada para garantir a correta
leitura de arquivos com observações de comprimento superior a 256 caracteres.
INFORMATS: PD e ZD
Os INFORMATS são utilizados no comando INPUT para permitir a leitura de
dados em um formato que não seja padrão, como por exemplo números representados nos
formatos decimal compactado, decimal zonado, binário ou hexadecimal. Os dois primeiros
formatos costumam ser utilizados em ambiente mainframe5. A Tabela 3.1 apresenta indica
a sua forma de utilização.
Tabela 3.1 – INFORMATs

INFORMAT Função Exemplo
PD Leitura de números representados no formato INPUT X PD5.
decimal compactado (packed decimaI).
ZD Leitura de números representados no formato INPUT Y ZD5.
decimal zonado (zoned decimaI).
Para maiores detalhes consulte http://publib.boulder.ibm.com/iseries/v5r2/ic2924/books/c092508302.htm
28
Lição 18 – FILE e PUT: Comandos para Gravação de
Arquivos Texto
Dentro de um passo DATA é possível gravar arquivos texto utilizando os comandos

FILE (para especificar o caminho do arquivo de saída) e PUT (para especificar as variáveis
que farão parte do arquivo).
No ambiente WINDOWS, existe um detalhe importantíssimo: o arquivo de saída
só pode ser gravado em um compartilhamento onde o usuário da sessão possua direito
de escrita. Só assim o servidor SAS conseguirá realizar a gravação.
Para entender a forma como o SAS grava arquivos, digite e execute o programa
abaixo. Antes você deverá criar um compartilhamento com direito de gravação para a sua
conta e substituir, no código, o trecho \\compartilhamento pelo nome do
compartilhamento que você criou.
* Programa 3.2 -> gravação de arquivo texto;

* cria o Data Set PAISES;
DATA PAISES;
INPUT NOME $ POPULACAO;
CARDS;
BRASIL 191790900
URUGUAI 3339701
CHILE 16634758
;
RUN;
* grava o conteúdo do Data Set PAISES em um arquivo texto
DATA _NULL_;
SET PAISES;
FILE '\\compartilhamento\SAIDA.TXT';
PUT
@001 NOME $CHAR7.
POPULACAO 10.
;
RUN;
No programa acima, o segundo passo DATA (linhas 13-19) transfere o conteúdo do

data set PAISES para o arquivo texto ‘SAIDA.TXT’. Veja que, na linha 13, a palavra
_NULL_ aparece ao invés do nome de um data set. Este é um recurso disponibilizado pelo
SAS para que o programador possa executar um passo DATA sem gerar um data set de
saída. Com isto, é possível economizar tempo de processamento. O comando SET (linha
14) simplesmente solicita com o que o SAS leia o data set PAISES. A seguir, o comando
FILE instrui o SAS a criar um arquivo para saída. O comando PUT informa o que será
gravado e aonde.
ATENÇÃO: não se esqueça que o comando PUT também é usado para escrever mensagens no
log.
29
IV. Transformação de Dados
Variáveis podem ser trabalhadas e transformadas dentro de um passo DATA antes
de terem o seu conteúdo gravado em um data set ou arquivo de saída. Este Capítulo
demonstra como operações deste tipo podem ser realizadas com a aplicação das instruções
de desvio condicional (IF-THEN-ELSE e SELECT) e das funções reservadas da
Linguagem SAS. O capítulo também um conceito muito importante associado à Linguagem
SAS: o Program Data Vector.
Lição 19 – Criação de Variáveis
Em um programa SAS, a declaração de variáveis pode ser realizada em qualquer

linha de um passo DATA. O tipo da variável será automaticamente estabelecido como o
tipo de valor que for atribuído à variável. Para demonstrar este conceito, considere o
arquivo apresentado abaixo (Figura 4.1), que contém as matrículas de quatro alunos e as
notas obtidas em duas provas.
M0012008 9.8 9.5

M0022008 5.3 4.1
M0032008 2.5 8.0
M0042008 7.5 7.5
Figura 4.1 – Arquivo com Matrículas e Notas (NOTAS.TXT)
O programa a seguir, processa o arquivo de notas e cria novas variáveis.
DATA MEDIAS;
INFILE '\\CursoSAS\NOTAS.TXT';
INPUT MATRICULA $ 1-8 NOTA1 NOTA2;
* CALCULA A MÉDIA;
MEDIA = (NOTA1 + NOTA2) / 2;
* MÉDIA PONDERADA (PESO 2 NA SEGUNDA PROVA);

MEDIA_POND = (NOTA1 + NOTA2 * 2) / 3;
* E-MAIL DO ALUNO - EXEMPLO DE CONCATENAÇÃO DE STRING;

E_MAIL = MATRICULA || '@ibge.gov.br';
RUN;
IMPORTANTE: neste exemplo o programador não foi obrigado a declarar as variáveis e seus tipos
no início do passo DATA. No entanto, na lição 25 será apresentado um exemplo de situação
prática onde isto é necessário.
A Tabela 4.1 resume a lista de operadores aritméticos e de string do SAS:
30
Tabela 4.1 – Operadores Aritméticos e de String
Operador Função
+, -, /, * Adição, Subtração, Divisão e Multiplicação
** Exponenciação
|| Concatenação de Strings
Lição 20 – Instruções de Desvio (1): IF-THEN-ELSE
Na programação SAS, as instruções de desvio IF-THEN-ELSE são principalmente

empregadas para a criação e transformação de variáveis. A seguir, apresentam-se diversos
exemplos de sintaxe para a utilização destas instruções.
IF com apenas um comando subordinado
Basta utilizar uma linha de comando:
IF condição THEN comando1;
IF com mais de um comando subordinado
Neste caso é preciso envolver os comandos subordinados entre as palavras DO e END;
IF condição THEN DO;

comando1;
comando2;
...
comandon;
END;
ATENÇÃO: a sintaxe requer o uso de ponto-e-vírgula após as palavras DO e END.
IF / ELSE IF / ELSE
Condições podem ser logicamente agrupadas com o uso dos comandos ELSE IF e
ELSE.
IF condição1 THEN comando1;

ELSE IF condição2 THEN comando2;
ELSE IF condição3 THEN comando3;
ELSE comando4;
O programa a seguir, processa novamente arquivo de notas e cria novas variáveis

com o uso das instruções de desvio.
31
DATA MEDIAS;
* CALCULA A MÉDIA;
/*
VERIFICA SE ALUNO FOI APROVADO
ELE SERÁ APROVADO SE A MÉDIA FOR MAIOR OU IGUAL A 6
OU SE TIVER MÉDIA MAIOR OU IGUAL A 4
E MÉDIA PONDERADA MAIOR OU IGUAL A 6
*/
IF MEDIA >= 6.0 THEN

SITUACAO = 'APR';
ELSE IF MEDIA >= 4.0 THEN DO;
MEDIA_POND = (NOTA1 + NOTA2 * 2) / 3;
IF MEDIA_POND >= 6.0 THEN
SITUACAO = 'APR';
ELSE
SITUACAO = 'REP';
END;
ELSE SITUACAO = 'REP';
RUN;
Lição 21 – Operadores Lógicos e Relacionais
Os operadores relacionais podem especificados em uma instrução de desvio

através de duas formas: com o uso de símbolos ou mnemônicos. A Tabela 4.2 apresenta
estes operadores.
Tabela 4.2 – Operadores Relacionais

Símbolo Mnemônico Significado
= EQ Igual
^=, ~= ou ¬= NE Diferente
> GT Maior
< LT Menor
>= GE Maior ou igual
<= LE Menor ou igual
IN Pesquisa em um conjunto de valores
O operador IN é o único que não possui um símbolo.
De maneira análoga, os operadores lógicos também podem ser representados por

símbolos ou mnemônicos (Tabela 4.3).
Tabela 4.3 – Operadores Lógicos

Símbolo Mnemônico Significado
& AND Operador E
| ou ! OR Operador OU
^, ~ ou ¬ NOT Operador NÃO
32
Lição 22 –Operação de Data Subsetting
Considere que você deseje criar um data set SAS que contenha apenas um
subconjunto de observações de um arquivo de entrada. Por exemplo: apenas os alunos com
média acima de 6.0. Este processo é conhecido no mundo SAS como “subsetting”. Ele
também é realizado com a utilização da instrução IF, conforme mostra o programa a seguir:
DATA APROVADOS;
* CALCULA A MÉDIA;
* GRAVA NO DATA SET "APROVADOS" APENAS QUEM TIVER A MÉDIA MÍNIMA;
IF MEDIA >= 6.0;
RUN;
Observe que o data set aprovados conterá apenas dois registros, com os dados dos
dois alunos que obtiveram a média superior à 6.0.
A sintaxe do comando para subsetting é (mais uma!) que a princípio parece bastante
esquisita. Afinal, qualquer programador que não conhece SAS observaria este programa e
pensaria: “se a média for maior ou igual a 6.0 então o quê??? Será que este IF não está
incompleto?!”. Porém, basta entender o funcionamento deste tipo de comando para que
você passe a achar o seu uso muito interessante. Afinal de contas, é mais um exemplo de
sintaxe que ajuda a tornar os programas SAS muito econômicos!
IF condição;
Funcionamento:
se a expressão for VERDADEIRA o SAS continua normalmente com o passo DATA.
se for FALSA:
(i) nenhum outro comando será executado para aquela observação;

(ii) a observação não será adicionada ao data set que está sendo criado;
(iii) o SAS passará para a próxima observação
O comando DELETE também pode ser usado na operação de subsetting. Enquanto o

IF sozinho indica observações a serem incluídas, o DELETE serve para indicar as
observações a serem excluídas. Veja o exemplo a seguir:
DATA APROVADOS;
33
* CALCULA A MÉDIA;
* EXCLUI DO DATA SET "APROVADOS" APENAS QUEM TIVER A MÉDIA MÍNIMA;
IF MEDIA < 6.0 THEN DELETE;
RUN;
Em resumo, as duas instruções são equivalentes:
IF MEDIA >= 6.0;

IF MEDIA < 6.0 THEN DELETE;
Lição 23 –Data Set Options
As data set options permitem com que o programador possa especificar ações
específicas enquanto um data set está sendo lido ou criado [Johnson 2003]. Elas são
especificadas entre parêntesis após o nome do data set.
KEEP
A opção KEEP é utilizada para permitir com que seja indicada a lista de variáveis
que serão gravadas no data set de saída. Se uma variável não estiver na lista ela não será
levada para o data set de saída.
*o data set de saída conterá apenas as variáveis MATRICULA e MEDIA;

DATA MEDIAS_FINAIS (KEEP = MATRICULA MEDIA);
* CALCULA A MÉDIA;
RUN;
O programa solicita a criação de um data set denominado MEDIAS_FINAIS que

conterá apenas duas variáveis MATRICULA e MEDIA. As variáveis NOTA1 e NOTA2
desta vez não farão parte do data set gerado no passo DATA. A sintaxe da opção KEEP é
apresentada a seguir:
DATA nome_do_dataset (KEEP = lista de variáveis mantidas);
A opção KEEP deve ser colocada entre parêntesis, seguida do sinal de igualdade. A
relação de variáveis a serem mantidas deve ser especificada utilizando um espaço em
branco como separador.
DROP
A opção DROP é utilizada com o mesmo propósito do KEEP. A diferença é que a
lista associada a essa opção indica as variáveis que não serão gravadas no data set de saída.
34
DATA MEDIAS_FINAIS (DROP = NOTA1 NOTA2);
* CALCULA A MÉDIA;
RUN;
A sintaxe da opção DROP é apresentada a seguir:
DATA nome_do_dataset (DROP = lista de variáveis excluídas);
WHERE
A opção WHERE é utilizada com o objetivo de realizar a operação de subsetting
(exclusão de observações). Uma observação será gravada no data set de saída apenas
quando a condição especificada na cláusula WHERE for verdadeira. No exemplo a seguir,
o data set APROVADOS conterá apenas as matrículas e médias finais dos alunos
aprovados. Observe que foi possível combinar as opções KEEP e WHERE.
*o data set de saída conterá apenas os alunos aprovados;

DATA aprovados (KEEP = MATRICULA MEDIA
WHERE = (MEDIA >= 6.0));
* CALCULA A MÉDIA;
RUN;
RENAME
A opção RENAME pode ser utilizada para que mudar o nome de uma variável no
data set de saída. A mudança de nome ocorre apenas no momento em que a observação
está sendo gravada. Por este motivo, o programa deve referenciar os nomes antigos das
variáveis dentro do passo DATA.
*a variável MEDIA será renomeada para MEDIA_FINAL no data set de saída;

DATA aprovados (KEEP = MATRICULA MEDIA
RENAME = (MEDIA = MEDIA_FINAL));
* CALCULA A MÉDIA;
* EXCLUI OS REPROVADOS;
IF MEDIA >= 6.0;
RUN;
35
Lição 24 – Funções do SAS
A Linguagem SAS possui mais de 400 funções [Slaugther e Delwiche 2003] de

diferentes tipos, tais como funções estatísticas, para manipulação de strings, para
manipulação de valores do tipo data/hora, funções para números aleatórios, financeiras, etc.
O exemplo a seguir mostra a utilização da função substr em um programa que
cria um data set contendo as naturezas jurídicas que são utilizadas na classificação de
empresas públicas (todas cujo código começa com ‘1’).
DATA NATJUR_PUB;
INFILE '\\CursoSAS\NJUR.TXT' LRECL=260;
INPUT
@1 CODIGO 4.
IF substr(CODIGO,1,1) = '1';
RUN;
A Tabela 4.4 lista a definição e a sintaxe de algumas das principais funções do SAS.
Tabela 4.4 – Algumas Funções do SAS

Funções Numéricas
Função Significado Exemplo
SQRT Raiz quadrada X = sqrt(N);
INT Retorna a porção inteira de um X = int(9.8); *retorna 9;
número. X = int(5.1); *retorna 5;
ROUND Arredondamento. X = round(9.8); *retorna 10;
X = round(5.1); *retorna 5;
MAX Maior valor entre N números. X = max(10, 20, 3, 5);
*retorna 20;
MIN Menor valor entre N números. X = min(10, 20, 3, 5);
*retorna 3;
MEAN Média aritmética de N X = mean(9.2, 9.8);
números. *retorna 9.5;
SUM Soma de N números. X = sum(2,5,8);
*retorna 15;
MOD Resto da divisão entre dois X = mod(10,3);
números. Utilize em conjunto *retorna 1.0000;
com a função INT se você X = int(mod(10,3));
desejar um resultado inteiro. *retorna 1;
Funções para Manipulação de Strings
Função Significado Exemplo
LENGTH Tamanho da string. X = length('SAS');
*retorna 3;
36
TRIM Remove os brancos. X = length(' SAS ');
*retorna 'SAS';
SUBSTR Obtém uma substring a partir X = substr('BRASÍLIA',6,3);
de uma string. *retorna 'LIA';
UPCASE Converte uma string para X = upcase('brasília');
maiúsculo. *retorna 'BRASÍLIA';
LOWCASE Converte uma string para X = upcase('BRASÍLIA');
minúsculo. *retorna 'brasília';
As funções put e input (não confundir com os comandos de mesmo nome)

merecem um destaque especial.
DATA CONVERSAO;
ANO_STR = '2008'; *variável string;
X_NUM = 1; *variável numérica;
*ANO_NUM: valor de ANO_STR convertido para number de 4 posições;

ANO_NUM = input(ANO_STR, 4.);
*X_STR: valor de X_NUM convertido para string de 1 posição;

X_STR = put(X_NUM,1.);
*X_STR2: valor de X_NUM convertido para string de 4 posições;

* a máscara “z4.” Faz com que a string seja;
* completada com zeros à esquerda;
X_STR2 = put(X_NUM,z4.);
RUN;
A função input recebe como entrada uma variável caractere e retorna o seu valor
convertido para numérico. É preciso especificar no segundo argumento da função o número
de posições desejadas para o valor convertido.
A função put faz o contrário: recebe um número e converte para caractere.
Também é preciso especificar no segundo argumento o tamanho do valor de saída.
Lição 25 – RETAIN
Durante a execução do loop implícito do passo DATA, o SAS atribui o valor

missing para todas as variáveis no início de cada iteração. Estes valores podem até ser
modificados com o uso do comando INPUT ou através de comandos de atribuição, mas
ficarão novamente com o valor missing no início da iteração seguinte. Para melhor
compreender esta característica curiosa do passo DATA, considere o seguinte exemplo:
DATA SEM_RETAIN;
CONTADOR = 0; *DECLARA “CONTADOR” E INICIALIZA COM ZERO;
CONTADOR = CONTADOR + 1;
RUN;
37
Veja que, no programa, a variável CONTADOR foi declarada no início do passo
DATA, recebendo o valor zero (assim o seu tipo foi automaticamente estabelecido como
numérico). Na última linha do passo DATA, incrementa-se à variável em uma unidade. No
entanto, isto não é suficiente para que as mudanças no valor de CONTADOR sejam
acumuladas entre os diferentes passos, conforme mostra a Figura 4.2.
Figura 4.2 – A variável CONTADOR não muda de valor durante as iterações
O comando RETAIN pode ser utilizado para modificar este comportamento. Se uma
variável for declarada com o uso deste comando, seu valor ao final de uma iteração será
levado para a iteração seguinte. O programa a seguir demonstra o uso do RETAIN. A
Figura 4.3 mostra o data set produzido após a execução do programa.
DATA COM_RETAIN;
*DECLARA "CONTADOR" INICIANDO COM ZERO E USANDO O RETAIN;
RETAIN CONTADOR 0;
CONTADOR = CONTADOR + 1;
RUN;
Figura 4.3 – Data set produzido com o uso do comando RETAIN
IMPORTANTE: no exemplo, o comando RETAIN foi utilizado na primeira linha do passo DATA e a
variável declarada possuía um valor inicial especificado. No entanto, o SAS permite com que o
RETAIN seja utilizado em qualquer linha e também não requer a especificação de um valor inicial.
Lição 26 – LENGTH
O comando LENGTH - que já foi apresentado na Lição 16 - serve para especificar o

comprimento de uma variável caractere no momento de sua declaração. Este comando será
revisto agora, por ser o comando requerido para impedir com que variáveis declaradas
com o uso dos comandos IF-THEN-ELSE contenham valores truncados.
38
Se você criar uma variável através de um comando de atribuição, o comprimento da
variável será determinado pelo valor da primeira ocorrência dela. Considere o seguinte
exemplo, que utiliza a base de dados TEMPERATURAS.TXT (Figura 4.4), que contém 5
datas e a temperatura máxima registrada em cada uma dessas datas.
01/04/2008 12
02/04/2008 28
03/04/2008 25
04/04/2008 32
05/04/2008 39
Figura 4.4 – TEMPERATURAS.TXT
Considere o seguinte programa, que cria a variável derivada CLASSE baseada em

diferentes faixas de valores de temperatura.
DATA TEMPERATURAS;
INFILE '\\CursoSAS\TEMPERATURAS.TXT';
INPUT DATA $ 1-10 GRAUS_C;
IF GRAUS_C <= 20 THEN
CLASSE = 'FRIO';
ELSE IF GRAUS_C > 20 AND GRAUS_C <= 29 THEN
CLASSE = 'AGRADAVEL';
CLASSE = 'CALOR';
ELSE
CLASSE = 'CALOR SENEGALÊS';
RUN;
A variável CLASSE recebe o valor ‘FRIO’ durante o processamento da primeira

observação. Como esta palavra possui 4 letras, o SAS atribui comprimento 4 para
CLASSE. Qualquer outro valor para esta variável, que seja atribuído em uma iteração
posterior do passo DATA, será truncado em 4 caracteres, conforme mostra a Figura 4.5.
Figura 4.5 – Variável CLASSE com valores truncados
Para resolver este problema, basta declarar explicitamente a variável CLASSE e

utilizar o comando LENGTH para estabelecer o comprimento desta variável. Isto é feito no
programa a seguir. O resultado final é mostrado na Figura 4.6.
DATA TEMPERATURAS;
39
LENGTH CLASSE $ 15; *DECLARA CLASSE COMO STRING DE 15 POSIÇÕES;
IF GRAUS_C <= 20 THEN

CLASSE = 'FRIO';
CLASSE = 'AGRADAVEL';
CLASSE = 'CALOR';
ELSE
CLASSE = 'CALOR SENEGALÊS';
RUN;
Figura 4.6 – Variável CLASSE sem valores truncados
Lição 27 – Instruções de Desvio (2): SELECT-WHEN
A estrutura SELECT-WHEN é uma estrutura de desvio utilizada para executar

diferentes grupos de comandos em função do valor de uma expressão. É similar ao case da
Linguagem Pascal ou o switch da Linguagem C, porém mais flexível. A sintaxe do
comando é apresentada a seguir:
SELECT <(variável)>;
WHEN1 (expressão1)
comandos1;
WHENn (expressãon)
comandosn;
OTHERWISE
comandoso;
END;
Essa instrução funciona da seguinte maneira. A expressão associada ao primeiro

WHEN é avaliada. Se a avaliação resultar em VERDADEIRO, o programa executa os
comandos subordinados a este WHEN e depois “sai do SELECT” (o fluxo do programa é
desviado para a instrução localizada imediatamente após o END do SELECT). Se a
avaliação do primeiro WHEN resultar em FALSO, então a expressão associada ao segundo
WHEN será avaliada. Se a avaliação for VERDADEIRO, executam-se os comandos
associados ao segundo WHEN e o fluxo de execução “sai do SELECT”. E da mesma
maneira são avaliados todos os WHENs. A seguir um exemplo simples de uso da estrutura
SELECT.
40
DATA UFS;
INFILE '\\CursoSAS\ARQ_TAB.TXT' DLM='09'x DSD;
LENGTH UF $ 30 REGIAO $ 12;
INPUT SIGLA $ UF $;
SELECT (SIGLA);
WHEN ('RJ','SP','MG','ES') REGIAO = 'SUDESTE';
WHEN ('RS','SC','PR') REGIAO = 'SUL';
WHEN ('GO','MS','MT','DF') REGIAO = 'CENTRO-OESTE';
WHEN ('RO','AC','AM','RR','PA','AP','TO') REGIAO = 'NORTE';
WHEN ('MA','PI','CE','RN','PB','PE','AL','SE','BA') REGIAO = 'NORDESTE';
OTHERWISE REGIAO = 'N/A';
END;
RUN;
É possível montar a estrutura SELECT-WHEN sem associar uma variável ao
SELECT. O exemplo a seguir demonstra esta característica. Trata-se do programa para
obtenção de classes de temperaturas (apresentado na Lição 26), agora modificado para
utilizar a estrutura SELECT-WHEN.
DATA TEMPERATURAS;
LENGTH CLASSE $ 15; *DECLARA CLASSE COMO STRING DE 15 POSIÇÕES;
SELECT;
WHEN (GRAUS_C <= 20) CLASSE = 'FRIO';
WHEN (GRAUS_C > 20 AND GRAUS_C <=29) CLASSE = 'AGRADÁVEL';
WHEN (GRAUS_C > 29 AND GRAUS_C <=34) CLASSE = 'CALOR';
OTHERWISE CLASSE = 'CALOR SENEGALÊS';
END;
RUN;
Por fim, o próximo exemplo demonstra que é possível montar expressões compostas
por condições e variáveis distintas na cláusula WHEN. O exemplo também descreve o fluxo
de execução da estrutura SELECT-WHEN.
DATA EXEMPLO_2;
SALARIO=500; FILHOS=3;
SELECT;
WHEN (SALARIO <= 600 AND FILHOS > 1 ) SAL_FAMILIA= SALARIO * 0.20;
WHEN (FILHOS > 2) SAL_FAMILIA = SALARIO * 0.05;
OTHERWISE SAL_FAMILIA=0;
END;
RUN;
As variáveis SALARIO e FILHOS são avaliadas contra o primeiro WHEN. Note que o
resultado da avaliação é VERDADEIRO e, por isso, a instrução SAL_FAMILIA= SALARIO *
0.20 é executada. A seguir o controle do programa é automaticamente passado para o
primeiro comando depois do END; do SELECT (melhor explicando: o SELECT é
encerrado). Por esta razão a expressão WHEN (FILHOS > 2) não é avaliada pelo programa
exemplo.
41
Lição 28 – Comando OUTPUT
Normalmente o SAS adiciona uma observação ao data set de saída no final de cada
iteração do loop implícito do passo DATA. No entanto, é possível mudar este
comportamento com o uso do comando OUTPUT. Digite e execute o programa abaixo.
DATA ExemploOutput;
X=1; Y=2; Z = X * Y;
OUTPUT;
X=2; Y=2; Z = X * Y;
OUTPUT;
X=2; Y=3; Z = X * Y; K=1000;

OUTPUT;
RUN;
Como resultado da execução, será criado um data set com 3 observações. Cada
observação conterá valores diferentes para as variáveis X, Y, Z e K, que correspondem aos
valores armazenados nestas variáveis no momento anterior à execução do comando
OUTPUT. Note que o valor de K será missing nas duas primeiras observações.
Lição 29 – Valores Lógicos
Embora a Linguagem SAS não possua um tipo lógico (booleano), o tipo numérico
pode ser utilizado para representar valores VERDADEIRO ou FALSO. Quando uma
condição é avaliada por comandos como IF e WHILE o valor 0 (zero) é tratado como o
valor lógico FALSO e qualquer outro valor diferente de zero é tratado como
VERDADEIRO. Veja o exemplo a seguir. Ao final da execução as variáveis MSG1 e
MSG3 conterão o valor ‘ENTROU NESSE IF’, enquanto MSG2 permanecerá com o
conteúdo missing.
DATA LOGICO;
X=1; Y=0; Z=-999;
LENGTH MSG1 $ 30 MSG2 $ 30 MSG3 $ 30;
IF (X) THEN MSG1='ENTROU NESSE IF';
IF (Y) THEN MSG2='NÃO ENTROU NESSE IF';
IF (Z) THEN MSG3='ENTROU NESSE IF';

RUN;
42
Lição 30 – Valores do Tipo Data (Date)
Uma variável do tipo DATE no SAS corresponde, internamente, a uma variável

numérica que contém o valor inteiro equivalente a o número de dias passados desde
01/01/19606. A faixa de valores que podem ser manipulados vai de 01/01/1582 (valor
inteiro –138.061) até 31/12/20000 (valor inteiro 6.589.335). O valor 0 (zero) corresponde a
01/01/1960.
O SAS possui três recursos principais para a manipulação de datas: (a)
INFORMATS especiais para a leitura de datas; (b) funções para operações com datas
(exemplo: subtração de datas, obtenção do dia da semana, etc) e (c) formatos (FORMATS)
especiais para a impressão de datas.
O primeiro exemplo desta lição apresenta a maneira pela qual um valor pode ser
lido de um arquivo texto e interpretado como uma data pelo SAS.
DATA ExemploData1;
INPUT
@001 DIA DDMMYY10.
@012 GRAUS_C 2.;
RUN;
PROC PRINT DATA = ExemploData1;

FORMAT DIA DDMMYY10.;
TITLE 'Meu primeiro exemplo com Datas';
RUN;
No programa acima, o passo DATA gera um data set chamado ExemploData1 a

partir do arquivo TEMPERATURAS.TXT (cuja estrutura foi apresentada na Figura 4.4). A
variável DIA é importada com o INFORMAT DDMMYY10 que representa uma data no
formato “dia/mês/ano” com 10 caracteres (dois para dia, dois para mês, quatro para ano e
mais duas barrinhas). A Figura 4.7 mostra que a variável DIA é estruturada como uma
variável numérica no data set. Quando se efetua o duplo-clique em ExemploData1, o que é
visto é um número e não uma data.
Figura 4.7 – A variável DIA foi importada com um INFORMAT de data, mas é armazenada como numérica
A seguir, o passo PROC gera um relatório HTML com o conteúdo de

ExemploData1. Neste passo, o comando FORMAT DIA DDMMYY10.; é usado para
especificar o formato de saída do tipo DATE com a máscara “dd/mm/aaaa” para a variável
DIA. Como resultado, o relatório HTML produzido fica com o formato apresentado na
Figura 4.8. Veja que nesta PROC também houve a configuração do parâmetro TITLE para
que fosse gerado um título customizado para o relatório.
6
O motivo da escolha desta data não foi encontrado em nenhuma das referências consultadas para a
elaboração desta apostila.
43
Figura 4.8 – Impressão da Variável DIA com o Formato “DD/MM/AAAA”
Uma relação abrangente de INFORMATS para a leitura de datas pode ser obtida em
[Slaughter e Delwiche 2003].
IMPORTANTE: em muitas situações práticas, você precisará ler uma variável do tipo data a partir
de um arquivo texto, mas na precisará realizar nenhum tipo de operação com esta variável. Neste
caso não existe qualquer problema em armazenar o valor desta data em uma variável caratere.
Lição 31 – Valores do Tipo Data/Hora: TIME e DATETIME e

Função DHMS
Na Linguagem SAS, as variáveis do tipo TIME podem ser utilizadas para

manipular informações do tipo hora/minuto/segundo. Este tipo de variável é armazenado
internamente como um valor inteiro que corresponde ao número de segundos passados
desde a meia-noite. Elas podem conter valores decimais para representar frações de
segundo.
Outro tipo de variável que pertence a mesma “família” é o tipo DATETIME. Ele
também é armazenado internamente como valor inteiro. Neste caso o valor armazenado
representa o número de segundos passados desde a meia-noite de 01/01/1960. Valores
positivos representam datas posteriores a este dia e valores negativos representam datas
anteriores. A seguir será apresentado um exemplo de importação de informações no
formato DATETIME a partir do arquivo DATA_HORA.TXT, apresentado na Figura 4.9.
05/09/2007 02:25:45
01/01/2008 00:00:00
15/03/2008 19:30:04
Figura 4.9 – Arquivo “DATA_HORA.TXT”
A idéia é construir um programa capaz de ler o arquivo e armazenar o conteúdo de

cada observação em uma variável do tipo DATETIME. O método apresentado é sugerido
44
em [Holland Numerics 2008]. A idéia é quebrar a informação em duas variáveis. Uma delas
recebe a porções DATE e outra a porção TIME. Em seguida a função DHMS pode ser
utilizada para combinar as duas porções em uma única variável do tipo DATETIME.
DATA ExemploData2;
INFILE '\\CursoSAS\DATA_HORA.TXT';
*PRIMEIRA ETAPA: LÊ PORÇÃO DATA E PORÇÃO HORA EM VARIÁVEIS SEPARADAS;
INPUT
@001 DIA DDMMYY10.
@012 HORA TIME8.;
*SEGUNDA ETAPA: JUNTA AS DUAS PORÇÕES COM O USO DA FUNÇÃO DHMS;

DATA_FINAL = DHMS(DIA,0,0,HORA);
RUN;

FORMAT DATA_FINAL DATETIME.;
TITLE 'Meu segundo exemplo com Datas';
RUN;
Para utilizar a função DHMS com o intuito de unir uma variável DATE e uma
variável TIME em uma variável DATETIME deve ser especificada a seguinte sintaxe:
RESULTADO = DHMS(VAR_DATE,0,0,VAR_TIME);
Existem outras formas de utilização da função DHMS, porém não serão

apresentadas neste curso. Voltando ao programa exemplo, o relatório produzido pelo passo
PROC é apresentado na Figura 4.10.
Figura 4.10 – Impressão da variável DATA_FINAL com o formato “DATETIME”
Lição 32 – Funções para Manipulação de Informações do

Tipo Data/Hora
O programa seguinte apresenta e demonstra a utilização de algumas funções da

Linguagem SAS para a manipulação de variáveis do tipo DATE, TIME e DATETIME.
Também são apresentados exemplos de operações permitidas com datas.
45
DATA ExemploData3;
*Função Today(): retorna a data corrente no servidor SAS;

* o resultado é armazenado como tipo DATE e não DATETIME;
vHoje = Today();
*É possível somar e subtrair dias de uma data;

vOntem = vHoje - 1; *subtrai um dia da data de hoje;
vAmanha = vHoje + 1; *soma um dia da data de hoje;
*Também podemos extrair o dia, mês e ano de uma variável DATE;

*usando as funções Day, Month e Year, respectivamente;
vDia = Day(vHoje);
vMes = Month(vHoje);
vAno = Year(vHoje);
*Função DateTime(): retorna a data/hora corrente no servidor SAS;

vAgora = DateTime();
*Função DatePart(): retorna a porção DATE de uma variável DATETIME;

*Função TimePart(): retorna a porção TIME de uma variável DATETIME;
vPorcaoData = DatePart(vAgora);
vPorcaoHora = TimePart(vAgora);
*Também é possível extrair as horas, minutos e segundos;

* de uma variável TIME, usando as funções Hour, Minute e Second;
vHora = Hour(vPorcaoHora);
vMinutos = Minute(vPorcaoHora);
vSegundos = Second(vPorcaoHora);
RUN;

FORMAT vHoje DDMMYY10.
vOntem DDMMYY10. vAmanha DDMMYY10.
vDia 2. vMes 2. vAno 4.
vAgora DATETIME.
vPorcaoData DDMMYY10.
vPorcaoHora TIME8.
;
TITLE 'Meu terceiro exemplo com Datas';
RUN;
A seguir um programa que exemplifica a utilização de duas funções que trabalham

com o intervalo entre datas: DATDIF e INTCK.
DATA ExemploData4;
*declara e inicializa duas variáveis do tipo DATE;
d1 = '01jan2007'd;
d2 = '15jan2008'd;
*função DATDIF: retorna o número de dias contidos entre duas datas;

*parâmetros: 'actual' -> considera o número de dias real de cada
mês;
* '30' -> considera que cada mês possui 30 dias;
d3 = DATDIF(d1,d2,'actual');
d4 = DATDIF(d1,d2,'30');
46
*função INTCK: permite a especificação de uma unidade de medida;
* para o intervalo a ser calculado;
d5 = INTCK('DAY ',d1,d2); *número de dias entre d1 e d2;
d6 = INTCK('WEEK ',d1,d2); *número de semanas entre d1 e d2;
d7 = INTCK('MONTH ',d1,d2); *número de meses entre d1 e d2;
RUN;
Maiores detalhes sobre as funções para manipulação de informações do tipo DATE,

TIME e DATETIME podem ser obtidos em [TS-668 ] e [Holland Numerics 2008].
Lição 33 – Estruturas de Repetição (1): DO-WHILE
Muitas vezes se torna necessário programar algum tipo de estrutura de repetição

dentro do passo DATA para que seja possível montar o data set adequado ao problema que
queremos resolver. Considere, por exemplo, o seguinte problema. Imagine que a partir do
arquivo de entrada NUMEROS.TXT (Figura 4.11), deseja-se criar um data set com duas
variáveis: o número contido no arquivo e um indicador que informe se este número é um
número primo ou não.
10
2
13
100
9
41
1000
1013
500
7
Figura 4.11 – Arquivo “NUMEROS.TXT”
Um algoritmo que pode ser usado para determinar se um número N é primo é

assumir a hipótese de que ele é primo e depois tentar quebrar esta hipótese, montando um
laço que realize a divisão de N por todos os números contidos entre 2 e N . Se em alguma
iteração do laço o resto da divisão for igual a zero, então descobrimos que N não é primo. A
resolução deste problema pode ser implementada na Linguagem SAS com o uso da
estrutura de repetição DO-WHILE.
DATA PRIMOS (KEEP=N PRIMO);

* leitura dos números;
INFILE '\\CursoSAS\NUMEROS.TXT';
INPUT N;
* rotina que determina se o número é primo;

PRIMO = 'SIM'; *parto da hipótese de que é primo;
I = 2;
RAIZ = Round(Sqrt(N));
DO WHILE (I <= RAIZ);
IF INT(MOD(N,I)) = 0 THEN DO; *se o resto deu zero não é primo;
47
PRIMO = 'NÃO';
LEAVE; *quebra o laço DO-WHILE na marra;
END; *{IF};
I = I + 1;
END; *{WHILE};
RUN;
O programa produz o data set PRIMOS, mostrado na Figura 4.12.
Figura 4.12 – Data Set PRIMOS
Um breve comentário sobre o funcionamento do programa. A opção (KEEP=N

PRIMO) faz com que o data set gerado contenha apenas as variáveis N e PRIMO. As
variáveis auxiliares I e RAIZ não são levadas para o data set.
A estrutura DO-WHILE opera de maneira absolutamente idêntica a de qualquer
outra linguagem de programação. Trata-se de uma estrutura de repetição com teste no
início, que é mantida enquanto a condição especificada ao lado da palavra WHILE for
satisfeita. Em nosso exemplo, o programa “só entra no loop” quando o valor da raiz de N
for maior do que 2 (valor inicial de I). Dentro do laço, I é incrementado em 1 a cada
iteração, até que atinja a condição de saída. A sintaxe da estrutura DO-WHILE é resumida a
seguir:
DO WHILE (condição);
Comando1;
...
Comandon;
END;
Lição 34 – Estruturas de Repetição (2): DO
A implementação de laços com repetição por um número fixo de iterações também

pode ser feita na Linguagem SAS (traduzindo: a mesma coisa que o comando FOR realiza
em outras linguagens)
DATA TABUADA_DE_MULTIPLICACAO;
DO N=1 to 9 by 1;
DO I = 1 to 9 by 1;
NxI = N*I;
OUTPUT;
END;
48
END;
RUN;
Este programa monta um data set que contém a tabuada completa de multiplicação
dos números de 1 a 9. Primeiro é montado um laço externo que varia N (variável de
controle) de 1 a 9. Dentro deste laço existe um outro laço que varia I entre 1 e 9.
Subordinado a este laço interno estão dois comandos. O primeiro cria a variável NxI. O
segundo é o comando OUTPUT para forçar a escrita de uma observação no data set de
saída. A sintaxe da estrutura é descrita a seguir:
DO var_de_controle = valor_inicial TO valor_final <BY incremento>;
O incremento é opcional. Se não for especificado, a variável de controle será

incrementada em 1. Valores negativos podem ser utilizados quando for desejado
decrementar a variável de controle.
Lição 35 – Estruturas de Repetição (3): DO-UNTIL
A estrutura DO-UNTIL executa um grupo de comandos repetidas vezes até que uma
condição especificada seja VERDADEIRA. A condição é checada NO FINAL de cada
iteração do laço.
DATA ExemploUntil;
X = 1;
DO UNTIL(X < 10);
OUTPUT;
X = X + 1;
END;
RUN;
Quando se usa a estrutura DO-UNTIL, o laço é executado pelo menos uma vez, já
que a condição que mantém o laço é testada apenas no final. Por este motivo, o data set
produzido pelo programa acima conterá uma observação. A sintaxe do DO-UNTIL é
apresentada abaixo:
DO UNTIL (condição);
Comando1;
...
Comandon;
END;
OBSERVAÇÃO: infelizmente a sintaxe da estrutura DO-UNTIL não é muito didática. O

funcionamento da estrutura se tornaria muito mais claro se a palavra UNTIL fosse escrita no final
do laço, da maneira que ocorre na Linguagem Pascal e em outras linguagens.
49
Lição 36 – Program Data Vector (PDV)
O Program Data Vector (PDV) é um conceito lógico que existe para auxiliar os
programadores SAS. Ele pode ser imaginado um array em memória que contém todas as
variáveis criadas em um passo DATA. O PDV armazena os dados referentes a uma única
observação de cada vez (ou seja, a observação que está sendo processada na iteração
corrente). É a partir das informações do PDV que os data set são gravados, observação por
observação [Droogendyk 2008], [Johnson 2003].
Além das variáveis criadas no passo DATA, o PDV sempre contém duas variáveis
automáticas: _N_ e _ERROR_. A primeira armazena o número da iteração que está sendo
processada no momento, enquanto a segunda indica se um erro ocorreu durante o
processamento do passo DATA. Para melhor compreender o funcionamento do Program
Data Vector, serão apresentados dois exemplos.
EXEMPLO 1 – FUNCIONAMENTO PADRÃO DO PDV
Considere o programa SAS abaixo:
DATA DUMMY;
INFILE '\\CursoSAS\ARQ_XY.TXT';
INPUT X Y;
Z = X * Y;
RUN;
Este programa realiza a leitura das variáveis numéricas X e Y a partir do arquivo

”ARQ_XY.TXT” (Figura 4.13), cria a variável derivada Z = X * Y e gera um data set
chamado DUMMY.
2 9
5 10
20 3
Figura 4.13 – ARQ_XY.TXT
Observe que o laço automático do passo DATA deste programa realizará três
iterações quando executado. Examinaremos a forma pela qual o SAS preenche o PDV com
informações em cada uma das iterações.
PDV antes da execução da primeira iteração

Em um programa SAS cada passo é compilado e executado de maneira
independente e seqüencial. As variáveis são adicionadas ao PDV na ordem em que são
vistas pelo compilador. O tipo e o comprimento das variáveis são determinados em tempo
de compilação de acordo com a primeira referência que for feita à variável dentro do
código [Howard 2004]. No programa exemplo a primeira variável que aparece no código é
X, no comando INPUT. Esta variável é do tipo numérico, que por default ocupa 8 bytes
com representação em ponto flutuante. Em seguida, o compilador verá as variáveis Y e Z,
nesta ordem. Desta forma, após a compilação do passo DATA e antes do início da
execução de sua primeira iteração, o PDV possuirá o formato apresentado na Figura 4.14.
Todas as variáveis estão com o conteúdo missing.
50
X Y Z _N_ _ERROR_
Figura 4.14 – PDV antes da execução da primeira iteração
Execução da primeira iteração

No início da iteração _N_ receberá o valor 1. Após a leitura da primeira observação
seguir X e Y e serão preenchidas e o valor de Z será calculado e atribuído. No fim da
iteração o PDV estará configurado da forma mostrada na Figura 4.15.
X Y Z _N_ _ERROR_
2 9 18 1 0
Figura 4.15 – PDV no final da primeira iteração
A variável _ERROR_ conterá o valor 0, pois nenhum erro ocorreu durante o

processamento. Ao longo da existência do PDV, o conteúdo da variável é sempre binário: 0
quando não houve em nenhuma iteração e 1 se um ou mais erros ocorrerem.
No fim da execução da primeira iteração, uma observação é adicionada ao data set
DUMMY, contendo os valores armazenados no PDV para as variáveis X, Y e Z. O
conteúdo das variáveis automáticas _ERROR_ e _N_ nunca é copiado para o data set de
saída . Se você, por algum motivo, desejar gravar o conteúdo de uma destas variáveis,
precisará criar uma variável auxiliar e realizar uma atribuição (ex: NUM = _N_)
Execução da segunda iteração

No início da execução da segunda iteração, o conteúdo das variáveis X, Y e Z é
anulado (todas recebem missing). A variável _N_ é incrementada automaticamente e o
conteúdo de _ERROR_ não é mudado. No final desse passo, o conteúdo do PDV é o
apresentado na Figura 4.16. Mais uma observação será gravada em DUMMY.
X Y Z _N_ _ERROR_
5 10 50 2 0
Figura 4.16 – PDV no final da segunda iteração
Execução da terceira iteração

Funciona de maneira idêntica à segunda iteração. Ao final da execução da terceira
iteração o PDV terá o conteúdo mostrado na Figura 4.17. A última observação será gravada
no data set de saída.
X Y Z _N_ _ERROR_
20 3 60 3 0
Figura 4.17 – PDV no final da última iteração
Fim da Execução do Passo DATA

Após a gravação da última observação – que representa o fim da execução do passo
DATA – o PDV é destruído. O compilador SAS verificará se existe um novo passo (DATA
51
ou PROC) a ser compilado e executado. Como o programa exemplo não possui nenhum
outro passo, a execução será encerrada.
EXEMPLO 2 – FUNCIONAMENTO DO PDV COM “VARIÁVEL RETAIN”

O programa a seguir lê o mesmo arquivo de entrada do Exemplo 1. No entanto, o
data set é criado com a opção DROP e a variável ACUMULA é declarada com o uso do
comando RETAIN.
DATA DUMMY2 (DROP = Y);

RETAIN ACUMULA_Y 0;
INFILE '\\CursoSAS\ARQ_XY.TXT';
INPUT X Y;
ACUMULA_Y = ACUMULA_Y + Y;
RUN;
Execução da primeira iteração

A Figura 4.18 apresenta o conteúdo do PDV ao final da primeira iteração. Note que,
desta vez, a primeira variável do PDV é ACUMULA_Y, pois ela foi a primeira “vista” pelo
compilador.
ACUMULA_Y X Y _N_ _ERROR_
9 2 9 1 0
Figura 4.18 – PDV no final da primeira iteração
Como sabemos, o PDV é usado para popular os data sets de saída. Neste exemplo
as variáveis ACUMULA_Y e X serão gravadas, mas Y não será levada para o data set
DUMMY2, pois faz parte da lista da opção DROP deste data set. Conclui-se então que:
todas as variáveis de um data set de saída sempre estão PDV, mas nem todas as
variáveis do PDV são gravadas no data set.
Execução da segunda iteração

No início da segunda iteração as variáveis X e Y terão o conteúdo anulado, porém o
valor de ACUMULA_Y será preservado do passo anterior. Isto ocorre, evidentemente,
porque ACUMULA_Y foi declarada com o uso do comando RETAIN. Ao final da segunda
iteração o conteúdo do PDV é o representado na Figura 4.19.
ACUMULA_Y X Y _N_ _ERROR_
19 50 10 2 0
Figura 4.19 – PDV no final da segunda iteração
Resultado Final
A Figura 4.20 apresenta o conteúdo final do data set gerado pelo programa. Veja
que Y não faz parte do data set e que ACUMULA_Y é a sua primeira variável.
Figura 4.20 – Data Set DUMMY2
52
V. Conexão com Banco de Dados
Este capítulo descreve a forma utilizada para o acesso à banco de dados relacionais
nos programas SAS. A seção também introduz a PROC SQL, um recurso que permite com
que instruções na Linguagem SQL possam ser executadas dentro de programas SAS.
Lição 37 – Visão Geral do Método de Acesso à Bancos

Relacionais no SAS
Dentro de um programa SAS, um banco de dados é enxergado como uma library

(conceito introduzido na Lição 10). O comando LIBNAME é utilizado para indicar os dados
de conexão do banco para o SAS. A sintaxe básica do comando possui três partes, que são
apresentadas e descritas a seguir:
LIBNAME Libref engine dados_da_conexão;
Libref
O parâmetro libref representa o nome pelo qual você irá referenciar a sua conexão
de banco de dados dentro dos programas SAS. Para que você possa acessar os objetos do
banco, precisará adicionar a libref como prefixo, seguida de um ponto (“ . ”). Por exemplo,
se a sua libref chama-se “libPNAD” e o banco possui uma tabela chamada
T_ESCOLARIDADE, você precisará acessar o objeto utilizando a sintaxe
libPNAD.T_ESCOLARIDADE.
Engine
No Sistema SAS, o acesso a bancos de dados relacionais é gerenciado através das
interfaces SAS/ACCESS (Lição 3). Na arquitetura exemplo apresentada na Figura 1.2
(Lições 4 e 5), existe a seguinte configuração: o Servidor I possui as interfaces Oracle (que
permite o acesso nativo ao SGBD Oracle) e ODBC (que permite o acesso ao PostgreSQL,
DB2 e outros bancos via ODBC). Já o Servidor II possui instalada a inteface DB2 (acesso
nativo ao DB2). No comando LIBNAME, o parâmetro engine é utilizado exatamente com o
objetivo de especificar a interface SAS que será utilizada na conexão. No ambiente
exemplo, existem apenas três possibilidades: oracle, db2 ou odbc.
Dados_da_conexão
Este parâmetro varia de acordo com o SGBD a ser acessado. Quando o acesso feito
ao banco Oracle, por exemplo, é necessário colocar o servidor (DIORADES, DIORAPRD,
etc), usuário e senha nos dados de conexão. Já em uma conexão ao DB2 pela interface
nativa (no MVS) é preciso especificar o banco (teste ou produção) e um ID com direito de
acesso.
As lições a seguir detalham a forma como o comando LIBNAME pode ser
configurado para o acesso a diversos bancos de dados.
53
Lição 38 – Conexão com o Oracle
A sintaxe básica para a configuração de uma library de acesso ao Oracle é

apresentada abaixo:
LIBNAME Libref oracle path=servidor user=xxx pw=xxx schema=xx;
Parâmetros:
• oracle: engine que especifica a utilização da interface nativa do Oracle.
• path: nome do servidor (DIORADES, DIORAPRD, ORAP, ORAT, etc).
• user: nome do usuário.
• pw: senha.
• schema: schema (owner) dos objetos. Este parâmetro não é obrigatório,

porém é interessante de ser utilizado em casos onde o usuário acessa objetos
de outro schema.
Vamos apresentar um exemplo de conexão ao DIORADES. Crie um novo nó de

código no Enterprise Guide e dê o nome de libnames para este nó. A seguir, digite o
seguinte código:
libname lib1 oracle user=scott pw=tiger path=oradesenv;
Este comando cria uma conexão para o banco (usuário) “scott” no servidor
“oradesenv” (banco automaticamente instalado pelo Oracle). Após a execução do código,
acesse a janela de servidores (servers). Expanda o servidor de banco de dados e a pasta
Libraries. Observe que a library lib1 será apresentada. Ela possui as tabelas do banco de
dados CURSO_SAS. É possível examinar o conteúdo das tabelas e fazer uma cópia na
library WORK.
Figura 5.1 – lib1
54
Lição 40 – Conexão com o DB2
Para os programas SAS executados no mainframe, a conexão com o DB2 poderá ser
feita através da interface nativa para este banco, desde que o ambiente possua o módulo
SAS ACCESS for DB2.
libname libDB2 db2 ssid=xxxp authid=xxx;
Onde authid refere-se a uma sigla de acesso ao MVS. Para informações sobre os
bancos de produção e desenvolvimento do DB2, consulte a equipe de suporte a este banco.
Lição 39 – Conexão via ODBC (Exemplo DB2)
O banco de dados DB2 pode ser acessado via ODBC, caso a empresa possua o
módulo SAS ACCESS for ODBC.
libname libDB2 odbc dsn=xxxp user=xxx pw=xxx;
No exemplo, user refere-se a uma sigla de acesso ao MVS.
Lição 41 – Conexão via ODBC (Exemplo PostGreSQL)
Até o momento a SAS ainda não desenvolveu uma interface ACCESS para
PostgreSQL, porém o acesso pode ser feito utilizando a interface odbc. Para que seja
possível acessar o PostgreSQL via SAS, primeiro é necessário solicitar a criação de um
data source ODBC específico para o seu banco no servidor SAS. Tendo sido criado o
data source, utilize o seguinte comando:
libname libPG odbc dsn=data_source user=xxx pw=xxx;
55
Lição 42 – Boa Prática: Criar um Nó para as Libraries
Uma boa prática de programação que pode ser adotada em projetos do Enterprise
Guide, consiste em criar um nó de código apenas para manter a configuração das
libraries que serão utilizadas nos programas. Utilizaremos esta prática nos exercícios
apresentados neste capítulo. Para começar a implementá-la, siga os passos abaixo:
1. Criação do Projeto “prjSQL”: Crie um novo projeto no EG (FILE / NEW /

PROJETCT) e salve com o nome “prjSQL”.
2. Criação do “nó de código” para as libraries: em nossos exercícios utilizaremos 3

libraries. Crie um novo nó de código (FILE / NEW / CODE), atribua a este nó o nome de
MyLibraries e digite as instruções abaixo.
*acessa o banco CURSO_SAS (banco exemplo da PNAD) no DIORADES;

libname lib1 oracle user=scott pw=tiger path=oradesenv schema=scott;
*library que representa uma pasta do Windows;

libname libCURSO '\\CursoSAS';
A library lib1 permite o acesso ao banco exemplo do Oracle. A library libCURSO

não está vinculada a um banco relacional. Ela será utilizada apenas para o armazenamento
de data sets SAS.
Lição 43 – PROC SQL – Introdução
A PROC SQL é uma procedure do SAS utilizada para permitir a utilização de

instruções SQL em programas SAS. Os comandos SQL podem ser executados não apenas
sobre tabelas de SGBD’s relacionais, mas também sobre data sets SAS. Isto quer dizer que
você pode importar um arquivo texto para um data set e depois realizar queries sobre o
mesmo usando a Linguagem SQL. As principais instruções SQL ANSI são suportadas, tais
como SELECT, INSERT, UPDATE, DELETE, CREATE e DROP [Harrington 2002].
A sintaxe básica da procedure é apresentada na página seguir. Ela começa com a
declaração “PROC SQL;” e termina com “QUIT;”. Entre estas duas declarações, uma ou
mais instruções SQL podem ser utilizadas.
PROC SQL;
Instrução_SQL1;
...
Instrução_SQLn;
QUIT;
RUN;
O programa a seguir realiza o SELECT sobre uma tabela do banco exemplo da

PNAD. Para que ele funcione, é preciso que o nó MyLibraries (criado na lição anterior)
já tenha sido executado na sessão corrente.
56
PROC SQL;
SELECT * FROM lib1.EMP;
QUIT;
RUN;
Este programa gera um relatório HTML contendo todos os dados da tabela EMP.
Note que é preciso especificar a libref “libP1” antes da tabela, para informar ao SAS a
localização da mesma.
IMPORTANTE: um comando SELECT dentro de uma PROC SQL serve para a geração de um
relatório (funcionamento similar ao da PROC PRINT).
O programa a seguir realiza o SELECT sobre o data set CENSO, que está
localizado na library libCurso. A instrução SELECT obtém a idade, raça, escolaridade e
classe de renda de todas as mulheres entrevistadas pelo Censo de Washington.
PROC SQL;
SELECT Age, Race, Education, IncomeClass FROM libCurso.CENSO
WHERE sex = 'Female';
QUIT;
RUN;
A PROC SQL suporta a consultas complexas (com o uso de junções e funções de

agregação, por exemplo). O exemplo abaixo mostra uma consulta à base da PNAD que
produz um relatório com o a escolaridade, ano de nascimento, UF e valor do domicílio, de
todas as pessoas que moram em Goiás e cujo valor do domicílio é conhecido. Embora a
consulta utilize a junção com a sintaxe SQL-92 (INNER JOIN, OUTER JOIN), o SAS
também suporta a sintaxe “tradicional” (junção no WHERE). Abaixo mostra-se um
exemplo de uma consulta deste tipo (complexa!).
PROC SQL;
SELECT D.COD_DOMICILIO, P.COD_PESSOA,
D.QTD_DORMITORIOS,
V.DSC_VALOR_DOMIC,
D.SGL_UF,
E.DSC_ESCOLARIDADE,
P.NUM_ANO_NASC
FROM
libPNAD.T_DOMICILIO_PNAD D
INNER JOIN libPNAD.T_VALOR_DOMICILIO V
ON (D.COD_VALOR_DOMIC = V.COD_VALOR_DOMIC)
INNER JOIN libPNAD.T_PESSOA_PNAD P
ON (D.COD_DOMICILIO = P.COD_DOMICILIO)
LEFT JOIN libPNAD.T_ESCOLARIDADE E
ON (P.COD_ESCOLARIDADE = E.COD_ESCOLARIDADE)
WHERE D.SGL_UF = 'GO'
AND V.DSC_VALOR_DOMIC NOT LIKE 'IGNORADO'
ORDER BY 3 DESC, 1, 2;
QUIT;
RUN;
57
Lição 44 – PROC SQL – Usando Funções SAS
A PROC SQL suporta apenas o SQL ANSI. Não é possível utilizar funções
específicas do Oracle (DECODE, TO_CHAR, TO_NUMBER, TO_DATE, NVL, etc). O
SELECT abaixo falha porque houve uma tentativa de calcular a idade da pessoa
entrevistada com o uso da função TO_NUMBER (mensagem de erro no LOG: ERROR:
Function TO_NUMBER could not be located).
PROC SQL;
D.QTD_DORMITORIOS,
V.DSC_VALOR_DOMIC,
D.SGL_UF,
E.DSC_ESCOLARIDADE,
P.NUM_ANO_NASC,
2002 – TO_NUMBER(P.NUM_ANO_NASC) AS IDADE_EM_2002
FROM
QUIT;
RUN;
Felizmente existem duas formas de resolver esta situação. A forma mais simples é
utilizar uma função SAS dentro do comando SQL. A função SAS que realiza a conversão
de uma string para number é a input. Basta utilizá-la no SQL que o comando funcionará
normalmente.
PROC SQL;
D.QTD_DORMITORIOS,
V.DSC_VALOR_DOMIC,
D.SGL_UF,
E.DSC_ESCOLARIDADE,
P.NUM_ANO_NASC,
2002 – input(P.NUM_ANO_NASC, 4.) AS IDADE_EM_2002
FROM
QUIT;
58
RUN;
A outra maneira de contornar o problema, é utilizando o recurso SQL Pass-

Through. Quando este recurso é utilizado o SAS envia a consulta para o SGBD e este se
torna responsável pela interpretação e execução da mesma. No entanto, este método é mais
sofisticado e difícil de ser utilizado, por isso não será abordado neste curso.
Lição 45 – PROC SQL – Criação de Data Sets SAS a Partir

de uma Tabela
Uma das aplicações mais populares da PROC SQL consiste na criação de data sets
SAS. Um comando CREATE AS SELECT pode ser utilizado para criar um data set na área
de WORK (ou em qualquer outra library SAS).
No exemplo a seguir, a tabela T_DOMICILIO_PNAD (da library libPNAD) será
criada e populada na área de WORK do SAS. Já a tabela DEPT (de libSCOTT) será criada
como um data set SAS na libCURSO.
*cria o data set DOMICILIO na área de WORK;

PROC SQL;
CREATE TABLE DOMICILIO AS
SELECT * FROM libPNAD.T_DOMICILIO_PNAD;
QUIT;
RUN;
*cria o data set DEPARTAMENTOxx em libCURSO;

*insere registros no data set DEPARTAMENTOxx, via SQL;
PROC SQL;
CREATE TABLE libCURSO.DEPARTAMENTOxx AS
SELECT * FROM libSCOTT.DEPT;
INSERT INTO libCURSO.DEPARTAMENTOxx VALUES(15, 'SAS', 'USA');
INSERT INTO libCURSO.DEPARTAMENTOxx VALUES(16, 'SAS2', 'CANADA');
QUIT;
RUN;
IMPORTANTE: se você criar um data set sem utilizar uma libname no prefixo, ele será criado
na library WORK. Isto é válido tanto para data sets criados em um passo DATA, como para os
criados pela PROC SQL.
Lição 46 – PROC SQL – Criação de Objetos no Banco

Oracle
No exemplo a seguir, uma tabela inteira do banco SCOTT (Oracle mainframe) será
copiada para o banco CURSO_SAS (Oracle Windows) com o uso da PROC SQL. Veja
como o processo é simples, mesmo as duas tabelas estando em ambientes diferentes.
59
*cria a tabela T_EMP_NEW em libPNAD;
PROC SQL;
CREATE TABLE libPNAD.T_EMP_NEW AS
SELECT * FROM lib1.EMP;
QUIT;
RUN;
O segundo exemplo cria a tabela em um passo DATA do SAS.
*cria a tabela T_XY em libPNAD;

DATA lib1.T_XY;
INPUT X Y;
DATALINES;
1 11
2 12
3 13
;
*grava dados em T_XY;
PROC SQL;
INSERT INTO libPNAD.T_XY VALUES(10,101);
INSERT INTO libPNAD.T_XY VALUES(11,111);
QUIT;
RUN;
60
VI. Introdução às PROCs do SAS
Em capítulos anteriores já demonstramos a utilização das PROCs PRINT e SQL do
SAS. No entanto, o conceito de PROC ainda não foi discutido com maiores detalhes. Este
capítulo tem os objetivos de apresentar as principais características do passo PROC e
também introduzir algumas das PROCs mais utilizadas em programas SAS.
Lição 47 – O que é uma PROC?
Qualquer programa SAS é composto por apenas dois tipos de passo: DATA e
PROC. O passo PROC é o local onde podemos fazer a chamada a uma procedure do SAS.
A maioria dessas procedures tem o propósito de realizar algum tipo de análise sobre os
dados de um data set e produzir relatórios. No entanto, existem algumas procedures
capazes de alterar o conteúdo de um data set e, até mesmo, criar novos data sets (como é o
caso da recém-apresentada PROC SQL).
OBSERVAÇÃO: os programadores SAS costumam referenciar as procedures do SAS como

PROCs. Normalmente as pessoas não falam “usei a procedure FREQ” e sim “usei a PROC FREQ”.
Em [Slaughter e Delwiche 2003] é apresentada uma metáfora interessante sobre a

execução de PROCs em programas SAS. As autoras consideram que utilizar uma PROC é
algo semelhante a preencher um formulário: “alguém projetou o formulário e tudo que
precisamos fazer é preencher os campos em branco” (Figura 6.1).
PROC xyz
DATA = _________________________
BY _________________________
TITLE __________________________________________________________
FORMAT __________________________________________________________
Figura 6.1 – Metáfora do Formulário
Cada PROC possui os seus próprios campos - na realidade, parâmetros ou opções -

a serem preenchidos. No entanto existem muitas procedures que compartilham os mesmos
parâmetros, o que faz com que o aprendizado torne-se facilitado. Todas as PROCs possuem
parâmetros obrigatórios e a maioria possui muitos parâmetros opcionais.
Todas as procedures começam com a palavra-reservada PROC seguida pelo nome
da procedure, como FREQ ou PRINT. As opções, se existirem, serão colocadas após o
nome da procedure.
A Opção DATA
Esta opção, disponível em praticamente todas as PROCs, informa ao SAS que data
set será utilizado como entrada para a procedure. No exemplo a seguir a PROC PRINT
utiliza o data set chamado CNAE_20:
61
PROC PRINT DATA = CNAE_20;
O parâmetro DATA é opcional. Se for omitido o SAS utilizará o último data set
criado.
ATENÇÃO: o último data set criado não significa o último data set utilizado no programa.
Lição 48 – PROC SORT
A PROC SORT tem o propósito de realizar a ordenação de um data set por uma ou
mais variáveis. Esta é uma das PROCs mais importantes do SAS, pois as operações de
junção (MERGE) e modificação (MODIFY) de data sets requerem que eles estejam
ordenados. Além disso, existem diversas procedures para análise de dados que podem tirar
proveito do fato dos dados de entrada estarem ordenados para que possam produzir
relatórios segmentados ou agrupados por determinadas variáveis. A sintaxe básica da
PROC SORT é:
PROC SORT DATA = nome_do_dataset;

BY lista_de_variáveis;
As variáveis associadas ao comando BY são chamadas de BY VARIABLES. A

seguir é apresentado um exemplo de utilização da PROC SORT.
DATA CLIENTES;
INPUT NOME $ IDADE;
DATALINES;
MARIA 33
ANA 18
PEDRO 45
MARIA 33
CARLA 29
ROBERTO 50
AMANDA 28
;
RUN;
PROC SORT DATA = CLIENTES; BY NOME;

RUN;
Como resultado, o dataset CLIENTES fica com o formato apresentado na Figura

6.2.
62
Figura 6.2 – Data Set Pessoas
A opção OUT pode ser usada para especificar a saída para um outro data set. Se
você modificar o programa anterior de acordo com o código apresentado abaixo verificará
que o data set PESSOAS não estará ordenado por nome e que será gerado um outro data
set chamado PESSOAS_ORD, este sim ordenado.
PROC SORT DATA = CLIENTES OUT = PESSOAS_ORD;

BY NOME;
RUN;
A opção NODUPKEY pode ser utilizada para eliminar registros duplicados (o caso
de “MARIA”). Já a cláusula DESCENDING pode ser utilizada junto ao comando BY para
que a ordenação seja realizada na forma descendente.
PROC SORT DATA = CLIENTES OUT = PESSOAS_ORD NODUPKEY;

BY DESCENDING NOME;
RUN;
Se for preciso ordenar por mais de uma variável, basta especificá-las utilizando o
espaço como separador. No exemplo abaixo, a ordenação está sendo realizada
prioritariamente pela variável V1 (ascendente), depois por V2 (também ascendente) e, por
fim, por V3 na ordem descendente.
PROC SORT DATA = TESTE;

BY V1 V2 DESCENDING V3;
RUN;
Lição 49 – BY VARIABLES, BY VALUES e BY GROUPS
Na PROC SORT, o comando BY informa as variáveis que serão utilizadas para a

ordenação (chamadas de BY VARIABLES). Além do conceito de BY VARIABLE existem
outros dois conceitos associados ao comando BY que são extremamente importantes:
• BY VALUE: representa o valor armazenado em uma BY VARIABLE.
• BY GROUP: representa um conjunto de observações que compartilham um

mesmo BY VALUE.
A Figura 6.3 apresenta os três conceitos recém apresentados de maneira ilustrativa.
63
Figura 6.3 – BY VARIABLE, BY GROUPS e BY VALUES
Lição 50 – PROC PRINT
Esta procedure, já apresentada no Capítulo II, serve para produzir um relatório a

partir do conteúdo de um data set. Sua sintaxe básica é:
PROC PRINT DATA = nome_do_dataset;
No Enterprise Guide a saída pode ser gerada como HTML, PDF, RTF e outros
formatos. O programa a seguir gera um relatório a partir do arquivo NOTAS.TXT.
DATA RESULTADO;
RUN;
PROC PRINT DATA = RESULTADO;

TITLE 'NOTAS FINAIS';
RUN;
No programa exemplo, a opção DATA = RESULTADO poderia ser omitida
(quando a opção é omitida o SAS utiliza o último data set criado). É possível utilizar uma
série comandos e opções com esta PROC, como, por exemplo, o comando BY que faz com
que o relatório seja organizado em seções, de acordo com a variável BY.
IMPORTANTE: o comando TITLE depois da PROC PRINT faz com que o SAS coloque o texto
entre aspas no topo de cada página do relatório de saída. É muito importante saber que o
comando TITLE é um comando global que, na realidade, não faz parte de nenhum passo. Se
você não especificar um título para um relatório, o SAS utilizará o último valor atribuído para o
comando TITLE em sua sessão.
64
Lição 51 – PROC MEANS – Parte 1
Esta procedure computa a média, variância, desvio padrão e outras estatísticas sobre
variáveis numéricas de um data set. Sua sintaxe mais comum é dada por:
PROC MEANS DATA = nome_do_dataset;;

BY lista_de_by_variáveis;
VAR lista_de_variáveis;
Onde:
• BY lista_de_by_variáveis: usado para a execução da análise de

maneira separada para combinação de valores das variáveis indicadas. O
data set precisa estar ordenado para que o comando seja usado.
• VAR lista_de_variáveis: especifica as variáveis numéricas que

serão analisadas.
Agora será feita uma demonstração da utilização da PROC MEANS. Considere uma
empresa hipotética que realiza apresentações sobre as linguagens Java, C# e PHP. A
empresa promove de 3 a 5 apresentações por mês. As palestras sobre cada linguagem são
realizadas no mesmo horário por três professores diferentes. O arquivo PALESTRAS.TXT
(Figura 6.4) apresenta a audiência de todas as palestras realizadas nos meses de fevereiro,
março e abril de 2008. Neste arquivo, a primeira informação é o dia do evento, seguido da
quantidade de pessoas que assistiram às palestras de C#, Java e PHP, respectivamente.
Note que no dia 22/03 não houve palestra sobre PHP.
01/02/2008 80 78 82
13/02/2008 102 72 96
25/02/2008 100 79 115
08/03/2008 87 87 79
15/03/2008 97 70 78
22/03/2008 109 81 .
30/03/2008 90 78 79
Figura 6.4 – PALESTRAS.TXT
Considere que a empresa deseja obter estatísticas de audiência por mês. Para
resolver este problema, ela poderia utilizar o seguinte programa SAS.
* CRIA DATA SET A PARTIR DO ARQUIVO DE ENTRADA;

DATA PALESTRAS (DROP=DIA NUM_MES);
INFILE '\\CursoSAS\PALESTRAS.TXT';
LENGTH MES $10;
INPUT
@01 DIA DDMMYY10.
65
@12 C 3.
@16 JAVA 3.
@20 PHP 3.
;
NUM_MES = MONTH(DIA);
SELECT (NUM_MES);
WHEN (1) MES = 'JANEIRO';
WHEN (2) MES = 'FEVEREIRO';
WHEN (3) MES = 'MARÇO';
WHEN (4) MES = 'ABRIL';
WHEN (5) MES = 'MAIO';
WHEN (6) MES = 'JUNHO';
WHEN (7) MES = 'JULHO';
WHEN (8) MES = 'AGOSTO';
WHEN (9) MES = 'SETEMBRO';
WHEN (10) MES = 'OUTUBRO';
WHEN (11) MES = 'NOVEMBRO';
WHEN (12) MES = 'DEZEMBRO';
END;
RUN;
*ORDENA POR MES;

PROC SORT; BY MES;
*EXECUTA A PROC MEANS;

PROC MEANS DATA=PALESTRAS;
BY MES;
VAR C JAVA PHP;
TITLE 'ESTATÍSTICAS DAS PALESTRAS';
RUN;
No programa, primeiro cria-se um data set chamado PALESTRAS que contém as

variáveis nome do mês (derivada do dia) e a audiência das palestras de C, Java e PHP. Em
seguida o data set é ordenado pelo mês. Veja que a PROC SORT foi chamada sem a
especificação da opção DATA=. Isto não é necessário, pois desejamos a ordenação pelo
ultimo data set criado, que é exatamente o data set PALESTRAS.
No ultimo passo do programa, é feita uma chamada para a execução da PROC
MEANS (a opção DATA= não precisava ter sido especificada, já que desejamos que a
PROC MEANS analise o último data set gerado). Em seguida, o comando BY é usado para
informar ao SAS que desejamos a estatística por mês. Já o comando VAR, indica as
variáveis a serem analisadas. Finalizando, a opção TITLE é usada para a especificação de
um título. Como resultado da execução do procedimento, o seguinte relatório da Figura 6.5
é produzido.
66
Figura 6.5 – Relatório produzido pela PROC MEANS
Os comandos BY e VAR são opcionais. Se você não especificar nenhum deles, o

SAS computará estatísticas para todas as variáveis numéricas, levando em conta todas as
observações. O comando CLASS ser utilizado no lugar do BY para a produção de um
relatório mais compacto.
Lição 52 – PROC MEANS – Parte 2
No exemplo da Lição 51, a PROC MEANS calculou, para cada variável, o número
de valores não nulos, a média, desvio padrão, valor máximo e valor mínimo. Isso ocorreu
porque a procedure foi chamada sem nenhuma opção. Em [Slaughter e Delwiche 2003]
uma lista de opções para o cálculo de outras medidas de interesse é apresentada. Algumas
delas são relacionadas na Tabela 6.1.
Tabela 6.1 – Algumas opções da PROC MEANS

Opção Significado
N Número de valores não-nulos.
NMISS Número de valores nulos.
SUM Somatório.
MIN Valor mínimo.
MAX Valor máximo.
MEAN Média.
STD Desvio padrão.
VAR Variância.
Veja a forma de utilizar as opções.
67
PROC MEANS DATA=PALESTRAS N NMISS SUM;
BY MES;
VAR C JAVA PHP;
RUN;
Também é possível exportar os resultados para um data set, utilizando a sintaxe a

seguir:
PROC MEANS DATA = nome_do_dataset;;

BY lista_de_by_variáveis;
VAR lista_de_variáveis;
OUTPUT OUT = data_set;
estatística1 (variáveis_origem1) = variáveis_destino1;
...
estatístican (variáveis_origemn) = variáveis_destinon;
Nada melhor do que um exemplo para demonstrar esta funcionalidade.
PROC MEANS DATA=PALESTRAS;

BY MES;
VAR C JAVA PHP;
OUTPUT OUT = RESULTADOS
MEAN(C JAVA PHP) = MEDIA_C MEDIA_JAVA MEDIA_PHP
SUM(C JAVA PHP) = SOMA_C SOMA_JAVA SOMA_PHP;
RUN;
Neste exemplo, é solicitada a geração de um data set chamado RESULTADOS que

conterá o resultado da análise da PROC MEANS. Duas estatísticas serão gravadas. A
primeira é a média de audiência dos cursos de C, JAVA e PHP, com o uso da opção MEAN.
Os nomes das variáveis destino foram especificados como MEDIA_C, MEDIA_JAVA e
MEDIA_PHP. A outra estatística é a soma total de público para cada palestra, com o uso da
opção SUM. As varáveis destino foram chamadas de SOMA_C, SOMA_JAVA e
SOMA_PHP. A Figura 6.6 apresenta o data set produzido. As variáveis _TYPE_ e _FREQ_
são colocadas automaticamente no resultado pelo SAS.
Figura 6.6 – Data set gerado pela PROC MEANS
Lição 53 – PROC FREQ
Esta procedure produz tabelas de freqüências sobre grupos de variáveis escolhidas

de um data set. A sua sintaxe básica é:
68
PROC FREQ DATA = nome_do_dataset;
TABLES conjunto_de_variáveis1;
...
TABLES conjunto_de_variáveisn;
A seguir alguns exemplos de análise sobre a base de dados do Censo de

Washington.
PROC FREQ DATA=libCurso.CENSO;

TABLES IncomeClass;
RUN;
O resultado (Figura 6.7) apresenta a freqüência sobre uma única variável:

IncomeClass (classe de renda). Veja que menos de 25% dos entrevistados ganham mais de
US$ 50.000 por mês.
Figura 6.7– Análise unidimensional com a PROC FREQ
O próximo exemplo gera uma tabela de freqüência com o cruzamento das variáveis
Sex e IncomeClass (análise bidimensional) O resultado é apresentado na Figura 6.8.

TABLES Sex * IncomeClass;
RUN;
69
Figura 6.8– Análise bidimensional com a PROC FREQ
Em cada célula, o SAS imprime a freqüência, o percentual, o percentual para a linha

e o percentual para a coluna. Observe a primeira célula destacada com um retângulo. O
valor 8670 refere-se ao total de mulheres que ganham menos de US$ 50.000 dólares por
ano. Isto representa 28.74% do total de observações da base de dados (30162 observações),
conforme mostra o valor da segunda linha da célula. Na terceira linha, é possível verificar
que 88.63% das mulheres ganham menos de US$ 50.000 dólares/ano. Por fim, a quarta
linha da célula dentre o total de pessoas que ganham menos de US$ 50.000 dólares/ano,
38,27% são mulheres. Um exercício interessante é comparar os valores desta primeira
célula com os valores das outras células destacadas nos retângulos. Vamos comparar a
segunda célula destacada {(Sex= “Female”), (IncomeClass = “> 50K”)} com a
quarta célula que também está destacada {(Sex= “Male”), (IncomeClass = “> 50K”)}.
Note que a chance de uma pessoa ser do sexo feminino e ganhar mais de US$ 50.000 por
ano é de 11.37% (célula 2) e que, entre os homens, este valor aumenta para 31,38% (célula
4).
Também pode-se gerar tabelas várias tabelas de freqüência em um único PROC
FREQ.

TABLES Sex * IncomeClass;
TABLES Race * IncomeClass;
TABLES NativeCountry;
RUN;
O exemplo a seguir mostra que é possível gerar tabelas de freqüência envolvendo o

cruzamento de mais de 2 variáveis. Mas é claro que, neste caso, existe um grande
70
inconveniente, que consiste na dificuldade da realização da análise visual de uma tabela
com 3 ou mais dimensões.

TABLES Sex * Race * IncomeClass;
RUN;
Lição 54 – Comentários Finais
Este capítulo apresentou algumas das PROCs mais importantes do módulo Base
SAS. Existem muitas outras PROC úteis dentro do Base SAS, como a PROC COMPARE
(realiza a comparação de dois data sets), a PROC APPEND (insere observações em um
data set), a PROC CONTENTS (gera um relatório com as propriedades de um data set),
PROC FORMAT (permite a criação de formatos para relatórios), entre outras. Somando
estas procedures com aquelas que fazem parte dos módulos SAS/STAT, SAS/IML e
SAS/GRAPH temos centenas de PROCs disponíveis no ambiente SAS. Infelizmente a
apresentação de todas essas PROCs encontra-se fora do escopo deste curso.
71
VII. Programação SAS – Além do Básico
Este capítulo aborda os comandos utilizados para a modificação e combinação de
data sets, o uso de vetores (arrays) no passo DATA e também as funcionalidades de macro
do SAS.
Lição 55 – SET
O comando SET permite com que você leia um data set SAS, podendo modificá-lo
de diversas formas (adicionando ou eliminando variáveis, alterando o conteúdo, etc). A
sintaxe básica deste comando é a seguinte:
DATA novo_data_set;
SET data_set;
No exemplo a seguir, o data set CENSO_AUX é gerado na área de WORK a partir

da leitura do data set CENSO (gravado na library CURSO). Uma variável derivada
chamada FAIXA_ETÁRIA será criada como função da variável Age.
libname libCURSO '\\CursoSAS';
DATA CENSO_AUX;
LENGTH FAIXA_ETARIA $ 6;
SET libCurso.CENSO;
SELECT;
WHEN (Age <= 20) FAIXA_ETARIA = '<20';
WHEN (Age > 20 AND Age <=30) FAIXA_ETARIA = '21-30';
OTHERWISE FAIXA_ETARIA = '>50';
END;
RUN;
É possível utilizar as opções DROP, KEEP, RENAME e WHERE no comando

SET. No exemplo a seguir, apenas as variáveis Age, Sex e Race são lidas.
DATA CENSO_AUX2;
SET CENSO_AUX (KEEP=Age, Sex, Race);
RUN;
A utilização do comando SET com a opção KEEP (ou DROP) apresenta uma
grande vantagem no que diz respeito ao desempenho, pois impede que variáveis sejam
lidas para o Program Data Vector [Johnson 2003] o que gera economia de memória e
processamento.
72
IMPORTANTE: o número de iterações executados pelo laço automático de um passo DATA será
igual ao número de observações do data set indicado pelo comando SET.
Lição 56 – Os Comandos KEEP, DROP, RENAME e

WHERE
Os comandos KEEP, DROP, RENAME e WHERE não devem ser confundidos

com as opções de data set que possuem o mesmo nome. Estes comandos aparecem dentro
do código do passo DATA; já as opções de data set aparecem entre parêntesis ao lado dos
comandos SET e DATA. Embora os comandos e opções tenham funções similares,
existem diferenças com relação ao modo como o SAS os executa. Estas diferenças são
discutidas no trabalho de [Johnson 2003].

DATA MEDIAS_FINAIS;
* CALCULA A MÉDIA;
DROP NOTA1 NOTA2; *USO DO COMANDO DROP;
RUN;
Lição 57 – Variáveis Temporárias: FIRST e LAST
As variáveis temporárias FISRT e LAST, consistem em variáveis numéricas que

podem ser adicionadas e gerenciadas automaticamente no Program Data Vector se o
programador assim desejar. Assim como as variáveis automáticas ( _N_ e _ERROR_ ), elas
não são transferidas para o data set de saída. Estas variáveis só podem ser utilizadas em
data sets ordenados e funcionam da seguinte forma:
• FIRST : recebe automaticamente o valor VERDADEIRO (1) se a observação

correntemente processada no passo DATA representa o primeiro registro de um
BY GROUP. Caso contrário armazena o valor FALSO (0).
• LAST : recebe automaticamente o valor VERDADEIRO (1) se a observação

correntemente processada no passo DATA representa o último registro de um BY
GROUP. Caso contrário armazena o valor FALSO (0).
As variáveis temporárias costumam facilitar em muito o desenvolvimento de certas

rotinas. O exemplo abaixo demonstra esta situação, utilizando a tabela
73
T_EMPREGO_PNAD - que possui informações sobre os salários das pessoas
entrevistadas pela PNAD. As variáveis FISRT e LAST são utilizadas para facilitar a
criação de uma variável derivada que armazenará a renda total de um domicílio (somatório
da renda de todos os moradores).
*cria o data set EMPREGO_AUX a partir de T_EMPREGO_PNAD;

DATA EMPREGO_AUX;
SET libPNAD.T_EMPREGO_PNAD
(KEEP = COD_DOMICILIO COD_PESSOA VAL_RENDA_TOTAL);
*ordena o data set por COD_DOMICILIO;

PROC SORT DATA=EMPREGO_AUX; BY COD_DOMICILIO;
*o data set FINAL conterá a renda total por domicílio;

DATA FINAL(DROP = COD_PESSOA VAL_RENDA_TOTAL);
SET EMPREGO_AUX; BY COD_DOMICILIO;
retain RENDA_TOT;
*se estou na primeira pessoa do domicílio, inicializo o valor da renda total;

if FIRST.COD_DOMICILIO then RENDA_TOT = 0;
*acumula a soma das rendas;

RENDA_TOT = RENDA_TOT + VAL_RENDA_TOTAL;
*se estou na última pessoa do domicílio, gravo a renda total em FINAL;

if LAST.COD_DOMICILIO then OUTPUT;
RUN;
IMPORTANTE: para que as variáveis FIRST e LAST possam ser usadas dentro de um passo
DATA é preciso:
1. Que os dados de entrada estejam ordenados por alguma BY VARIABLE.
2. Realizar uma chamada ao comando BY dentro do passo DATA.
Lição 58 – MERGE - Introdução
MERGE é o comando utilizado no passo DATA para combinar o conteúdo de dois

ou mais data sets. Trata-se de um processo similar a operação de JOIN (junção) da
linguagem SQL. Normalmente você terá dois data sets SAS com dados relacionados que
você desejará combinar em um novo data set (ex: pedido com produto, empresa com UL,
etc). Os data sets combinados possuirão algum tipo de relacionamento efetivado por uma
ou mais variáveis em comum. A Figura 7.1 resume os passos necessários para a execução
do MERGE entre data sets.
74
1. Ordenar os data sets pela variável em comum, caso eles não
estejam ordenados. Para isto, utilize a PROC SORT.
2. Criar um novo passo DATA que se encarregará de produzir o

data set que armazenará o resultado do MERGE.
3. Incluir o comando MERGE nesse passo, especificando a relação

de data sets que serão combinados.
4. Incluir o comando BY para informar ao SAS quais são as

variáveis em comum.
Figura 7.1 – Passos para a implementação de uma rotina de MERGE em um Programa SAS
Com relação ao passo 4, é preciso realizar um breve comentário. Na linguagem SAS

também é possível fazer o MERGE de data sets que não possuem variáveis em comum. No
entanto, na prática, esta necessidade não costuma surgir com muita freqüência.
A sintaxe básica do comando MERGE é apresentada abaixo.
DATA ds_saída;
MERGE d1 d2;
BY variáveis_em_comum;
As subseções a seguir apresentarão diversos exemplos práticos de utilização do

comando MERGE. As situações apresentadas foram criadas com base nos conceitos
apresentados nas seguintes referências: [Droogendyk 2008] , [TS-644], [TS-705] e
[Slaughter e Delwiche 2003] .
Lição 59 – MERGE – Exemplo Básico
Nesta lição será apresentada a operação de MERGE entre um data set com dados de
EMPRESAS e um data set com os dados das UL’s destas empresas. Os data sets serão
montados a partir dos arquivos EMPRESAS.TXT e ULS.TXT, cujos conteúdos são
apresentados nas Figuras 7.2 e 7.3, respectivamente.
11111111MARIA GONÇALVES ME 213562040

66666666LIMPSERV SERVIÇOS DE LIMPEZA 214381117
22222222INDUSTRIA DE CALÇADOS RIO DO OURO 206215335
44444444SUPERMERCADO DO BOM PREÇO 206247113
33333333COMÉRCIO DE ROUPAS BOA VISTA 206247814
55555555PREFEITURA DE NEW JERSEY 103186101
88888888MERCADINHO ABCD 213547113
Figura 7.2 – EMPRESAS.TXT
75
222222220001RIO DO OURO I 1531920
222222220002RIO DO OURO II 153355
222222220003RIO DO OURO III 1540815
333333330001LOJA RIO DE JANEIRO 478148
333333330002LOJA NITERÓI 478144
444444440001SEDE ADMINISTRATIVA 70107112
444444440003LOJA PRINCIPAL 47113101
444444440004LOJA RECIFE 4711348
444444440005LOJA PORTO ALEGRE 4711350
444444440010LOJA VITÓRIA 47113
555555550001 861011800
666666660001LIMPSERV 8111712
Figura 7.3 – ULS.TXT
O arquivo de empresas possui 4 variáveis:

• Raiz do CNPJ (colunas 1-8);
• Razão Social (9-49) ;
• Natureza Jurídica (50-53);
• CNAE da Empresa (54-58).
O arquivo de UL’s possui 5 variáveis:
• Raiz do CNPJ (colunas 1-8);

• Sufixo do CNPJ (colunas 9-12);
• Nome Fantasia (13-34) ;
• CNAE da UL (35-39);
• Pessoal Ocupado (40-43).
A variável em comum é Raiz do CNPJ. O programa abaixo importa os dois arquivos

e depois cria um data set SAS chamado TODAS, resultante do MERGE entre as empresas
e UL’s.
76
/*-------------------------------------------------------
MERGE - EXEMPLO 1 (BÁSICO);
PRODUZ O DATA SET "TODAS" RESULTANTE DO MERGE ENTRE UM
DATA SET DE EMPRESAS E UM DATA SET DE UL'S
-------------------------------------------------------*/
* PASSO 1 - IMPORTA ARQUIVO DE EMPRESAS PARA UM DATA SET SAS;

* APENAS AS VARIÁVEIS RAIZ DO CNPJ E RAZÃO SOCIAL SERÃO IMPORTADAS;
DATA EMPS;
INFILE '\\CursoSAS\EMPRESAS.TXT';
INPUT
@001 RAIZ $CHAR8.
@009 RAZAO $CHAR40.
;
RUN;
* PASSO 2 - IMPORTA ARQUIVO DE UL'S PARA UM DATA SET SAS;

* APENAS AS VARIÁVEIS RAIZ, SUFIXO DO CNPJ, NOME FANTASIA E PO SERÃO IMPORTADAS;
DATA ULS;
INFILE '\\CursoSAS\ULS.TXT';
INPUT
@001 RAIZ $CHAR8.
@009 SUFIXO $CHAR4.
@013 FANTASIA $CHAR21.
@039 PO 4.
;
RUN;
* PASSOS 3 e 4 – ORDENAÇÃO DOS DATA SETS PELA VARIÁVEL EM COMUM (RAIZ);

PROC SORT DATA = EMPS;
BY RAIZ;
RUN;
PROC SORT DATA = ULS;

BY RAIZ;
RUN;
* PASSO 5 - REALIZA O MERGE E GRAVA O RESULTADO NO DATA SET TODAS;

DATA TODAS;
MERGE EMPS ULS;
BY RAIZ;
RUN;
O programa será agora analisado. O primeiro passo cria um data set EMPS com
dados oriundos do arquivo EMPRESAS.TXT. De maneira análoga, no segundo passo o
data set ULS é criado a partir de ULS.TXT.
O objetivo é realizar o MERGE utilizando a variável Raiz que é a variável comum
entre os dois data sets. Para que o MERGE possa ser feito, é preciso que os data sets
estejam ordenados por esta variável em comum. Por este motivo, nos passos 3 e 4
utilizamos a PROC SORT. Se você observar a Figura 7.3, perceberá que o arquivo de UL’s
já estava ordenado. De qualquer maneira, foi feita a chamada da PROC SORT para as ULS
Se o conteúdo de ULS.TXT for alterado no futuro, o funcionamento do programa SAS
continuará garantido.
O quinto e último passo do programa é o que, de fato, cria o data set TODAS
resultante do MERGE entre os data sets EMPS e ULS. As tabelas a serem combinadas são
77
especificadas ao lado do comando MERGE, enquanto a variável em comum é indicada ao
lado do comando BY.
O data set TODAS possui 13 observações e 5 variáveis, conforme mostra a Figura
7.4.
Figura 7.4 – Data Set TODAS
Veja que as empresas com Raiz do CNPJ igual “11111111” e “88888888” não
possuem UL’s associadas, mas mesmo assim foram gravadas no data set (o SAS executou
algo semelhante ao que seria um LEFT JOIN na Linguagem SQL). Você entenderá porque
isso aconteceu ao estudar a próxima lição.
Lição 60 – MERGE - Como Funciona?
O conceito chave para o entendimento da forma de funcionamento do comando

MERGE está, na realidade, associado ao comando BY e a maneira como ele altera o
comportamento do Program Data Vector durante a execução dos comandos MERGE,
SET, MODIFY e UPDATE (estes últimos, ainda não apresentados).
O comando BY controla a maneira pela qual os valores das variáveis do PDV são
passados para missing. Durante o processamento de um BY GROUP, o sistema SAS retém
os valores das variáveis do PDV até que tenha copiado a última observação do BY
GROUP em qualquer um dos data sets.
Para que seja possível entender este conceito, é preciso apresentar um exemplo, que
mostrará o funcionamento do MERGE passo-a-passo. Suponha que desejamos realizar o
MERGE entre os data sets de Empresas e UL’s cujo conteúdo é mostrado na Figura 7.5.
EMPRESAS ULS
RAIZ RAZÃO RAIZ SUFIXO UF
22222222 Emp A 22222222 0001 RJ
77777777 Emp B 22222222 0002 SP
88888888 Emp C 77777777 0001 MG
99999999 Emp D 99999999 0010 RJ
Figura 7.5 – Data Sets que serão Combinados com o MERGE.
78
Os dois data sets já estão ordenados pela variável comum, RAIZ. Recordando a
lição anterior, os comandos necessários para a efetivação do MERGE são:
DATA RESULTADO;
MERGE EMPRESAS ULS;
BY RAIZ;
RUN;
A simulação do processo de execução deste trecho de código pelo SAS é
apresentada a seguir.
1. Criação do PDV
Após a compilação do código, o SAS criará o PDV mostrado na Figura 7.6. Observe
que o PDV contém todas variáveis dos data sets EMPRESAS e ULS. Note ainda que a
variável comum RAIZ aparece apenas uma vez no PDV.
RAIZ RAZÃO SUFIXO UF _N_ _ERROR_
Figura 7.6 – PDV antes da execução da primeira iteração
2. Execução da Primeira Iteração

A primeira iteração começa com a leitura da primeira observação do data set
EMPRESAS (o primeiro especificado na lista de data sets do comando MERGE), fazendo
com que as variáveis correspondentes sejam preenchidas no PDV (Figura 7.7).
22222222 Emp A 1 0
Figura 7.7 – PDV após a leitura da primeira observação de EMPRESAS
O SAS irá ler agora a primeira observação que pertencente ao mesmo BY GROUP
em ULS. O valor da RAIZ será sobrescrito no PDV. Os valores das variáveis SUFIXO e
UF, que pertencem ao data set ULS serão preenchidos no PDV. O valor da Razão não será
alterado, pois essa variável não faz parte do data set ULS. Ao final do processo o PDV
estará configurado da maneira mostrada na Figura 7.8.
22222222 Emp A 0001 RJ 1 0

Figura 7.8 – PDV após a leitura da primeira observação de EMPRESAS e da primeira observação de ULS
Neste momento o conteúdo do PDV é gravado no data set de saída (RESULTADO)

e o SAS passa para próxima iteração.
3. Execução da Segunda Iteração

Na primeira ação desta iteração, o SAS verifica se ainda existe mais alguma
observação que pertença ao mesmo BY GROUP (RAIZ = “22222222”) nos dois data sets.
Olhe novamente para a Figura 7.5. Veja que não existe mais nenhuma observação para o
BY GROUP no data set EMPRESAS. No entanto, ainda existe no data set ULS. Por esta
razão, o SAS executa as seguintes ações:
79
1. Manter o conteúdo das variáveis do PDV (exceto as variáveis automáticas). Veja
que este comportamento é diferente do comportamento padrão do PDV,
apresentado na Lição 36.
2. Não realizar a leitura de uma nova observação em EMPRESAS.
3. Realizar a leitura de uma nova observação em ULS, alterando o conteúdo das
variáveis RAIZ, SUFIXO e UF.
Como resultado, a configuração do PDV ao final desta iteração será a mostrada na

Figura 7.9. Estes serão os dados gravados no data set RESULTADO.
22222222 Emp A 0002 SP 2 0

Figura 7.9 – PDV após o final da segunda iteração
4. Execução da Terceira Iteração

Novamente, a primeira ação do SAS é examinar se existe mais alguma observação
associada ao BY GROUP (RAIZ = “22222222”) em algum dos dois data sets. Desta vez a
resposta é negativa. Então, por este motivo, o SAS anula as variáveis do PDV (Figura
7.10).
3 0
Figura 7.10 – PDV no Início da Terceira Iteração
O SAS lê a próxima observação em EMPRESAS e preenche as variáveis

correspondentes no PDV. Esta observação pertence ao BY GROUP (RAIZ = “77777777”).
A seguir o SAS verifica se a próxima observação em ULS está associada ao mesmo BY
GROUP. Como o resultado da verificação é VERDADEIRO, a observação é lida de ULS e
as variáveis correspondentes são atualizadas no PDV (Figura 7.11). A iteração é finalizada
com a gravação de mais uma observação no data set RESULTADO.
77777777 Emp B 0001 MG 3 0

Figura 7.11 – PDV após o final da terceira iteração
5. Execução da Quarta Iteração

O SAS é examinar se existe mais alguma observação associada ao BY GROUP
(RAIZ = “77777777”) nos dois data sets. O resultado da verificação é FALSO, e, com isso
são anulados os valores das variáveis RAIZ, RAZÃO, SUFIXO e UF no PDV (Figura
7.12).
4 0
Figura 7.12 – PDV no Início da Quarta Iteração
80
A próxima observação de EMPRESAS é lida, atualizando as variáveis RAIZ e
RAZÃO no PDV. Esta observação pertence ao BY GROUP (RAIZ = “88888888”). A
seguir, o SAS verifica se a próxima observação em ULS está associada ao mesmo BY
GROUP. A comparação retorna FALSE e por isso o SAS não importa a observação de
ULS. O PDV fica configurado da forma apresentada na Figura 7.13. Veja que SUFIXO e
UF ficam com valor missing. Estes serão os dados gravados no data set RESULTADO.
88888888 Emp C 4 0
Figura 7.13 – PDV ao final da quarta iteração.
6. Execução da Quinta Iteração (FINAL)

Esta última iteração funciona de maneira análoga, não apresentando nenhuma
novidade. Ao final da iteração o PDV estará com a configuração mostrada na Figura 7.14 e
e o processo de geração do data set RESULTADO será finalizado. A conteúdo final de
RESULTADO é mostrado na Figura 7.15.
99999999 Emp D 0010 RJ 5 0

Figura 7.14 – PDV após o final da última iteração
Figura 7.15 – Data Set RESULTADO
Como curiosidade, segue o programa que realizou esta simulação.
DATA EMPRESAS;
INPUT RAIZ $ RAZAO $;
DATALINES;
22222222 EmpA
77777777 EmpB
88888888 EmpC
99999999 EmpD
RUN;
DATA ULS;
INPUT RAIZ $ SUFIXO $ UF $;
DATALINES;
22222222 0001 RJ
22222222 0002 SP
77777777 0001 MG
99999999 0010 RJ
RUN;
81
DATA RESULTADO;
MERGE EMPRESAS ULS;
BY RAIZ;
RUN;
Lição 61 – MERGE – Opção IN
Quando dois data sets são combinados, é possível utilizar a opção IN para
acompanhar qual o data set origem que contribuiu para a criação de cada observação no
data set de saída. A opção IN pode ser imaginada como uma espécie de etiqueta de
fabricação [Slaughter e Delwiche 2003]. Para que o conceito fique claro, altere a rotina de
MERGE do programa da Lição 59 da forma mostrada a seguir e, depois, execute
novamente o programa.
* PASSO 4 alteração – GRAVA APENAS AS EMPRESAS QUE POSSUEM UL(S);

DATA COM_ULS;
MERGE EMPS (IN=E) ULS (IN=U);
BY RAIZ;
IF E AND U THEN OUTPUT;
RUN;
No programa exemplo, o comando MERGE EMPS (IN=E) ULS (IN=U) faz com que
os data sets EMPS e ULS recebam, respectivamente, os rótulos E e U. Já a linha de
comando IF E AND U THEN OUTPUT atua como um IF de subsetting que dá a seguinte
ordem ao SAS: “grave a observação corrente no data set apenas se ela for resultante da
contribuição dos data sets E e U). Isto funciona da mesma maneira que um INNER JOIN
da Linguagem SQL. Desta vez as empresas que não possuem UL’s não serão gravadas no
data set de saída (Figura 7.16).
Figura 7.16 – Data Set COM_ULS
Faça mais uma alteração no programa:
* PASSO 4 alteração – GRAVA APENAS AS EMPRESAS QUE NÃO POSSUEM UL(S);

DATA EXEMP3;
BY RAIZ;
IF E AND NOT U THEN OUTPUT;
RUN;
82
Esta alteração fará com que apenas as observações geradas somente pelo data set
EMPS sejam gravadas na saída (Figura 7.17). Estas observações correspondem às empresas
que não possuem UL’s.
Figura 7.17 – Data Set SEM_ULS
No passo DATA também é possível especificar a criação de mais de 1 data set. No

exemplo a seguir, serão gerados 3 data sets a partir do comando MERGE (TODAS,
COM_ULS e SEM_ULS). A instrução OUTPUT se encarregará de colocar as observações
adequadas em cada data set.
* PASSO 4 - REALIZA O MERGE E GRAVA O RESULTADO EM 3 DATA SETS;

DATA TODAS SEM_ULS COM_ULS;
BY RAIZ;
IF E AND U THEN
OUTPUT COM_ULS; *este data set contém apenas as empresas com UL(s);
ELSE IF E AND NOT U THEN
OUTPUT SEM_ULS; *este data set contém apenas as empresas sem UL;
OUTPUT TODAS; *este data set contém todas as empresas;
RUN;
Lição 62 – MERGE – Problemas mais Comuns
Esta lição apresenta uma relação dos problemas mais comumente vivenciados pelos
programadores SAS com relação ao uso do comando MERGE com BY.
As Variáveis BY precisam ter o MESMO NOME.

Para que seja possível realizar o MERGE entre dois data sets é preciso que as
variáveis BY em ambos os data sets possuam o mesmo nome. Muitas vezes você precisará
utilizar a opção RENAME para resolver esta questão.
As Variáveis BY precisam ter o MESMO TIPO.

Não é possível realizar a combinação, quando as Variáveis BY possuem o mesmo
nome, mas tipos diferentes (caractere e numérico).
Os Data Sets devem estar ORDENADOS pelas Variáveis BY

Se você especificar um data set que não esteja ordenado no comando BY, o SAS
não realizará a operação de MERGE e apresentará a seguinte mensagem de erro:
ERROR: BY variables are not properly sorted on [Data Set]
83
Data Sets com OBSERVAÇÕES DUPLICADAS afetam o Data Set de Saída
Se você combinar data sets que possuem observações duplicadas, estas serão
transportadas para o data set de saída. Observe o exemplo da Figura 7.18
RAZOES RECEITAS
RAIZ RAZÃO RAIZ CLASSE RECEITA
22222222 Emp X 22222222 A
22222222 Emp X 88888888 C
88888888 Emp Y
Figura 7.18 – Data Sets que serão Combinados com o MERGE
Considere que se deseja combinar o data set RAZOES (que possui o CNPJ e a razão
social das empresas) com o data set de receitas (que possui o CNPJ e a classe de receita).
Imagine que por um erro provocado em outro programa, o data set de RAZOES possui
uma observação duplicada, a de CNPJ = 22222222. O resultado do MERGE entre os dois
arquivos acabaria por levar o registro duplicado, conforme mostra a Figura 7.19.
RESULTADO
RAIZ RAZÃO CLASSE RECEITA
22222222 Emp X A
22222222 Emp X A
88888888 Emp Y C
Figura 7.19 – Data Sets com observação duplicada
Problema das Variáveis comuns aos dois data sets

Se você tentar combinar data sets que possuem variáveis comuns (com nomes
iguais), o SAS levará reservará apenas um “espaço” no PDV para as duas variáveis. Isto é
um problema para o caso de variáveis que não são Variáveis BY. Observe o exemplo a
seguir, retirado de [TS-644].
DATA UM;
INPUT ID $ X;
DATALINES;
a 1
b 2
c 3
;
RUN;
DATA DOIS;
INPUT ID $ X;
DATALINES;
a 11
b 22
c 33
;
RUN;
DATA COMUM;
MERGE UM DOIS; BY ID;
RUN;
Uma variável comum aparecerá apenas uma vez no data set de saída. No exemplo
acima, o data set UM irá popular o PDV primeiro com os conteúdos de ID e X. Como o
data set DOIS possui observações do mesmo BY GROUP, o conteúdo de ID e o conteúdo
84
de X serão sobrescritos. No resultado final, acabarão prevalecendo as informações do data
set DOIS, já que ele foi o especificado por último na lista do MERGE (Figura 7.19).
Figura 7.19 – Data Set COMUM
Problema das Variáveis BY com TAMANHOS DIFERENTES

Nesta situação, é possível realizar o MERGE. Porém o comprimento adotado será o
comprimento da variável no primeiro data set subordinado a lista do MERGE. Com isto,
poderão ocorrer problemas de truncamento de valores.
Lição 63 – MERGE Sem BY
Os exemplos apresentados nas lições anteriores, representaram casos de Match

MERGE, ou seja, combinação de data sets com o uso do BY. No entanto, também é
possível realizar o MERGE sem o uso do comando BY (embora, normalmente, não haja
necessidade para isso). Neste caso o SAS simplesmente irá gerar a primeira observação do
data set de saída combinando as primeiras observações de todos os data sets subordinados
ao MERGE. A segunda observação no data set de saída será resultante da combinação das
segundas observações de todos os data sets de entrada. E assim por diante. Veja o seguinte
exemplo:
DATA UM;
INPUT X;
DATALINES;
1
2
3
;
RUN;
DATA DOIS;
INPUT NOME $;
DATALINES;
EDUARDO
ANA
;
RUN;
DATA SEM_BY;
MERGE UM DOIS;
RUN;
O data set gerado possuirá o conteúdo mostrado na Figura 7.20.
85
Figura 7.20 – Data Set SEM_BY
Lição 64 – MERGE x SQL JOIN
Trabalhos recentes como [Harrington 2002], [Hu 2004], [Lauderdale 2007] e,

especialmente, [Droogendyk 2008] sugerem que tanto o uso do comando MERGE para
combinar tabelas, como a utilização da PROC SQL objetivando o mesmo propósito,
representam abordagens que possuem vantagens e desvantagens. Dependendo do tipo
de combinação a ser feita, o uso do MERGE pode ser mais adequado do que o do SQL
com JOIN e vice-versa. A Tabela 7.1 apresenta os principais “prós” e “contras” de cada
uma das abordagens.
Tabela 7.1 – MERGE x SQL Join: Prós e Contras

MERGE SQL JOIN (PROC SQL)
PRÓS - Permite a utilização de recursos - Permite combinar data sets que não
dentro do DATA STEP, que estão ordenados.
facilitam a transformação de
variáveis. Ex: FIRST/LAST, IF- - Permite a junção entre 3 ou mais
THEN, loops, etc. tabelas usando variáveis BY diferentes
Ex: DOMICILIO com PESSOA com
- Para quem não sabe nada sobre ESCOLARIDADE.
MERGE e nada sobre SQL, é
mais fácil aprender o MERGE...
CONTRAS - É preciso ordenar o data set por - Não é possível utilizar os recursos de
alguma variável BY. programação do DATA STEP.
- Não é possível fazer um MERGE

que combine tabelas por variáveis
BY diferentes. A rotina tem que
ser dividida em 2 passos DATA.
Lição 65 – MODIFY - Introdução
O comando MODIFY é utilizado para modificar um data set dentro do passo

DATA, sem que seja preciso criar um novo data set. Dependendo do problema a ser
resolvido, pode funcionar de forma mais eficiente do que uma atualização via SQL (o
trabalho de [Curtis 2006] mostra uma série de testes comparativos).
Para demonstrar a utilidade do comando MODIFY, veja o programa abaixo, que
cria o data set F_XY na library usada em nosso curso. O data set três variáveis: K, X e Y.
Neste exemplo, K é uma constante com o valor 5 e Y representa o valor de X * K.
86
DATA libCURSO.F_XY;
INPUT K X;
Y = K * X;
DATALINES;
5 10
5 20
5 30
;
RUN;
Imagine que o usuário deixou o data set F_XY gravado por alguns dias e depois
resolveu recriá-lo, fazendo uma modificação no valor de K (K passou a valer 5.5 ao invés
de 5). Ele poderia executar esta tarefa da seguinte maneira:
DATA libCURSO.F_XY;
SET libCurso.F_XY;
K = 5.5;
Y = K * X;
RUN;
Ao executar o programa, o SAS lerá cada observação de F_XY para o PDV. As
modificações em K e Y serão feitas no PDV e, os dados serão sempre gravados em um
data set temporário. Após a última iteração do passo DATA, o SAS substituirá o data set
F_XY pelo data set temporário.
Com o uso do MODIFY o processo de atualização é diferente, pois o SAS
modificará diretamente o data set, sem criar nenhuma estrutura temporária. Com isto
a atualização torna-se mais eficiente.
DATA libCURSO.F_XY;
MODIFY libCurso.F_XY;
K = 5.8;
Y = K * X;
RUN;
Lição 66 – MODIFY com o Comando BY
Existem 4 formas de usar o comando MODIFY: sozinho, com o comando BY, com
chave (key) e com o comando POINT. Nesta lição abordaremos a utilização do MODIFY
com o comando BY, por ser a que possui maior aplicação prática .
O uso do MODIFY com BY é similar ao do MERGE. Dois data sets ordenados por
uma ou mais variáveis são combinados. A diferença é que, neste caso, teremos a
combinação entre um data set de transações com um data set alvo (ou master). O data set
alvo tem o conteúdo modificado pelo de transações.
Durante o confronto entre os data sets será preciso utilizar um destes três
“comandos de ação” (action statements):
- OUTPUT: cria uma nova observação no data set alvo, a partir de uma observação
do data set de transações.
- REPLACE: atualiza uma observação no data set alvo, com os dados de uma
observação do data set de transações.
- REMOVE: exclui uma observação no data set alvo.
87
O próximo exemplo mostra um programa que usa o comando MODIFY, para alterar
um data set com dados de empresas a partir de um data set de transações. Os
comentários sobre o funcionamento do programa são apresentados logo em seguida.
* CRIA O DATA SET ALVO;

DATA EMP_ALVO;
INPUT CNPJ RAZAO $ 9-45 NATJUR CNAE;
DATALINES;
11111111 MARIA GONÇALVES ME 2135 62040
66666666 LIMPSERV SERVIÇOS DE LIMPEZA 2143 81117
22222222 INDUSTRIA DE CALÇADOS RIO DO OURO 2062 15335
44444444 SUPERMERCADO DO BOM PREÇO 2062 47113
33333333 COMÉRCIO DE ROUPAS BOA VISTA 2062 47814
55555555 PREFEITURA DE NEW JERSEY 1031 86101
88888888 MERCADINHO ABCD 2135 47113
;
RUN;
* CRIA DATA SET DE TRANSAÇÕES;

DATA EMP_TRANS;
INPUT CNPJ RAZAO $ 9-45 NATJUR CNAE;
DATALINES;
11111111 MARIA CORREA LTDA 2135 62040
77777777 MERCADO EFGH 2062 47113
55555555 PREFEITURA DE NOVA JÉRSEI 1031 70107
;
RUN;
* ORDENA POR CNPJ;

PROC SORT DATA = EMP_ALVO; BY CNPJ; RUN;
PROC SORT DATA = EMP_TRANS; BY CNPJ; RUN;
* MODIFICA O DATA SET "EMP_ALVO" USANDO O CONTEÚDO DO DATA SET DE TRANSAÇÕES;

DATA EMP_ALVO;
MODIFY EMP_ALVO EMP_TRANS;
BY CNPJ;
SELECT (_IORC_);
WHEN (%SYSRC(_SOK)) REPLACE;
WHEN (%SYSRC(_DSENMR)) DO;
OUTPUT;
_ERROR_ = 0;
END;
END;
RUN;
Os dois primeiros passos do programa são bem simples: no primeiro cria-se o data
set alvo (EMP_ALVO) e no segundo o data set de transações que será usado para alterá-lo.
A seguir os dois data sets são ordenados por CNPJ.
O quinto passo é o que é realmente interessante, pois contém o comando MODIFY
responsável por alterar o conteúdo de EMP_ALVO. A instrução MODIFY EMP_ALVO
EMP_TRANS diz ao SAS que EMP_ALVO será modificado por EMP_TRANS. O MODIFY
requer que os data sets sejam indicados nessa ordem, primeiro o master e depois o data set
de transações. A instrução BY CNPJ, indica que a variável CNPJ será utilizada como chave
de comparação.
A seguir é montado um SELECT que avalia o valor da variável _IORC_
(Input/Output Return Code) que é outra variável automática do passo DATA (assim como
88
_N_ e _ERROR_). Ela contém um valor numérico que indica o status da última ação de
entrada/saída executada. O SAS disponibiliza a macro %SYSRC para converter este valor
numérico para um mnemônico mais fácil de ser memorizado pelo programador. A Tabela
7.2 relaciona os códigos e seus mnemônicos.
Tabela 7.2 – _IORC_ : códigos e mnemônicos

MNEMÔNICO CÓDIGO NUMÉRICO SIGNIFICADO
_SOK 0 A observação do data set de transações
encontrou uma observação
correspondente no data set alvo.
_DSENMR 1230013 A observação do data set de transações
não encontrou uma observação
correspondente no data set alvo durante
o processamento do BY GROUP.
_DSENMTR 1230014 A observação do data set de transações
não encontrou uma observação
correspondente no data set alvo durante
o processamento do BY GROUP e não
é a primeira vez que isso acontece para
o BY GROUP em questão.
Retornando ao nosso programa. Cada transação do arquivo de transações é aplicada

contra o arquivo alvo.
• Se o CNPJ de uma transação é encontrado no arquivo alvo, o programa avaliará
a condição WHEN (%SYSRC(_SOK)) como TRUE e executará a instrução
REPLACE. Esta instrução atualiza o registro de CNPJ correspondente no
arquivo alvo.
• Se o CNPJ de uma transação não é encontrado no arquivo alvo, o programa
avaliará a condição WHEN (%SYSRC(_SOK)) como FALSE. Em seguida avaliará
a condição WHEN (%SYSRC(_DSENMR)) como TRUE e executará dois
comandos: OUTPUT e _ERROR_ = 0. O comando OUTPUT é o que, de fato,
insere um novo registro no arquivo alvo. Já o comando _ERROR_ = 0 é usado
porque o SAS automaticamente coloca o valor 1 nesta variável quando uma
transação do arquivo de transações não é encontrada no arquivo alvo. O SAS,
por default, considera que não achar a chave de uma transação no arquivo alvo é
um “erro” e e acaba gerando várias mensagens no log. Então temos que fazer
_ERROR_ = 0 para avisar ao SAS que o que aconteceu não foi um erro e sim
algo possível de ocorrer em nosso cenário.
A Figura 7.21 apresenta o conteúdo do data set EMP_ALVO após a modificação.
Figura 7.21 – Data Set EMP_ALVO após a modificação
89
O LOG do SAS mostra a quantidade de registros inseridos, excluídos e atualizados
(Figura 7.22).
NOTE: The data set WORK.EMP_ALVO has been updated. There were 2
observations rewritten, 1 observations added and 0 observations
deleted.
Figura 7.22 – Log do SAS
A seguir, um exemplo de trecho de programa que utiliza o MODIFY para apagar

registros.
* APAGA REGISTROS DO DATA SET "EMP_ALVO";

* USANDO O CONTEÚDO DO DATA SET DE TRANSAÇÕES;
DATA EMP_ALVO;
MODIFY EMP_ALVO EMP_TRANS;
BY CNPJ;
IF _IORC_ = %SYSRC(_SOK) THEN REMOVE;
RUN;
Lição 67 – Arrays
A Linguagem SAS suporta a utilização de arrays (vetores e matrizes) dentro do

passo DATA, com o objetivo principal de simplificar a forma como podemos nos referir
a um grupo de variáveis relacionadas. Uma vez criado, um array pode ser manipulado de
maneira semelhante a feita por qualquer outra linguagem de programação.
Para demonstrar a forma de declarar e utilizar arrays no SAS, considere o arquivo
CSV VENDAS.TXT, mostrado na Figura 7.23, que registra o valor das vendas de 6
produtos, efetuadas por três vendedores de uma loja de departamento hipotética no mês de
abril.
M10,JOÃO,12000.55,12400.98,15999.99,13300.21,13800.12,9200.00
M11,PAULO,15111.12,15232.15,11100.15,12380.00,12322.15,17812.15
M13,ANTONIO,9000.00,12800.35,13500.35,10200.00,10800.13,11999.99
Figura 7.23 – Arquivo “VENDAS.TXT”
Considere um programa que será utilizado para calcular o salário a ser pago para
cada vendedor. A seguinte regra será utilizada: todo vendedor ganha R$ 480,00 somados ao
valor de uma comissão. Se o valor das vendas de um produto for inferior à 12000 reais, o
vendedor recebe comissão de 2% referente ao produto em questão, caso contrário a
comissão é de 3%. O programa SAS a seguir gera um data set com os valores das
comissões para cada vendedor, utilizando um array no processo de cálculo.
DATA FOLHA_SALARIAL (KEEP = MATRICULA NOME SALARIO);
*ETAPA 1 – LEITURA DO ARQUIVO “VENDAS_ABRIL.TXT”;

INFILE 'C:\TMP\VENDAS_ABRIL.TXT' DLM=',' DSD;
INPUT MATRICULA $ NOME $ VENDAPROD1-VENDAPROD6;
90
*ETAPA 2 - DECLARAÇÃO DO ARRAY “VENDAS”;
array VENDAS{6} VENDAPROD1-VENDAPROD6;
*ETAPA 3 - CALCULA A COMISSÃO A SER RECEBIDA USANDO O ARRAY “VENDAS”;

* APÓS O FIM DO LOOP O SALÁRIO PODERÁ SER CALCULADO;
SALARIO = 480; *SALÁRIO INICIAL;

COMISSAO = 0;
DO i = 1 to 6;
IF VENDAS{i} < 12000 THEN
COMISSAO = COMISSAO + VENDAS{i} * 0.02;
ELSE
COMISSAO = COMISSAO + VENDAS{i} * 0.03;
END;
SALARIO = SALARIO + COMISSAO;
FORMAT SALARIO dollar9.2; *FORMATO PARA EXIBIÇÃO DO SALÁRIO;
RUN;
Na primeira etapa do programa, ocorre a leitura do arquivo VENDAS_ABRIL.TXT.

A primeira variável do arquivo corresponde à matrícula do vendedor e a segunda ao seu
nome. A seguir os valores das vendas dos 6 produtos são lidos com o uso da seguinte
sintaxe: VENDAPROD1-VENDAPROD6. Este tipo de sintaxe, dentro do comando INPUT,
serve para fazer com que o SAS declare automaticamente no Program Data Vector
seis variáveis com os nomes VENDAPROD1, VENDAPROD2, VENDAPROD3, VENDAPROD4,
VENDAPROD5 e VENDAPROD6. É importante deixar claro que o uso deste recurso no comando
INPUT - que ainda não havia sido mostrado em outras lições – não representa a declaração
de um array. Na realidade estão sendo declaradas 6 variáveis distintas.
A segunda etapa do programa consiste na declaração do array VENDAS de
tamanho 6.
array VENDAS{6} VENDAPROD1-VENDAPROD6;
No momento da declaração do array é feita uma correspondência entre o mesmo e

as variáveis VENDPROD1-VENDPROD6 (Figura 7.24).
Figura 7.24 – Correspondência entre o array VENDAS e

as variáveis VENDAPROD1-VENDAPROD6 no Program Data Vector
A correspondência das seis variáveis com o array, torna possível o acesso ao

conteúdo de qualquer variável através da referência a um índice do array. É exatamente
isto que é feito na Etapa 3. Veja que o cálculo da comissão para cada funcionário é
realizado através de um loop que analisa o valor das vendas de cada um dos produtos,
91
acumulando os resultados na variável COMISSAO. O data set produzido pelo programa é
apresentado na Figura 7.25 (veja que o comando FORMAT, outra novidade desta lição, faz
com que o valor dos salários seja exibido de uma forma mais elegante).
Figura 7.25 –data set FOLHA_SALARIAL
A sintaxe para a declaração de arrays no SAS é apresentada abaixo:
array nome_do_array{N} elementos;
Onde:
• {N} : determina o número de elementos do array. Também é possível
usar ( ) ou [ ].
• As variáveis às quais o array irá se referir. Se elas não existirem o SAS

irá cria-las. É importante saber que o array não é armazenado no
Program Data Vector, mas as variáveis de referência sempre o são. Os
comandos DROP e KEEP podem ser usados sobre as variáveis de
referência para que elas não sejam copiadas para o data set de saída.
Na Linguagem SAS, existem outros formatos e aplicações para os arrays. É possível

trambém trabalhar com arrays multidimensionais (matrizes). O tutorial de [Stroupe 2007]
aborda estes temas.
Lição 68 – Macro Variáveis
As variáveis criadas em um passo DATA possuem escopo local. Isto quer dizer que
as variáveis “nascem” e “morrem” dentro do passo em que foram declaradas e, por isso,
não podem ter o seu conteúdo levado para um passo DATA ou PROC subseqüente.
Felizmente, a linguagem SAS dispõe de um recurso chamado macro variável para
contornar este problema. Resumidamente, pode-se dizer que uma macro variável é uma
estrutura que possui as seguintes características:
• Possui escopo global, ou seja, pode ser enxergada por qualquer passo DATA ou
PROC de um programa.
• Possui o nome prefixado por &.
O comando %LET é o responsável pela criação de macro variáveis. Sua sintaxe é:
%LET nome_da_macro_variável = valor;
Alguns exemplos:
92
%LET PI = 3.14;
%LET EMPRESA = Universidade Federal Fluminense;
Observe que não é necessário utilizar aspas para representar um valor que possui
espaços (isso só é requerido quando o valor possui espaços em branco à esquerda).
Todo programa que possui uma macro variável ou uma macro (ver lição 68) possui
um passo adicional de compilação, executado pelo macro processador do SAS
[Slaughter e Delwiche 2003], [SAS Macro 1997]. Antes do SAS compilar e executar cada
passo do programa, ele passa todos os processamentos de macro para o macro processador.
Este, por sua vez, “resolve” as macros, transformando-as em código SAS. Melhor
explicando: o que o processador SAS faz é, simplesmente, substituir, dentro do código de
um passo (DATA ou PROC), as referências a uma macro pelo texto que estiver a ela
associado (ex: antes de compilar o SAS troca todas as referências de &PI por 3.14). É por
este motivo que os manuais de referência dizem que “uma variável macro é sempre do tipo
caractere” (na verdade ela armazena um texto que será usado para substituir referências,
mesmo que esse texto seja um número como 3.14!). A seguir um exemplo que mostra a
aplicação de macro variáveis.
%LET PI = 3.14;
%LET CALC1 = ÁREA DO CÍRCULO;
%LET CALC2 = VOLUME DA ESFERA;
*monta data set com área do círculo de raios entre 1 e 10;
DATA CIRCULO;
DO raio=1 to 10 by 1;
area = &PI * (raio ** 2);
msg = "&CALC1 DE RAIO " || PUT(raio,2.);
OUTPUT;
END;
RUN;
*monta data set com volume da esfera de raios entre 1 e 10;
DATA ESFERA;
DO raio=1 to 10 by 1;
area = 4/3 * &PI * (raio ** 3);
msg = "&CALC2 DE RAIO " || PUT(raio,2.);
OUTPUT;
END;
RUN;
Inicialmente são declaradas três macro variáveis fora dos passos DATA do
programa. O objetivo é utilizá-las como constantes ao longo do programa. No processo de
compilação de cada passo, desta vez haverá uma etapa inicial feita pelo macro
processador, para substituir as referências às macros pelos seus valores. Melhor explicando:
antes da compilação do passo DATA CIRCULO (primeiro passo DATA do programa), o
macro processador substituirá as referências às variáveis &PI, &CALC1 pelos valores 3.14
e ÁREA DO CÍRCULO, respectivamente. Depois disso é que o passo DATA CIRCULO
será, de fato, compilado e executado pelo SAS. A seguir a mesma coisa será feita com
relação ao passo DATA ESFERA (segundo passo DATA do programa). Primeiro o macro
processador substituirá as referências às variáveis variáveis &PI, &CALC2 pelos valores
3.14 e VOLUME DA ESFERA, respectivamente. Então compilará e executará o passo
DATA ESFERA. O resultado é apresentado nas Figuras 7.26 e 7.27.
93
Figura 7.26 – Data set CIRCULO
Figura 7.27 – Data set ESFERA
IMPORTANTE: não esqueça que as referências às macro variáveis são sempre resolvidas pelo
processador de macros antes da execução de um passo DATA ou PROC.
Lição 69 – Macro Variáveis Dinâmicas - CALL SYMPUT
No exemplo anterior as macro variáveis foram declaradas fora dos passos DATA e
utilizadas como constantes. No entanto, uma aplicação bem mais interessante para as macro
variáveis é feita pela rotina CALL SYMPUT. Esta rotina cria uma variável macro
dinamicamente, ou seja, a partir do valor de uma variável declarada dentro de um passo
DATA. Com isso, torna-se possível transferir informações de um passo DATA para
outro. A sintaxe da rotina CALL SYMPUT é apresentada a seguir:
CALL SYMPUT (“nome_da_macro_variável”, valor);
Veja que o nome da macro variável a ser criada deve estar entre aspas. No
parâmetro valor, podemos especificar tanto uma constante literal, um número ou uma
variável do passo DATA. O próximo exemplo demonstra o uso da rotina CALL SYMPUT.
A explicação encontra-se no próprio código do programa. A Figura 7.25 apresenta o
resultado da execução.
94
*CRIA O DATA SET COM NOME E SALARIO DE EMPREGADOS;
DATA EMPREGADOS;
INPUT NOME $ 1-10 SALARIO;
DATALINES;
J.LENNON 1500
B.MARLEY 500
C.BERRY 5000
J.PAGE 3000
J.STRUMMER 2500
;
RUN;
*ORDENA O DATA SET;

PROC SORT; BY SALARIO;
*OBTÉM O MAIOR SALÁRIO E ARMAZENA NA MACRO VARIÁVEL “MAIOR_SAL”;

DATA _NULL_;
SET EMPREGADOS;
BY SALARIO;
IF LAST.SALARIO THEN CALL SYMPUT("MAIOR_SAL", SALARIO);
RUN;
*ALTERA O DATA SET EMPREGADOS CRIANDO UMA VARIÁVEL;

*ADICIONANDO VARIÁVEL COM A DIFERENÇA ENTRE O MAIOR SALÁRIO;
*E O SALÁRIO DO FUNCIONÁRIO;
DATA EMPREGADOS;
SET EMPREGADOS;
DIFERENCA = &MAIOR_SAL - SALARIO;
RUN;
Figura 7.28 – Data set EMPREGADOS
A documentação completa sobre a rotina CALL SYMPUT e outras rotinas de macro

pode ser encontrada em [SAS Macro 1997].
Lição 70 – Macros
Uma macro do SAS é um trecho de código que aceita parâmetros (de entrada e
saída), pode ser armazenado em um arquivo em separado e compartilhado por diversos
programas SAS. Ou seja, uma macro é o recurso do SAS que permite a reutilização de
código.
As macros parecem um pouco com as sub-rotinas do Visual Basic ou as procedures
da Linguagem Pascal. No entanto a maneira com que o SAS compila e executa as macros é
completamente diferente do processo usado nestas linguagens. Na realidade os SAS faz
com as macros a mesma coisa que faz com as macro variáveis: usa o macro processador
95
para substituir o texto da macro por código SAS antes de compilar e executar um passo
DATA ou PROC. A sintaxe para a declaração de macros é apresentada a seguir:
%MACRO nome_da_macro(Param1, ... , Paramn);

comando1;
...
comandon;
%MEND nome_da_macro;
Todos os parâmetros funcionam como parâmetros de entrada e saída (IN OUT). O

exemplo a seguir mostra uma macro usada para converter uma temperatura em graus
Celsius para graus Fahrenheit. O programa gera uma tabela de equivalência de
temperaturas, variando de –100oC a +100oC (Figura 7.29).
*macro ConvTemp: converte temperatura em graus Celsius para Fahrenheit;

%macro ConvTemp(C, F);
&F = &C * 1.8 + 32;
%mend ConvTemp;
*este passo DATA usa a macro ConvTemp para gerar tabela de equivalência;
*de valores de temperatura em graus Celsius e Fahrenheit;
DATA TABELA_TEMPERATURAS;
DO Celsius=-100 TO 100 BY 10;
%ConvTemp(Celsius, Fahrenheit);
OUTPUT;
END;
RUN;
Figura 7.29 – Data set TAB_TEMPERATURAS
96
Algumas considerações importantes. Dentro do código da macro, os parâmetros
devem ser referenciados com o uso do caractere & antes de seu nome (no exemplo &C e
&F). Para que a macro possa ser usada, é preciso chamá-la, no passo DATA ou PROC
utilizando o caractere % (no exemplo, %ConvTemp(Celsius, Fahrenheit))
Lição 71 – Macros – Como Funcionam?
Embora, aparentemente, uma macro pareça funcionar como uma sub-rotina ou

procedure comum de linguagens como Pascal, PL/SQL, FORTRAN ou Visual Basic, na
verdade ou seu processo de compilação e execução é completamente diferente. Na
Linguagem SAS a chamada a uma macro implica simplesmente na substituição da
referência a macro pelo texto a ela associado dentro do passo DATA ou PROC. Esta
substituição é realizada pelo macro processador, da mesma maneira que é feito o tratamento
de macro variáveis.
De uma maneira simples, pode-se dizer que um passo DATA ou PROC que possua
uma chamada a macro é executado pelo SAS em três etapas:
1. O macro processador substitui a referência à macro pelo texto a ela associado.

2. O compilador SAS compila o passo DATA ou PROC.
3. O passo é executado.
Para que isto fique mais claro, apresentaremos um exemplo “etapa-por-etapa”, que
explica o processo de execução do passo DATA do programa abaixo (é o mesmo
apresentado na lição anterior).
%macro ConvTemp(C, F);

&F = &C * 1.8 + 32;
%mend ConvTemp;
%ConvTemp(Celsius, Fahrenheit);
OUTPUT;
END;
RUN;
O passo DATA TABELA_TEMPERATURAS possui uma chamada de macro, por isso a

primeira etapa para viabilizar a sua execução consistirá na substituição de
%ConvTemp(Celsius, Fahrenheit) pelo texto associado a esta chamada. Isto é feito pelo
macro processador. Ao final da execução desta etapa, o código do passo
DATA TABELA_TEMPERATURAS terá sido modificado da maneira indicada abaixo. Note que
os parâmetros são substituídos da maneira adequada.
Fahrenheit = Celsius * 1.8 + 32;
OUTPUT;
END;
97
A partir desse ponto o SAS compila e executa o programa da maneira que já foi
descrita no Capítulo 4, utilizando o PDV normalmente.
Uma característica muito interessante de uma macro consiste na possibilidade de
criar bibliotecas de macros. Uma macro pode ser armazenada em um arquivo e usada por
diversos programas. Para que um programa possa fazer uso de uma macro genérica, basta
utilizar o comando %INCLUDE. Exemplo:
%include '\\CursoSAS\macros\calc_dv.sas';
Este exemplo é usado para incluir a macro calc_dv.sas dentro de um programa.

Suponha que esta macro seja uma macro genéricas que serve para calcular o DV de de um
CNPJ. Embora o conceito de macro seja simples, o desenvolvimento de macros é um
processo que, na prática, demonstra-se bastante difícil. Para que um programador SAS
possa desenvolver macros é preciso um pouco de experiência, pois uma macro sofisticada
requer um alto grau de abstração. No entanto a prática também demonstra que as macros
representam um recurso extremamente útil. Por estes motivos, intenciona-se promover, no
futuro, um curso destinado apenas ao desenvolvimento de macros.
Lição 72 – É o Fim!
Este curso introduziu alguns dos principais conceitos relacionados ao

desenvolvimento de programas com o uso da Linguagem SAS. O enfoque principal foi a
apresentação de técnicas para o acesso, integração, transformação e atualização de dados
disponibilizados em diferentes tipos de repositório, desde arquivos texto até bancos
relacionais. O curso também descreveu a forma de funcionamento de algumas das
principais estruturas da Linguagem SAS, como o Program Data Vector, o comando
MERGE e os BY GROUPS, entre outros. Para que você possa conhecer mais sobre a
linguagem (e outros recursos do Sistema SAS) serão relacionados alguns sites que
representam importantes fontes de informação.
• SAS 9.1.3 Help and Documentation: esta é a documentação oficial do Sistema

SAS release 9.1.3, que também é conhecida como SAS OnLineDOC. O link
para acesso é: .http://support.sas.com/documentation/onlinedoc/sas9doc.html
Devido ao SAS ser um produto muito poderoso e sofisticado, por vezes a
navegação por este site torna-se um verdadeiro desafio. A quantidade de
informações disponibilizadas é muito grande e nem sempre é fácil achar o que
realmente desejamos.
• SAS Global Forum: congresso anual que objetiva a troca de experiências entre
usuários SAS e a produção de artigos sobre diversos temas relacionados ao
produto. Alguns exemplos: artigos sobre o uso do comando MODIFY,
comparações entre a PROC SQL e o MERGE, uso do Enterprise Guide,
aplicações do SAS em diversas áreas, etc. A cada ano são produzidos mais de
200 artigos. Anteriormente a conferência era chamada de SUGI. O link do SAS
Global Fórum disponibiliza gratuitamente todos os artigos publicados desde a
conferência de 1997 (SUGI 22). http://support.sas.com/events/sasglobalforum/
98
• SAS Technical Papers: fornecem detalhes técnicos sobre como você pode
executar uma tarefa. Dentre as várias categorias de papers existe uma dedicada
inteiramente ao Base SAS. Link para acesso:
http://support.sas.com/resources/papers/index.html
• MISUG: conferência anual promovida por um grupo de

usuários/programadores SAS (Michigan SAS Users Group). Produz um bom
número de artigos interessantes. Link:
http://www.misug.org/misug_pastproceedings.html
• Sites de Universidades: o Sistema SAS é utilizado em diversas universidades

em todo o mundo. Muitas delas disponibilizam tutoriais bastante interessantes
sobre o SAS. Em [Galster 2006], por exemplo, é possível consultar tutoriais
sobre diversos temas, desde a apresentação do PC SAS até o uso das PROCs do
módulo SAS/STAT.
• FALE COM O AUTOR: caso você deseje esclarecer dúvidas sobre a

linguagem SAS ou possua alguma crítica/sugestão com relação a apostila, entre
em contato com o autor:
 Eduardo Corrêa Gonçalves

DI/CODES/GESEC
 E-mails para contato: eduardo.ence@gmail.com

eduardo.correa@ibge.gov.br
99
Referências
Bennett, P. (2008), “Starting Out With SAS Enterprise Guide”, SAS Global Forum 2008
Proceedings, Paper 169-2008, San Antonio.
Droogendyk, Ian (2008), “Joining DATA: Data Step Merge or SQL?”, SAS Global Forum
2008 Proceedings, Paper 178-2008, San Antonio.
ETL-Tools.Info (2008), “SAS Tutorial - Generation of a Sample Business Datawarehouse

Scenario”, disponível em http://etl-tools.info/en/sas_tutorial/tutorial.htm.
Fernandez, George (2002), “Data Mining using SAS applications”, CRC Press.
Galster, Dwight (2006), “SAS Tutorial”, Dept. of Math and Statistics, South Dakota State
University, disponível em http://learn.sdstate.edu/Dwight_Galster/.
Garrido, Kita, Reeve, Kent e Repole, Warren (1996), “SAS Fundamentals: a

Programming Approach Course Notes”. SAS Press.
Harrington, Timothy J. (2002), “An Introduction to SAS PROC SQL”, SUGI 27

Proceedings, Paper 070-27, Orlando.
Holland, Philip R. (2007), “Saving Time and Money Using SAS”. SAS Press.
Holland Numerics Limited (2008), “Frequent Asked Questions about SAS Software”,
disponível em http://www.hollandnumerics.co.uk/sasfaq/SASFAQ1.HTM.
Howard, Neil (2004), “How SAS Thinks or Why the DATA Step Does What it Does”,
SUGI 29 Proceedings, Paper 252-29, Montreal.
Hu, Weiming (2004), “Top Ten Reasons to Use PROC SQL”, SUGI 29 Proceedings,
Paper 042-29, Montreal.
Johnson, Jim (2003), “The Use and Abuse of the Program Data Vector”, MISUG 2003
Proceedings, disponível em http://www.misug.org/mifolder/JJohnson_PDV.pdf.
Lauderdale, Kirsty (2007), “PROC SQL – The Dark Side of SAS?”, SAS Global Forum
Mack, Curtis (2006), “Improve Database Transaction Processing Using MODIFY, the
Most Under-Appreciated Data Step File Handling Statement”, SUGI 31 Proceedings, Paper
264-31, Califórnia.
SAS Macro (1997), “SAS Macro Language: Reference, First Edition”. SAS Press.
Slaughter, Susan J. e Delwiche, Lora D. (2003), “The Little SAS Book: a Primer”. 3a
Edição, SAS Press.
100
Slaughter, Susan J. e Delwiche, Lora D. (2006), “The Little SAS Book for Enterprise
Guide 4.1”. SAS Press.
Slaughter, Susan J. e Delwiche, Lora D. (2008), “Writing Code in SAS Enterprise

Guide”, SAS Global Forum 2008 Proceedings, Paper 184-2008, San Antonio.
Stroupe, Jane (2007), “Adventures in Arrays: a Beginning Tutorial”, SAS Global Forum
TS-644 (2000), “Everything You Wanted to Know about Merge but Were Afraid to Ask”.
SAS Technical Support, TS-DOCS, TS-664.
TS-668 (2001), “SAS Dates, Times, and Interval Functions”. SAS Technical Support, TS-
DOCS, TS-668.
TS-705 (2004), “The Fundamentals of MERGE”. SAS Technical Support, TS-DOCS, TS-
705.
Whitlock, Ian (2007), “How to Think Through the SAS Data Step”, SAS Global Forum
2007 Proceedings, Paper 208-2007, Orlando.
101
Anexo A – Data Set do Censo de Washington
A base do Censo de Washington – também conhecida como adult database ou
census income data set – encontra-se disponibilizada para download no repositório de
bancos de dados da Universidade da Califórnia7. Trata-se de um arquivo seqüencial no
formato texto que contém dados provenientes do censo que foi realizado no ano de 1990,
na cidade de Washington nos Estados Unidos. O arquivo foi transformado em um data set
SAS para utilização em nosso curso.
Cada observação apresenta informações relativas a um indivíduo entrevistado pelo
censo. O arquivo é composto por 30.162 registros, extraídos de maneira aleatória da base
de dados original do censo. Para cada pessoa entrevistada, são apresentados dados a
respeito de 9 variáveis, que indicam, entre outras características, a idade, educação, estado
civil e tipo de ocupação de cada pessoa. Além disso, existe uma variável chamada
IncomeClass que é utilizada para especificar se o entrevistado possui renda anual superior a
US$ 50.000,00. A descrição do arquivo é apresentada a seguir. As variáveis Age e
HoursPerWeek são numéricas e as demais do tipo caractere.
ATRIBUTO DESCRIÇÃO CONJUNTO DE VALORES

POSSÍVEIS PARA O ATRIBUTO
Age Idade Entre 17 e 90.
Sex Sexo Male

Female
Race Raça Amer-Indian-Eskimo.
Asian-Pac-Islander.
Black.
Other.
White.
MaritalStatus Estado Civil Divorced
Married
Never-married
Separated
Widowed
HoursPerWeek Quantidade de Horas Entre 01 e 99.
Trabalhadas por
Semana
Education Escolaridade 10th
11th
12th
1st-4th
5th-6th
7th-8th
9th
Assoc-acdm
Assoc-voc
7
UCI Machine Learning Repository - http://mlearn.ics.uci.edu/MLRepository.html
102
Bachelors
Doctorate
HS-grad
Masters
Preschool
Prof-school
Some-college
Occupation Tipo de Ocupação Adm-clerical

Armed-Forces
Craft-repair
Exec-managerial
Farming-fishing
Handlers-cleaners
Machine-op-inspct
Other-service
Priv-house-serv
Prof-specialty
Protective-serv
Sales
Tech-support
Transport-moving
NativeCountry País de Origem Cambodia
Canada
China
Columbia
Cuba
Dominican-Republic
Ecuador
El-Salvador
England
France
Germany
Greece
Guatemala
Haiti
Holand-Netherlands
Honduras
Hong
Hungary
India
Iran
Ireland
Italy
Jamaica
Japan
Laos
103
Mexico
Nicaragua
Outlying-US(Guam-USVI-etc)
Peru
Philippines
Poland
Portugal
Puerto-Rico
Scotland
South
Taiwan
Thailand
Trinadad&Tobago
United-States
Vietnam
Yugoslavia
IncomeClass Renda Anual <=50K
(igual ou inferior a US$ 50.000,00)
> 50K
(superior a US$ 50.000,00)
104

Idioma

Apostila Curso SASFree

Enviado por

Dados do documento

Descrição:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Descrição:

Direitos autorais:

Formatos disponíveis

Apostila Curso SASFree

Título original:

Enviado por

Descrição:

Direitos autorais:

Formatos disponíveis

Introdução à

• Apresentação do Ambiente SAS

Eduardo Corrêa Gonçalves

I. Conhecendo o Sistema SAS............................................................................................... 5

Lição 1 – O que é SAS?

Lição 2 – SAS: Uma Breve História

O SAS foi criado por um grupo de pesquisadores da North Carolina State

Lição 3 – A Arquitetura SAS

O sistema SAS possui uma arquitetura bastante sofisticada e, infelizmente, nada

• Possui uma sintaxe é simples (fácil de aprender) e “econômica”. Normalmente um

• Possui centenas de funções e procedures pré-definidas (built-in) para a extração,

• Suporta o uso das linguagens SQL e XML;

• Suporta a criação de macros (rotinas reutilizáveis)

IMPORTANTE: este curso possui o objetivo principal de apresentar os principais conceitos e

O pacote Base SAS pode ser estendido através do licenciamento de outros

Figura 1.1 – SAS/ACCESS

SAS/IT (Integration Technologies)

Conclusões e Comentários Finais

Lição 4 – Enterprise Guide

O SAS Enterprise Guide (ou, simplesmente EG) é a principal ferramenta utilizada

Figura 1.2 – Comunicação entre o EG e dois Servidores SAS

Na Figura 1.2, um PC Cliente com o EG instalado, pode se comunicar com dois

Lição 5 – O Ambiente SAS

A Figura 1.2, mostrada na lição anterior, representa um exemplo de como o

Módulos Licenciados no Servidor SAS II (Mainframe)

Lição 6 – Criação de um Projeto no Enterprise Guide

- Iniciar o software (e fechar a janela de boas vindas); ou

Figura 2.1 – Tela Principal do Enterprise Guide

Observe a janela Project Explorer, localizada no canto esquerdo. Ela é responsável

Lição 7 – Configuração de Projetos

As configurações dos projetos criados no EG podem ser feitas através do menu

1. Definição do Formato para Apresentação dos Resultados: depois de acessar o

Figura 2.2 – Definição do Formato dos Resultados em HTML

Lição 8 – Hello World – o Primeiro Programa SAS

2. Alterar o Nome do Programa: é possível renomear qualquer programa inserido

3. Digitação do Programa: digite, na janela do editor, o código apresentado a seguir.

* cria um "data set" chamado Hello. Ele conterá;

1. Toda instrução SAS é encerrada com um ponto-e-vírgula (“ ; ”).

2. Os comentários podem ser definidos entre os símbolos “/*” e “*/” ou entre os

4. Execução do Programa: Agora que o programa está pronto, basta executá-lo.

Figura 2.5 – Executando “ProgHello” no Servidor SERVIDOR I

a. O primeiro nó chamado Log apresenta informações a respeito da execução

b. O segundo nó, chamado HELLO, representa o data set criado como

Figura 2.6 – O Data Set HELLO

OBSERVAÇÃO: na versão 2 do Enterprise Guide (anteriormente utilizada) os projetos são salvos

Lição 9 – Data Sets SAS

A seguir algumas características dos data sets SAS:

Lição 10 – Libraries SAS

Uma library SAS é um repositório de data sets SAS.

1. Insira um novo nó de código em seu projeto, digite e execute o programa abaixo.

2. Após a execução do programa, acesse a janela de servidores (servers). Expanda o

As outras libraries - MAPS, SASHELP, SASUSER e WORK são criadas

Lição 11 – DATA e PROC: os Dois Passos de um

Figura 2.9 – um Programa SAS Típico

Programa Exemplo - DATALINES

* Programa 2.3: cria um data set e produz relatório a partir do mesmo;

OBSERVAÇÃO: a Linguagem SAS não é case-sensitive, ou seja, os comandos podem ser

O programa-exemplo possui um passo DATA (linhas 3-10) e um passo PROC

2. Os comentários podem ser definidos entre os símbolos “/” e “/” ou entre os