ABAP para Funcionais

Capítulo 1 - Introdução ao ABAP
Objeto de desenvolvimento
Um objeto de desenvolvimento é qualquer coisa criada por um desenvolvedor. Exemplos de objetos de
desenvolvimento são: programas, telas, tabelas, visualizações, estruturas e mensagens.
Tipos de programas ABAP

Há dois tipos de programas ABAP: Report e Dialog
Reports
O Objetivo de um report é ler dados a partir do banco de dados e escrevê-los. Ele consiste apenas em duas
telas.
Tela de seleção (parâmetros de entrada)
Lista (saída do relatório)

A tela de seleção é opcional. Nem todos os relatórios tem uma. Entretanto, todos os relatórios geram uma
lista.
Dialogs
Os dialogs são mais flexíveis do que os relatórios e, portanto, são mais complexos no nível de programa. Eles
podem conter qualquer número de telas e a seqüência de telas pode ser alterada dinamicamente em tempo de
execução. Em cada tela, você pode ter campos de entrada, campos de saída, botões e mais de uma área
rolável.
Componentes do Report
Os programas do tipo Report são constituídos por cinco componentes:
Variantes Texto fonte
Características
Documentação
Elementos de
texto
Somente os componentes Texto fonte e características são exigidos. Os demais são opcionais.
Convenções de nome de programa
A empresa em que você trabalha é cliente da SAP. Portanto, os programas criados pela sua empresa são
chamados Client programs.
Os objetos de desenvolvimento de cliente devem seguir as convenções de atribuição de nome que são
predefinidas pela SAP. O nome do programa desenvolvido pelo cliente deve iniciar com a letra Y ou Z.
ABAP Workbench
O sistema R/3 contém ferramentas para criar, visualizar e testar objetos de desenvolvimento. Essas
ferramentas estão localizadas no ABAP Workbench
Entre as ferramentas do workbench estão:
- O Editor ABAP : Para criar, modificar e visualizar o texto fonte do ABAP e outros componentes de
programa.
- O Data Dictionary: Criar, modificar e visualizar tabelas, estruturas, visões, elementos de dados,
ajudas de pesquisa, etc.
- O Function Builder: Criar, modificar e visualizar módulos de função do ABAP

- O Menu Painter e o Screen Painter: Criar, modificar e visualizar a interface de usuário (telas e menu)
dos programas ABAP
Visualizando um programa ABAP

1. No menu principal do R/3, selecione o caminho Ferramentas -> ABAP Workbench -> Desenvolvimento
-> Editor ABAP
2. Uma tela com o título Editor ABAP: 1ª tela é exibida. No campo programa, digite o nome do programa,
marque a opção Características e clique no botão Exibir
3. A tela de características do programa é exibida. Nessa tela temos informações sobre o programa:
4. Volte para a tela inicial do editor, marque a opção Texto fonte e clique em exibir. Na primeira linha
encontraremos sempre o comando report seguido pelo nome do programa. Na terceira linha temos o
comando WRITE que exibirá a string “Hello SAP World” na tela.
Utilizando funções do Editor
A tabela abaixo contém algumas das funções do editor.
Para… Faça…
Escolha o caminho de menu Ajuda -> Ajuda para a
Obter ajuda no editor
aplicação.
Coloque o cursor em uma palavra-chave dentro do
Obter ajuda em qualquer palavra-chave do ABAP
código e pressione F1.
Executar o programa Pressione F8.
Dê um clique com o botão direito do mouse em
Exibir as teclas de função
qualquer lugar na área de tela de uma janela.
Dê um duplo clique nos espaços em branco (no fim
Trazer qualquer linha para a parte superior da tela
da linha).
Escolha o caminho de menu Programa -> Imprimir
Imprimir o programa ou pressione Crtl+P, ou ainda, clique no botão de
imprimir.
Enquanto visualiza a saída, Escolha o caminho de
Imprimir a saída do programa menu Sistema -> Lista -> Imprimir ou pressione
Crtl+P, ou ainda, clique no botão de imprimir.
Escolha o caminho de menu Processar ->
Procurar/substituir ou pressione as teclas Crtl+F, ou
Localizar e repetir a localização
ainda, pressione os botões Procurar e Continuar
procurando
Fazer download de um programa para um arquivo em Escolha o caminho de menu Utilitários -> Outros
seu PC utilitários -> Upload/download -> Download
De qualquer tela, digite /nse38 no campo de comando
Pular diretamente para o editor
e pressione Enter.
Da tela inicial do Editor ABAP, Escolha o caminho de
menu Utilitários -> Editor tela dividida.
Comparar dois programas diferentes Digite o nome dos dois programas e pressione o
botão exibir. Com os dois programas na tela,
pressione o botão Comparar (Ctrl+Shift+F11)
menu Utilitários -> Editor tela dividida.
Digite o nome do programa nos dois campos. No
Comparar dois programas em sistemas diferentes campo de baixo informe também o id do sistema e
pressione o botão exibir. Com as duas versões do
programa na tela, pressione o botão Comparar
(Ctrl+Shift+F11)
menu Utilitários -> Versões -> Administração de
Comparar versões do programa versões. Todas as versões do programa serão
exibidas. Selecione as versões que deseja comparar e
clique no botão Comparar (F8).
Localizando objetos de desenvolvimento
No menu principal do R/3, selecione o caminho Ferramentas -> ABAP Workbench -> Síntese -> Object
Navigator ou transação SE80.
Aparecerá a tela do Object Navigator. No primeiro campo selecione Classe de desenvolvimento. No campo
seguinte entre com o nome da classe de desenvolvimento que se deseja consultar. Clique no botão
Exibir(óculos).
O sistema exibirá todos os objetos de desenvolvimento da classe de desenvolvimento informada.

Clicando-se duas vezes no objeto desejado, o mesmo poderá ser visualizado do lado direito da tela.
Se você estiver procurando um programa e souber os primeiros caracteres de seu nome, poderá localizá-lo a
partir do editor ABAP da seguinte forma:
1. Vá para a tela inicial do Editor ABAP (SE38)

2. No campo Programa, digite os primeiros caracteres de seu nome seguidos por um asterisco.
3. Dê um clique no ícone à direita do campo. A tela Programas é exibida.
4. Dê um duplo clique no programa que você quer visualizar.
ABAP Dictionary – Introdução

O ABAP Dictionary é um utilitário para definir e visualizar objetos de dados. Para chamar o ABAP
Dictionary, execute esses passos:
No menu principal do R/3, selecione o caminho Ferramentas -> ABAP Workbench -> Desenvolvimento ->
Dictionary ou transação SE11.
A tela inicial do ABAP Dictionary será exibida.
Explorando as tabelas e as estruturas
No R/3 uma tabela é uma coleção de linhas. Cada linha contém campos, também chamados de colunas.
Uma tabela armazena dados persistentes. Em outras palavras, se você coloca dados em uma tabela, eles
permanecem aí depois que seu programa finalizar. Eles permanecerão até serem alterados ou excluídos por
seu programa ou outro.
No R/3 uma estrutura é uma descrição de um grupo de campos. Ela descreve os nomes de campo, sua
seqüência e seus tipos e comprimentos de dados. A estrutura não armazena dados.
Exibindo definição de tabela ou estrutura
Para exibir uma tabela ou estrutura no Dictionary:
1. Vá para a tela inicial do ABAP Dictionary (SE11)

2. Insira o nome da tabela ou da estrutura no campo Tabela banco dados
3. Clique no botão Exibir
Visualizando a definição da tabela MARA:
Visualizando a definição da estrutura EMARA:
Exibindo dados na tabela
O R/3 também oferece um utilitário, o Data Browser para permitir que você exiba os dados que existem
dentro de uma tabela. Para utilizá-lo:
1. No menu principal do R/3, selecione o caminho Ferramentas -> ABAP Workbench -> Síntese -> Data
Browser ou transação SE16
A 1ª tela do Data Browser é exibida. Digite o nome da tabela e clique no botão de exibir ou tecle F7, ou
ainda tecle Enter.
A tela de seleção do Data Browser é exibida. Para visualizar todas as linhas da tabela, pressione o botão
Execute ou tecle F8 sem inserir qualquer critério de pesquisa.
Não deixe em branco o campo Núm.máx.ocorrências para exibir todos os registros, a menos que você
realmente pretenda procurar na lista inteira. Para tabelas grandes isso pode consumir muita CPU. A
abordagem preferida é estreitar sua pesquisa, digitando valores nos campos da tela de seleção.
A tela Conteúdo de tabela do data Browser é exibida:
Determinando campos exibidos
Você pode controlar quais campos serão exibidos no Data Browser da seguinte forma:
1. Visualize o conteúdo da tabela no Data Browser
2. Escolha o caminho de menu Opções -> Formato de lista -> Seleção coluna
3. Selecione os campos que você deseja que sejam exibidos na lista e desmarque aqueles que você não
deseja ver
4. Clique no botão Aceitar
Utilizando ABAP para Selecionar e exibir dados
A instrução SELECT
A instrução SELECT recupera registros do banco de dados.
O seguinte código mostra o uso da instrução SELECT:
Esse programa lê todos os registros da tabela lfa1 (Mestre de fornecedores) e escreve o conteúdo do campo
lifnr (Número do fabricante) em ordem crescente.
A instrução REPORT é solicitada como a primeira linha de um report.
A instrução TABLES faz as duas coisas. Primeiro ela aloca uma área de memória (chamada área de trabalho)
identificada como lfa1.Segundo, ela dá acesso à tabela de banco de dados lfa1.
A instrução SELECT começa com um loop. A instrução ENDSELECT marca o fim do loop. As linhas de
código entre SELECT e ENDSELECT são executadas uma vez para cada linha retornada do banco de dados.
As palavras INTO lfa1 são opcionais. Se você deixá-las de fora, a área de trabalho com o mesmo da tabela é
utilizada. Em outras palavras, a linha atual automaticamente entra na área de trabalho lfa1. Por essa razão, ela
é conhecida como área de trabalho da tabela padrão. Nesse caso, a área de trabalho lfa1 é a área padrão para
a tabela lfa1. Por isso, o código do exemplo pode ser simplificado, da seguinte forma:
SELECT * FROM lfa1 ORDER BY lifnr.
A instrução WRITE é executada uma vez para cada linha que é lida da tabela. A / (barra) depois de WRITE
começa uma nova linha.
Note que em seu programa, você tem duas coisas identificadas como lfa1: uma área de trabalho e uma tabela.
As duas tem o mesmo nome – lfa1. A posição do nome lfa1 dentro de uma instrução determina à qual você se
refere à tabela de banco de dados. A segunda ocorrência refere-se à área de trabalho.
Utilizando uma área de trabalho explícita
Você pode definir áreas de trabalho da tabela adicional utilizando a instrução DATA.
O código do programa abaixo mostra como utilizar a instrução DATA para criar uma nova área de trabalho.
Este programa produzirá a mesma saída que o anterior. Observe que nesse exemplo não é necessário definir
uma nova área de trabalho, definimos apenas para ilustrar o conceito.
A instrução DATA define uma nova área de trabalho chamada wa_fornec com a mesma estrutura da tabela
lfa1.
A instrução SELECT lê as linhas da tabela lfa1 movendo seu conteúdo para a área de trabalho wa_fornec.
A instrução WRITE exibe o conteúdo da área de trabalho wa_fornec.
Cláusula WHERE
Para restringir o número de linhas retornadas do banco de dados, uma cláusula WHERE pode ser adicionada à
instrução SELECT. Por exemplo, para recuperar fabricantes que tem número menores que 20, escreveríamos
o código da seguinte forma:
A execução deste programa produzirá a lista abaixo:

Trabalhando com variáveis de sistema
O sistema O sistema R/3 torna as variáveis de sistema disponíveis dentro do seu programa. Você não tem que
definir qualquer coisa para acessá-las, elas estão sempre disponíveis. Todas as variáveis de sistema começam
com o prefixo sy-. Por exemplo, a data atual de sistema está disponível no campo de sistema sy-datum e a
hora atual em sy-uzeit.
Todas as variáveis de sistema são definidas na estrutura syst .
Você pode se referir a uma variável de programa utilizando o prefixo sy- ou syst- . Por exemplo sy-datum
também pode ser codificado como syst-datum. Syst é a única estrutura que tem uma dualidade de prefixos.
Para todas as outras, você deve utilizar o nome completo da estrutura como prefixo.
Existem duas variáveis de sistemas que são muito úteis quando utilizamos a instrução SELECT:
- sy-subrc
Para determinar se a instrução SELECT retornou alguma linha, teste o valor dessa variável após a
instrução ENDSELECT. Se nenhuma linha for localizada o valor de sy-subrc será 4, do contrário o valor
será 0.
Abaixo exemplo da utilização do sy-subrc com a instrução SELECT.
A execução deste programa produzirá o seguinte resultado:
Nesse caso, nenhuma linha coincide com o critério na cláusula WHERE, então depois do ENDSELECT,
o valor de sy-subrc é configurado como 4.
- sy-dbcnt
Para determinar o número de linhas retornado por uma instrução SELECT, teste o valor de sy-dbcnt
depois do ENDSELECT. Você também pode utilizá-la como um contador de loop, entre o SELECT e o
ENDSELECT. Para a primeira linha retornada, o sy-dbcnt será 1, para a segunda será 2 e assim por
diante.
Como exemplo, vamos exibir o código de um programa que imprime números seqüenciais ao lado de
cada fornecedor e imprime o total de linhas selecionadas no final.
Após a execução deste programa a saída seria a seguinte:
Operador de encadeamento
O sinal de dois pontos (:) é chamado operador de encadeamento. Utilize-o para combinar linhas de código
que começam com a mesma palavra ou seqüência de palavras. Coloque a parte comum no começo da
instrução seguido por dois pontos. Então, coloque as partes finais das instruções depois dele, cada uma
separada por uma vírgula.
Por exemplo, para definir duas tabelas, você poderia codificar isto:
TABLES lfa1.
TABLES lfb1.
Ou, você poderia utilizar o operador de encadeamento:
TABLES: lfa1, lfb1.
Exemplo da utilização do operador de encadeamento num programa:

Utilizando a instrução SELECT SINGLE
A instrução SELECT SINGLE recupera um registro do banco de dados. Se você conhece a chave primária
inteira do registro que deseja recuperar, SELECT SINGLE é muito mais rápido e eficiente que
SELECT/ENDSELECT.
O seguinte código mostra o uso da instrução SELECT SINGLE:
Observe que a instrução SELECT SINGLE não começa um loop porque ela apenas retorna uma linha. No
nosso caso, o fornecedor M1000, que especificamos na cláusula WHERE.
Você sempre deve especificar todos os campos da chave primária na cláusula WHERE.
Ao ser executado, o programa de exemplo produzirá a seguinte saída:
Comentários e documentação dos programas
Os comentários nos programas ABAP podem ser feitos de duas maneiras:
- Um * (asterisco) na primeira coluna indica que a linha inteira é um comentário. Ela será exibida numa
cor diferente dentro do editor para indicar que é um comentário de linha inteira..
- “ (aspas duplas) em qualquer lugar em uma linha indicam que o restante da linha é um comentário. O
comentário não ficará de cor diferente, ao contrário do que acontece com o comentário de linha inteira.
O código abaixo exemplifica a utilização de comentários no código dos programas:
Um programa também pode ter informações registradas no componente de documentação. Para visualizar
essas informações vá para a tela inicial do editor, selecione o subobjeto Documentação e clique no botão
exibir.
Uma tela com a documentação será exibida, conforme exemplo abaixo:

Capítulo 2 – Data Dictionary
Tipos de tabelas no R/3
No R/3 há três tipos de tabela: tabelas transparentes, de pool e tabelas cluster.
Tabelas transparentes
Uma tabela transparente tem relacionamento um para um com uma tabela do banco de dados. Sua estrutura no
R/3 corresponde a uma única tabela do banco de dados. A tabela do banco de dados tem o mesmo nome, o
mesmo número de campos e os campos tem os mesmos nomes que a definição de tabela do R/3. Quando
examinar a definição de uma tabela transparente do R/3, você pode considerar que está olhando para a própria
tabela de banco de dados.
As tabelas transparentes são muito mais comuns do que as tabelas de pool ou de cluster. Elas são utilizadas
para armazenar dados de aplicativo. Os dados de aplicativo são os dados mestre ou os dados de transação
utilizados por um aplicativo.
As tabelas de pool e de cluster são normalmente utilizadas para armazenar dados de sistema, como as
informações de configuração de sistema ou dados estatísticos e históricos.
Tabelas de pool
Uma tabela de pool tem um relacionamento muitos para um com uma tabela no banco de dados. A tabela no
banco de dados tem um nome diferente do das tabelas no R/3, tem um número de campos diferente e os
campos também tem nome diferente.
Uma tabela de pool é armazenada no banco de dados junto com outras tabelas de pool em uma única tabela
chamada pool de tabelas.
O R/3 utiliza pools de tabela para armazenar um grande número (dezenas a milhares) de tabelas muito
pequenas (10 a 100 registros cada).
Tabelas de cluster
Uma tabela de cluster é semelhante a uma tabela de pool. Ela tem um relacionamento muitos para um com
uma tabela do banco de dados.
Uma tabela de cluster é armazenada no banco de dados junto com outras tabelas de cluster em uma única
tabela chamada cluster de tabelas.
O R/3 utiliza clusters de tabela para armazenar dados de algumas (2 a 10) tabelas muito grandes.
Restrições nas tabelas de pool e de cluster
As tabelas de pool e de cluster são normalmente criadas somente pela SAP e não pelos clientes,
provavelmente por causa do formato proprietário dessas tabelas dentro do banco de dados e por causa das
restrições técnicas colocadas sobre sua utilização dentro de programas ABAP. Em tabelas de pool e de cluster:
- Não podem ser criados índices secundários
- Não é permitido utilizar as estruturas SELECT DISTINCT ou GROUP BY
- Não é permitido utilizar SQL nativo
- Não é permitido especificar nomes de campo depois da cláusula ORDER BY. A única variação permitida
é ORDER BY PRIMARY KEY
Explorando componentes de tabelas
Uma tabela é composta de campos. Para criar um campo você precisa de um elemento de dados. O elemento
de dados contém os denominadores de campo e a documentação on-line (também chamada ajuda F1) para o
campo.
Uma definição do elemento de dados exige um domínio. O domínio contém a característica técnica de um
campo, como o comprimento do campo e o tipo de dado.
Os domínios e os elementos de dados são reutilizáveis. Um domínio pode ser utilizado em mais de um
elemento de dados, e um elemento de dados pode ser utilizado em mais de um campo e em mais de uma
tabela.
Determinando quando criar ou reutilizar domínios e elementos de dados
Cada sistema R/3 vem com mais de 13.000 domínios preexistentes criados pela SAP. Quando você cria um
novo campo, você deve decidir se cria um novo domínio ou se reutiliza um existente. Para tomar essa decisão,
determine se o tipo ou o comprimento de dados de seu campo deve ser dependente de um campo existente da
SAP. Se o seu campo precisa ser independente, crie um novo domínio. Se o seu campo deve ser dependente,
reutilize um domínio da SAP existente. De forma similar, você deve reutilizar elementos de dados se os seus
denominadores de campo e documentação forem os mesmos utilizados pela SAP.
Visualizando domínios
Para exibir um domínio no Dictionary:

2. Insira o nome do domínio no campo Domínio
Na tela acima temos o campo Descrição breve, que é exibida apenas para os desenvolvedores. O usuário final
nunca a vê.
O campo Categoria dados especifica a representação utilizada internamente pelo banco de dados para
armazenar o valor desse campo. As categorias de dados mais utilizadas são:
Tipo Descrição
CHAR Strings de caracteres ( máximo de 255 caracteres)
DEC Valores decimais (comprimento máximo de 31)
DATS Campo data
TIMS Campo hora
INT1, INT2, INT4 Valores inteiros
NUMC Campo de caracteres que pode conter apenas numéricos
O campo Núm.posições indica o número de bytes necessários ára dar saída ao campo para uma lista ou para
uma tela, incluindo vírgulas, ponto decimal, sinal e quaisquer outros caracteres de formatação.
O campo Rotina conversão permite indicar uma rotina de conversão no domínio. Uma rotina de conversão é
identificada por um nome de cinco posições, e é arquivada como grupo de dois módulos de função. Os
módulos de função têm uma determinada convenção de nomes.
O módulo INPUT executa a conversão do formato de exibição para o formato interno, o módulo OUTPUT a
conversão do formato interno para o formato de exibição.
Visualizando elementos de dados
Para exibir um elemento de dados no Dictionary:

2. Insira o nome do elemento de dados no campo Categoria dados
Na tela acima temos o campo Descrição breve, que será exibida para o usuário final quando ele pressionar F1
para um campo que foi criado utilizando esse elemento de dados.
Os boxes Características e Ajuda para pesquisa referem-se a informações sobre a área de memória onde
estarão armazenados os valores do campo e a definição de ajuda para pesquisa (matchcode) do campo
respectivamente.
A Janela Denom.de campo contém quatro campos de texto. Os primeiros três são a denominação do campo.
Quando qualquer campo aparece numa tela (como campo de entrada), uma das denominações (breve, médio
ou longa) aparecerá a esquerda dele. O conteúdo do campo Título aparecerá como um cabeçalho de coluna no
topo das listas.
Transações para navegação de dados
No sistema R/3, há três transações que podem ser utilizadas para navegação de dados: SE16, SE17, SM30.
Elas são similares sob alguns aspectos e ainda oferecem vários tipos de funcionalidade.
O SE16 é o navegador de dados mais utilizado. Com ele você pode pesquisar registros específicos em tabelas.
O SM30 também podem ser utilizados para exibir e atualizar dados de tabela. Antes que você possa utilizar
essa transação, um programa especial chamado diálogo de manutenção padrão deve ser gerado para a tabela
que você quer exibir.
A SE17 é muito semelhante à SE16 no sentido de que pode ser utilizada para pesquisar linhas específicas
dentro de uma tabela. Entretanto, a SE17 não pode ser utilizada para atualizações. Utilizando a SE16, você
pode especificar critério de pesquisa complexo para um máximo de 40 campos por vez; com a SE17, você
pode especificar critérios de pesquisa simples para qualquer número de campos de uma vez. A SE16 somente
ativa a saída a ser classificada por uma única coluna de uma vez; a SE17 permite que você especifique
qualquer seqüência de tipo ao longo de várias colunas. A SE16 não funcionará para uma tabela que tem um
diálogo de manutenção padrão, mas a SE17 funcionará.
Chaves estrangeiras
Uma chave estrangeira é um campo em uma tabela que está conectado a outra tabela via um relacionamento
de chave estrangeira. O propósito do relacionamento de uma chave estrangeira é validar os dados sendo
inseridos em uma tabela de verificação contra um conjunto válido de valores em outra tabela. A tabela que
contém a chave estrangeira é chamada tabela de chave estrangeira. A tabela que contém o conjunto válido de
valores é chamada tabela de verificação. O campo que é validado e em que o relacionamento de chave
estrangeira é criado é chamado chave estrangeira.
As chaves estrangeiras são verificadas apenas pela interface com o usuário. Elas não são verificadas se você
emitir uma instrução update de banco de dados. Portanto um programa ABAP incorretamente escrito pode
violar a integridade referencial; ele pode inserir valores inválidos nas tabelas de banco de dados. Por essa
razão, programas ABAP que precisam atualizar o banco de dados com dados provenientes de uma outra fonte
que não a interface com o usuário normalmente passam esses dados por uma interface com o usuário a fim de
validá-los (batch input).
Tabelas de texto
Uma tabela de texto é uma tabela que contém descrições “na língua falada” de valores em uma tabela de
verificação. Essas descrições são armazenadas em vários idiomas. A chave primária da tabela de texto é a
mesma que a chave primária da tabela de verificação, com a adição da coluna SPRAS (idioma).
Indices de tabela
Um índice é um mecanismo de eficiência para localizar rapidamente linhas dentro de uma tabela. Cada tabela
do R/3 tem um índice primário construído na chave primária da tabela. O índice comumente utilizado é
análogo ao índice primário de uma tabela. Os índices adicionais são análogos a índices secundários. Para
suportar uma cláusula WHERE em um campo de chave não primária, pode-se definir um índice secundário.
Uma tabela pode ter múltiplos índices secundários.
Para exibir todos os índices de uma tabela, inclusive o primário, siga esses passos:
1. Exiba a definição das tabela
2. Escolha o caminho de menu Saltar -> Índices
3. Clique duas vezes em cima do índice para exibir detalhes
Capítulo 3 - Definição de dados no ABAP
Objetos de dados
Os objetos de dados são posições de memória que você utiliza para armazenar dados enquanto o programa
está sendo executado. Há dois tipos de objetos de dados: modificáveis e não modificáveis. Os tipos de objetos
de dados não modificáveis são as literais e constantes. Os objetos de dados modificáveis são as variáveis,
strings de campo e tabelas internas.
Literais
Um literal é um objeto de dados não modificável. Os literais podem aparecer em qualquer lugar em um
programa e eles são definidos meramente sendo digitados onde necessário. Há quatro tipos de literais:
Literais de string de caractere: São strings que diferenciam letras maiúsculas e minúsculas de qualquer
comprimento incluídas entre aspas simples.
Exemplo: ‘Hello SAP World’.
Literais numéricos: São valores numéricos codificados manualmente com um sinal à esquerda opcional. Eles
normalmente não são incluídos entre aspas. Entretanto, se um literal numérico contiver um decimal, ele deve
ser codificado como uma string de caracter incluída entre aspas simples.
Exemplos: 256
-99
’10.5’
Literais de ponto flutuante: São especificados dentro de aspas simples como

‘<mantissa>E<expoente>’. A mantissa pode ser especificada com um sinal à esquerda
e com ou sem casas decimais e o expoente pode estar com sinal ou sem sinal, com ou sem
zeros à esquerda.
Exemplos: ’99.99E9’
‘-10E-32’
‘+1E09’
Literais hexadecimal: É especificado dentro de aspas simples como se fossem uma string de caractere. Os
valores permitidos são 0-9 e A-F. Deve haver um mesmo número de caracteres na string e todos os caracteres
devem estar em letras maiúsculas.
Exemplos: ‘00’
‘A2E5’
‘F1F0FF’
Definindo variáveis
Duas instruções são comumente utilizadas para definir variáveis em um programa ABAP:
Data e Parameters
Utilizando a instrução DATA para definir variáveis
DATA f1(2) TYPE c.

DATA f2 LIKE f1.
DATA max_value TYPE i VALUE 100.
DATA cur_date TYPE d VALUE '20050615'.
Tipos de dados do ABAP
Há duas categorias principais de dados no ABAP: caracter e numérico.
Tipos de dados de caractere
Os tipos de dados de caractere são mostrados abaixo:
Tipo Descrição Comprimento Comprimento Valores Valor

de interna interno interno válidos inicial
dado padrão máximo padrão
C Caractere 1 65535 Qualquer carac. Em branco
N Texto numérico 1 65535 0-9 0
D Data 8 (fixo) - 0-9 00000000
T Hora 6 (fixo) - 0-9 000000
X Hexadecimal 1 65535 Qualquer carac. Em branco
Comprimento interno são dados em bytes. A coluna Valor inicial padão indica o valor dado à variável por
padrão se você não especificar um valor utilizando a adição VALUE
Tipos de dados de numéricos
Os tipos de dados de numéricos são mostrados abaixo:
Tipo Descrição interna Comprimento Comprimento Decimais Valor

de interno interno máximos inicial
dado padrão máximo padrão
I Inteiro 4 (fixo) - 0 0
P Decimal empacotado 8 16 14 0
F Ponto flutuante 8 8 15 0.0
Os inteiros são utilizados em cálculos simples ou quando nenhuma casa decimal for exigida
As variáveis decimais são utilizados quando é necessário utilizar números com casas decimais
Variáveis de ponto flutuante são sempre aproximadas. Elas podem ser utilizadas para cálculos que exigem
valores muito grandes ou muitos espaços decimais.
Mapeando tipos de dados do Dictionary para tipos de dados do ABAP
Os tipos de dados no ABAP Dictionary são contruídos a partir dos tipos de dados do ABAP. Abaixo
mostramos os tipos de dados do Dictionary e as correspondentes definições de dados no ABAP. n é o
comprimento especificado no domínio, m é o número de casas decimais especificado no domínio e s é o sinal
especificado no domínio.
Dict. data type ABAP data type

ACCP N(6)
CHAR n C(n)
CLNT C(3)
CUKY C(5)
CURR n, m, s P((n + 2) / 2) DECIMALS m [NO SIGN]
DEC n, m, s P((n + 2) / 2) DECIMALS m [NO SIGN]
DATS D
FLTP F
INT1 No corresponding type
INT2 No corresponding type
INT4 I
LCHR n C(n)
LRAW n X(n)
LANG C(1)
NUMC n N(n)
PREC X(2)
QUAN n, m, s P((n + 2) / 2) DECIMALS m [NO SIGN]
RAW n X(n)
TIMS T
UNIT n C(n)
VARC n C(n)
Utilizando a instrução PARAMETERS para definir variáveis
Um parâmetro é um tipo de variável especial que é definida utilizando a instrução parameters. Essa instrução
é muito parecida com a instrução data, mas quando você executar o programa, o sistema exibirá os
parâmetros como campos de entrada em uma tela de seleção antes de o programa realmente começar a ser
executado.
Abaixo segue o exemplo de um report que utiliza a instrução parameters:

A execução deste programa exibirá a uma tela, chamada tela de seleção, onde o usuário irá preencher os
campos antes de pressionar o botão Execute (F8):
Ao ser executado o programa exibirá uma lista conforme os parâmetros informados na tela:
Descrição dos campos de entrada de parâmetro
Na tela de seleção, à esquerda de cada campo de entrada do parâmetro, está a descrição do mesmo. Por padrão
a descrição que aparece é o próprio nome do parâmetro, conforme declarado no programa. Essa descrição
pode ser configurada manualmente na tela do editor, através da opção de menu ir para ->Elementos de textos
-> Textos de seleção
Salvando e executando novamente, a descrição configurada aparecerá na tela.
OBSERVAÇÃO: Sempre utiliza a adição like para definir um parâmetro. Quando você a utiliza, o parâmetro
adquire os seguintes atributos do Dictionary:
- A Ajuda F1 é adquirida a partir do botão Documentation no elemento de dados
- A Ajuda F4 (Matchcode) é adquirida se o parâmetro for referente a um campo que contenha uma tabela
de verificação.
- A Descrição do campo é adquirida do elemento de dados
- As modificações no tipo ou comprimento de dado no Dictionary automaticamente são refletidas pelo
programa
Definindo constantes
Uma constante é quase idêntica a uma variável, exceto quanto ao fato de que seu valor não poderá ser
alterado. Para definir uma constante você utiliza a instrução constants.
Exemplo de definição de constantes:
Constants c1(2) type c value ‘AA’.

Constants c2 like c1 value ‘BB’.
Constants error_threshold type i value 5.
Constants amalgamation_date like sy-datum value ‘20041117’.
Definindo strings de campo

Uma string de campo corresponde a um tipo de variável e é o equivalente de uma estrutura no Dictionary,
porém é definida dentro de um programa ABAP.
Duas instruções são geralmente utilizadas para definir strings de campo em um programa ABAP:
Utilizando a instrução DATA para definir strings de campo

O lista produzida pela execução deste programa ficaria assim:
Utilizando a instrução TABLES para definir strings de campo

Capítulo 4 – Atribuições, conversões e cálculos
Trabalhando com variáveis de sistema
As variáveis de sistema estão disponíveis durante a execução de programas ABAP. Não é necessário defini-
las; elas são automaticamente definidas e estão sempre disponíveis.
A estrutura syst contém as definições de todas as variáveis de sistema.
Para exibir a estrutura syst acesse o Dictionary (transação SE11), digite o nome da estrutura no campo tabela
banco dados e clique em Exibir.
Algumas das variáveis de sistema mais utilizadas:
sy-datum Data atual

sy-uzeit Hora atual
sy-uname Id do usuário atual
sy-subrc Último código de retorno
sy-mandt Client de logon
sy-repid Nome do programa atual
sy-tcode Nome da transação atual
sy-langu Lingua de logon
sy-index Número sequencial dentro de um loop
sy-tabix Número da linha de uma na tabela interna
sy-dbctn Número de linhas retornadas de uma instrução SELECT
Exemplo de utilização de variáveis de sistemas em programa ABAP:

Instruções de atribuição
Uma instrução de atribuição atribui um valor para uma variável ou string de campo. Três instruções de
atribuição são comumente utilizadas: CLEAR, MOVE e MOVE-CORRESPONDING.
- CLEAR
A instrução CLEAR configura o valor de uma variável ou uma string de campo como zero. Se o tipo de
dado for C, o valor por sua vez, será configurado como espaços em branco. Os espaços em branco e os
zeros são valores iniciais padrão de variáveis.
- MOVE
Para mover um valor de um campo para outro, utiliza a instrução MOVE. O conteúdo inteiro ou uma
parte do conteúdo pode ser movida. Em vez de move, você pode usar o operador de atribuição =.
- MOVE-CORRESPONDING
Para mover um campo de uma string de campo para outra, em que os tipos de dados e/ou comprimentos
não correspondam, utilize a instrução MOVE-CORRESPONDING. Ela gera instruções MOVE para
componentes com nomes correspondentes. Os componentes na string de campo de recebimento que não
tenham um nome correspondente na string de campo de envio não serão alterados.
Executando Cálculos
Você pode executar cálculos utilizando os operadores abaixo:
+ Adição
- Subtração
* Multiplicação
/ Divisão
** Exponenciação
DIV Divisão de inteiro
MOD Resto da divisão
Atribuição dinâmica
Um símbolo de campo é um indicador que você pode dinamicamente atribuir a um campo. Depois da
atribuição, você pode utilizar o símbolo de campo em qualquer lugar do seu programa em vez do nome real
do campo. Utilize a instrução field-symbol para definir um símbolo de campo e utilize assign para atribuir um
campo a ele. O nome do símbolo de campo deve começar com o sinal de menor que e terminar com o sinal de
maior que.
O Resultado da execução do programa acima é o seguinte:
Capitulo 5 - Instruções de controle comuns
Instrução IF
- Cada IF deve ter um ENDIF correspondente
- ELSE e ELSEIF são opcionais
- Os parênteses podem ser utilizados. Por exemplo, IF ( f1 = f2 ) or ( f1 = f3 ).
- As variáveis podem ser comparadas com espaços em branco ou zeros utilizando a adição IS INITIAL.
Por exemplo, IF f1 IS INITIAL será verdadeiro se f1 for do tipo C e estiver em branco. Se f1 for de
qualquer outro tipo de dado, a instrução será verdadeira se f1 contiver zeros.
- Para uma negação, NOT deve preceder a expressão lógica. Por exemplo, IF NOT f1 IS INITIAL.
- As variáveis podem ser comparadas com valores nulos utilizando a adição IS NULL. Por exemplo, IF
f1 IS NULL.
Comparações comuns e suas formas alternativas
Comparação Formas alternativas Verdadeiro quando

v1 = v2 EQ v1 é igual a v2
v1 <> v2 NE, >< v1 é diferente de v2
v1 > v2 GT v1 é maior que v2
v1 < v2 LT v1 é menor que v2
v1 >= v2 GE, => v1 é maior ou igual a v2
v1 <= v2 LE, =< v1 é menor ou igual a v2
v1 between v2 and v3 v1 está entre v2 e v3 (inclusive)
not v1 between v2 and v3 v1 não se encontra entre v2 e v3 (inclusive)
Exemplo de utilização de IF no programa
*-----------------------------------------------------------
* Exemplo de utilização de IF
*-----------------------------------------------------------
REPORT zvmtr_gpessoa_15.
* Definição de variáveis
DATA: BEGIN OF s1,
x VALUE '1',
y VALUE '2',
z VALUE '3',
END OF s1,
BEGIN OF s2,
x VALUE '1',
z VALUE '3',
END OF s2.
* Comparações
IF s1-x = s2-x.
WRITE: / s1-x, '=', s2-x.
ELSE.
WRITE: / s1-x, '<>', s2-x.
ENDIF.
IF s1-x BETWEEN s2-x AND s2-z.

WRITE: / s1-x, 'está entre', s2-x, 'and', s2-z.
ELSE.
WRITE: / s1-x, 'não está entre', s2-x, 'and', s2-z.
ENDIF.
* Comparando string de campo

IF s1 = s2.
WRITE: / 's1 = s2'.
ELSE.
WRITE: / 's1 <> s2'.
ENDIF.
* Atenção para este caso

IF 0 = ' '.
WRITE: / '0 = '' '''.
ELSE.
WRITE: / '0 <> '' '''.
ENDIF.
Ao ser executado o programa exibirá a seguinte lista:

Instrução CASE
A instrução CASE executa uma série de comparações:
- Somente as instruções após a primeira correspondência WHEN serão executadas.
- WHEN OTHERS corresponderá se nenhuma WHEN precedente corresponder
- Se WHEN OTHERS não estiver codificada e nenhuma WHEN corresponder, o processamento continuará
com a primeira instrução após ENDCASE.
Exemplo de utilização de CASE no programa
*-----------------------------------------------------------
* Exemplo de utilização de CASE
*-----------------------------------------------------------
data f1 TYPE i.
f1 = 2.
CASE f1.
WHEN 1.
WRITE / 'f1 = 1'.
WHEN 2.
WRITE / 'f1 = 2'.
WHEN 3.
WRITE / 'f1 = 3'.
WHEN OTHERS.
WRITE / 'f1 é diferente de 1, 2 e 3'.
ENDCASE.
Instrução DO
A instrução DO corresponde a um mecanismo de loop básico. Pode ser aplicada com a adição de “N TIMES”,
indicando quantas vezes o loop será executado. Do contrário o loop será executado até que encontre uma
instrução EXIT.
Instrução EXIT
A Instrução EXIT impede que processamentos posteriores ocorram.
Exemplo de utilização de EXIT no programa

*-----------------------------------------------------------
* Exemplo de utilização de DO e EXIT
*-----------------------------------------------------------
DO 100 TIMES.
WRITE:/ sy-index.
IF sy-index = 20.
EXIT.
ENDIF.
ENDDO.
Instrução WHILE
A instrução WHILE corresponde a um mecanismo de loop semelhante ao DO. A diferença é que pode ser
especificada uma condição para o loop.
Exemplo de utilização de WHILE no programa
*-----------------------------------------------------------
* Exemplo de utilização de WHILE.
*-----------------------------------------------------------
WHILE sy-index <= 10.
WRITE:/ sy-index.
ENDWHILE.
Instrução CONTINUE
A instrução CONTINUE é utilizada dentro de um loop . Quando o programa está executando as instruções
dentro de um loop e encontra uma instrução CONTINUE ele interrompe o processamento dentro deste loop e
volta para processar a próxima ocorrência.
Exemplo de utilização de CONTINUE no programa
*-----------------------------------------------------------
* Exemplo de utilização de CONTINUE.
*-----------------------------------------------------------
DO 10 TIMES.
IF SY-INDEX = 1 OR
SY-INDEX = 3 OR
SY-INDEX = 5 OR
SY-INDEX = 7 OR
SY-INDEX = 9.
CONTINUE.
ENDIF.
WRITE:/ sy-index.
ENDDO.

Instrução CHECK
A instrução CHECK é utilizada dentro de um loop. Ela se comporta da mesma forma que a instrução
CONTINUE quando a expressão lógica for falsa, do contrário não fará nada.
Exemplo de utilização de CHECK no programa
*-----------------------------------------------------------
* Exemplo de utilização de CHECK
*-----------------------------------------------------------
DO 10 TIMES.
CHECK sy-index = 2 OR
sy-index = 4 OR
sy-index = 6 OR
sy-index = 8 OR
sy-index = 10.
WRITE:/ sy-index.
ENDDO.
Capitulo 6 – Tabelas internas

Uma tabela interna é uma tabela temporária armazenada na memória do servidor do aplicativo. Ela é criada e
preenchida por um programa durante a execução e é descartada quando o programa termina. Como uma
tabela de banco de dados, uma tabela interna consiste em uma ou mais linhas com uma estrutura idêntica,
mas, diferentemente de uma tabela de banco de dados, ela não pode armazenar dados após o término do
programa. A tabela interna é utilizada como armazenamento temporário para a manipulação de dados.
Uma tabela interna consiste em um corpo, que são as linhas da tabela, e uma linha opcional de cabeçalho
(header).
O cabeçalho da tabela contém a linha com os dados que serão inseridos numa tabela interna, ou a linha
selecionada no momento em que a tabela está sendo manipulada.
Maneiras básicas de definir tabelas internas com e sem uma linha de cabeçalho:
DATA: BEGIN OF it1 OCCURS 0, "tabela interna com cabeçalho

f1,
f2,
f3,
END OF it1.
DATA it2 LIKE lfa1 OCCURS 0. "tabela interna sem cabeçalho
DATA it3 LIKE lfa1 OCCURS 0 WITH HEADER LINE. "com cabeçalho
Adicionando dados em uma tabela interna utilizando a instrução APPEND

A instrução APPEND copia uma única linha de qualquer área de trabalho e a coloca no corpo da tabela
interna, ao final da linhas existentes. A área de trabalho pode ser a linha de cabeçalho ou qualquer outra string
de campo com a mesma estrutura da tabela interna.
O programa abaixo adiciona linhas em uma tabela interna:

*-----------------------------------------------------------
* Tabelas internas - Exemplo de utilização de APPEND
*-----------------------------------------------------------
* Definição da tabela interna

DATA: BEGIN OF ti_consultores OCCURS 0,
numero TYPE i,
nome(20),
modulo(2),
END OF ti_consultores.
* Adiciona linhas na tabela interna

ti_consultores-numero = 1.
ti_consultores-nome = 'George'.
ti_consultores-modulo = 'MM'.
APPEND ti_consultores.
ti_consultores-nome = 'Geraldo'.
ti_consultores-modulo = 'PM'.
ti_consultores-nome = 'Pedro'.
ti_consultores-modulo = 'BW'.
ti_consultores-nome = 'Tanabe'.
* Imprime tabela interna

LOOP AT ti_consultores.
WRITE:/ ti_consultores-numero,
ti_consultores-nome,
ti_consultores-modulo.
ENDLOOP.
Lendo dados a partir de uma tabela interna
Duas instruções são comumente utilizadas para a leitura dos dados a partir de uma tabela interna:
LOOP AT: Para ler várias linhas da tabela interna. O critério de seleção é definido pela adição WHERE. A
variável de sistema SY-TABIX conterá o numero da linha lida.
READ TABLE: Para ler uma única linha da tabela interna. O critério de seleção é definido na adição WITH
KEY.
O programa abaixo seleciona linhas em uma tabela interna:

*-----------------------------------------------------------
* Tabelas internas
* Exemplo de utilização de LOOP AT e READ TABLE
*-----------------------------------------------------------

numero TYPE i,
nome(20),
modulo(2),

* Imprime várias linhas selecionadas da tabela interna

WRITE:/ 'Consultores PM'.
WRITE:/.
LOOP AT ti_consultores WHERE modulo = 'PM'.

ENDLOOP.
WRITE:/.
* Imprime uma única linhas selecionada da tabela interna

WRITE:/ 'Consultor MM'.
WRITE:/.
READ TABLE ti_consultores WITH KEY modulo = 'MM'.
A adição INDEX
A adição INDEX na instrução READ TABLE localiza uma única linha por seu número de linha relativo.
Exemplo: READ TABLE TI_CONSULTORES INDEX 3.  Retorna a terceira linha da tabela interna
A instrução SORT
A instrução SORT ordena uma tabela interna de acordo com os campos especificados.
A adição BINARY SEARCH
Na instrução READ TABLE, sempre que uma tabela estiver ordenada através da instrução SORT a utilização
da adição WITH KEY deve ser seguida pela adição BINARY SEARCH. Isso faz com que a linha seja
localizada com uso de um algorítmo binário de pesquisa, em vez de uma varredura de tabela linear.
O programa abaixo ordena a tabela interna, seleciona linhas e imprime:
*-----------------------------------------------------------
* Tabelas internas
* Exemplo de utilização de SORT E BINARY SEARCH
*-----------------------------------------------------------

numero TYPE i,
nome(20),
modulo(2),

* Ordena tabela interna

sort ti_consultores by modulo.
* Imprime todas as linhas da tabela ordenada

WRITE:/ 'Consultores'.
WRITE:/.
ENDLOOP.
WRITE:/.
* Imprime uma única linhas selecionada da tabela interna

WRITE:/ 'Consultor MM'.
WRITE:/.
READ TABLE ti_consultores WITH KEY modulo = 'MM' binary search.

Modificando linhas de uma tabela interna utilizando a instrução MODIFY
Para modificar o conteúdo de uma ou mais linhas de uma tabela interna, utilize a instrução MODIFY
O programa abaixo modifica linhas de uma tabela interna:
*-----------------------------------------------------------
* Tabelas internas - Exemplo de utilização de MODIFY
*-----------------------------------------------------------

numero TYPE i,
nome(20),
modulo(2),

* Imprime linhas da tabela interna

WRITE:/ 'Tabela original'.
ENDLOOP.
* Modifica linhas da tabela interna

ti_consultores-modulo = 'BC'.
MODIFY ti_consultores.
ENDLOOP.
WRITE:/.

WRITE:/ 'Tabela alterada'.
ENDLOOP.
Excluindo linhas de uma tabela interna

Para eliminar linhas de uma tabela interna, você poderá utilizar as seguintes instruções:
REFRESH:  Exclui todas as linhas de uma tabela interna
CLEAR:  Exclui todas as linhas de uma tabela interna

Limpa linha de cabeçalho da tabela interna
DELETE:  Exclui a linha da tabela interna que está selecionada , ou seja, que foi transferida para a
linha de cabeçalho.
O programa abaixo utiliza as instruções de eliminação de linhas de uma tabela interna:
*--------------------------------------------------------------------
* Tabelas internas - Exemplo de utilização de CLEAR, REFRESH e DELETE
*--------------------------------------------------------------------

numero TYPE i,
nome(20),
modulo(2),


WRITE:/ .
WRITE:/ 'Tabela de consultores'.
ENDLOOP.
* Deleta primeira linha da tabela

DELETE ti_consultores.
EXIT.
ENDLOOP.

WRITE:/ .
WRITE:/ 'Tabela sem a primeira linha'.
ENDLOOP.
* Deleta todas as linhas da tabela.

REFRESH ti_consultores.
* Imprime linha de cabeçalho

WRITE:/ .
WRITE:/ 'Cabeçalho da tabela'.
* Limpa cabeçalho
clear ti_consultores.
WRITE:/ .
WRITE:/ 'Cabeçalho da tabela deletado'.

WRITE:/ .
WRITE:/ 'Tabela com linhas deletadas'.
ENDLOOP.
Capitulo 7 – Modularização
As unidades de modularização são utilizadas para eliminar código redundante dentro do
programa e torná-lo mais fácil de ler.
Eventos
Os programas ABAP são baseados em eventos. Um bom entendimento sobre eles é a chave
para um bom entendimento de ABAP.
Um evento é uma tag que identifica uma seção de código associada com um evento.
Começa com o nome de evento e termina quando o próximo nome é encontrado.
Alguns eventos utilizados em reports:
INITIALIZATION
START-OF-SELECTION
END-OF-SELECTION
TOP-OF-PAGE
END-OF-PAGE
Independente da ordem em que os eventos são colocados no programa, o INITIALIZATION sempre será
executado em primeiro lugar, seguido pelo START-OF-SELECTION e END-OF-SELECTION. O TOP-OF-
PAGE será executado quando encontrar a primeira instrução WRITE.
Exemplo de utilização de eventos em programa ABAP.

*--------------------------------------------------------------------
* Exemplo de utilização EVENTOS
*--------------------------------------------------------------------
REPORT zvmtr_gpessoa_26 LINE-COUNT 65(3) NO STANDARD PAGE HEADING .
* Declaração de variável
DATA: var TYPE p.
* Evento start of selection

START-OF-SELECTION.
WRITE:/ 'Evento START-OF-SELECTION'.
DO 150 TIMES.
var = var + 1.
WRITE:/ var.
ENDDO.
* Evento end of page

END-OF-PAGE.
WRITE:/ 'FIM DA PAGINA'.
* Evento initialization
INITIALIZATION.
var = 1.
WRITE:/ 'Evento INITIALIZATION'.
WRITE:/ var.
ULINE.
* Evento top of page

TOP-OF-PAGE.
WRITE:/ 'Exemplo de utiização dos EVENTOS',
/ 'VEM - Varig Engenharia e Manutenção'.
ULINE.
Sub-rotinas
Uma sub-rotina é uma seção de código reutilizável. É como um miniprograma que pode ser chamado de outro
ponto em seu programa. Dentro dele você pode definir variáveis, executar instruções, computar resultados e
escrever saída. Para definir uma sub-rotina é utilizada a instrução FORM para indicar o início da sub-rotina e
ENDFORM para indicar o fim. Para chamar uma sub-rotina, utilize a instrução PERFORM.
Na utilização de sub-rotinas é possível utilizar parâmetros, que são variáveis através das quais a subrotina
recebe e/ou devolve valores.
Exemplo de programa com sub-rotina.
*--------------------------------------------------------------------
* Exemplo de programa com sub-rotina
*--------------------------------------------------------------------
REPORT zvmtr_gpessoa_27 .
* Tela de seleção
PARAMETERS: numero1(1) TYPE p,
numero2(1) TYPE p,
numero3(1) TYPE p.
START-OF-SELECTION.
PERFORM imprime_tabuada USING numero1.
*---------------------------------------------------------------------*
* FORM imprime_tabuada *
*---------------------------------------------------------------------*
FORM imprime_tabuada USING p_num.
DATA: var1 TYPE i.
DATA: var2 TYPE i.
WRITE:/ 'Tabuada de ', p_num.

WRITE:/.
DO 9 TIMES.
var1 = var1 + 1.
var2 = var1 * p_num.
WRITE:/ p_num, ' X', var1, ' = ', var2.
ENDDO.
ULINE.
ENDFORM.
Ao ser executado o programa exibirá a seguinte tela de seleção:

Entrando com um número qualquer no campo e clicando no botão Executar, o programa exibirá a seguinte
lista:.
Instrução Include
Um Programa Include é um aplicativo em que o conteúdo é projetado para ser utilizado por outro programa.
Um programa include deve ser estar especificado como tipo I nas características do programa. Ele pode estar
incluído em um ou mais programas.
Exemplo de utilização de include
Programa executável (zvmtr_gpessoa_28)

*--------------------------------------------------------------------
* Exemplo de programa com INCLUDE
*--------------------------------------------------------------------
TABLES: lfa1, lfb1.
PARAMETERS p_lifnr LIKE lfa1-lifnr.
WRITE: 'Início da lista'.

WRITE:/.
INCLUDE zvmtr_gpessoa_28_01.
INCLUDE zvmtr_gpessoa_28_02.
WRITE: 'Fim da lista'.
Primeiro programa include ( zvmtr_gpessoa_28_1)

*----------------------------------------------------------------------*
* INCLUDE ZVMTR_GPESSOA_28_01 *
*----------------------------------------------------------------------*
select single * from lfa1 where lifnr = p_lifnr.
WRITE:/ 'Empresas p/ fornecedor', p_lifnr, '-', lfa1-name1.
Segundo programa include ( zvmtr_gpessoa_28_2)

*----------------------------------------------------------------------*
* INCLUDE ZVMTR_GPESSOA_28_02 *
*----------------------------------------------------------------------*
select * from lfb1 where lifnr = lfa1-lifnr.
write:/ lfb1-bukrs.
endselect.
WRITE:/.
write:/ lfb1-bukrs.
endselect.
Ao ser executado o programa exibirá a seguinte tela de seleção:

Entrando com um fonecedor no campo e clicando no botão Executar, o programa exibirá a seguinte lista:.
Módulos de função
Um módulo de função é muito semelhante a uma sub-rotina externa sob os seguintes aspectos:
- Ambos existem dentro de um programa externo

- Ambos ativam os parâmetros a serem passados e retornados
As diferenças importantes entre módulos de função e sub-rotinas externas são as seguintes:
- Os módulos de função tem uma tela especial utilizada para definir parâmetros
- Para chamar um módulo de função, é utilizada uma sintaxe diferente da empregada para chamar uma
sub-rotina
- Para sair de um módulo de função, é utilizada a instrução RAISE em vez de CHECK, EXIT ou STOP.
Grupo de funções
Um grupo de função é um programa que contém módulos de função. Um grupo de funções é composto por:
- Um include superior (top)

Este programa é conhecido como top include e conterá as definições globais de dados. Estas são
definições válidas para todos os módulos de função dentro do grupo
- Um include UXX
Este programa é protegido, e ao contrário do include top, não permite modificações. O sistema colocará
automaticamente no UXX, um include para cada módulo de função que for criado. Dentro de cada
include mencionado no UXX está o código–fonte para um módulo de função.
Através da transação SE80 pode-se visualizar um grupo de funções, conforme abaixo:

Function Builder
Para acessar diretamente uma função, utilizamos a transação SE37, conforme abaixo:
Entre com o nome da função que deseja visualizar e clique no botão Exibir.
Na aba Importação estão declarados os parâmetros que serão recebidos pela função.
Na aba Exportação estão declarados os parâmetros que serão devolvidos pela função.
Na aba Modificação estão declarados os parâmetros que serão modificados pela função.
Na aba Texto fonte visualizamos o código ABAP da função

Abaixo temos um exemplo de programa que chama a função acima:
*--------------------------------------------------------------------
* Exemplo de programa com FUNÇÃO
*--------------------------------------------------------------------
REPORT zvmtr_gpessoa_29 .
* Tela de seleção
PARAMETERS: numero1(2) TYPE p,
numero2(2) TYPE p.
* Variável
DATA: usuario LIKE sy-uname.
START-OF-SELECTION.
CALL FUNCTION 'ZVMTR_FUNCTION001'

EXPORTING
w_numero1 = numero1
IMPORTING
w_user = usuario
CHANGING
w_numero2 = numero2.
WRITE:/.
WRITE:/ 'Listagem do programa após execução da função'.
WRITE:/ 'Parametro exportação:', numero1,

/ 'Parametro modificação:', numero2,
/ 'Parâmetro importação:', usuario.
Ao ser executado o programa exemplo exibirá uma tela de seleção. Entrando com os parâmetros solicitados
uma listagem será exibida:
Para testar a função sem executar o programa, utilizamos a transação SE37, clicando no botão de teste,
conforme abaixo:
Capitulo 8 – Enhancements
FIELD-EXITS
São funções que podemos associar ao data elements. Por exemplo, para criar uma verificação que evite a
duplicidade de CGC de clientes do SAP, precisamos posicionar o cursor no campo e pressionar F1 e em
seguida F9, com isso conseguimos o nome do elemento de dados associado ao campo CGC [STCD1] em
seguida precisamos saber em quais telas e transações queremos que o nosso FIELD-EXIT seja ativado. Senão
informarmos em nenhuma tela o FIELD-EXIT acabará valendo para todas as telas onde exista esse elemento
de dados.
Visualizando feild-exits
Entrar na transação CMOD e digitar PRFB no field command.
Nesta tela deve-se criar um novo FIELD-EXIT, informando o elemento de dados, também é possível realizar
o processo de criação de FIELD-EXITS pela transação SE37.
Pressione F8.
Ao pressionar F8 esta será a próxima tela.

Clique no menu Exit campo e escolha a opção Criar .
Coloque o nome do elemento de dados na caixa que se abrirá, o mesmo que foi recuperado com F1 e F9,
Caixa campo exit elemento de dados.
DICA:
Não é o nome do campo e sim o elemento de dados.
Após ter colocado o elemento de dados encontrado e clicado em avançar, a próxima tela será a
FUNCTION BUILDER ou seja a SE37 citada acima.
Clique em criar.
Escolha o grupo de funções e escreva um texto breve para identificar sua FIELD-EXIT.
Pronto está criada a sua FIELD-EXIT.
OBS: DETALHE IMPORTANTE !!!

DICA:
Em qualquer FIELD-EXIT, é necessário que exista uma “SAÍDA” para o campo OUTPUT, mesmo que o
resultado seja o mesmo do campo INPUT.
EX.
OUTPUT = VARIÁVEL DE RESULTADOS DE UM PROCESSAMENTO.
OU
OUTPUT = INPUT.
A FIELD-EXIT pode ser global ou associada a um programa e tela.

Após efetuar a rotina de programação necessária, devemos associar o nome do programa e a tela em que o
FIELD-EXIT deverá ser executado.
DICA:
Caso a FIELD-EXIT não seja associada a um programa e tela ela será global ou seja para todos os elemento
de dados e campos encontrados nas transações do SAP.
Volte a tela em que se encontra todas as FIELD-EXITS existentes e selecione com um clique o nome da
FIELD-EXIT desejada, clique no botão atribuir progr/tela. Ao aparecer a janela acima você deverá preencher
os devidos campos com os dados que recuperou da tela com F1 e F9 ou SISTEMA STATUS, isso deve ser
feito na tela em que se encontra o campo MATNR que receberá a FIELD-EXIT, faça o mesmo para recuperar
o elemento de dados o nome do campo e sua tabela.
Programando uma FIELD-EXIT.

Como recuperar campos de tela em uma FIELD-EXIT?
Aqui são citadas três maneiras para conseguir os valores de campos de tela para uma FIELD EXIT.
1º - MOVE INPUT
2º - GET
3º - FUNÇÃO - DYNP_VALUES_READ
1º - MOVE INPUT
Para campos que recebem a FIELD-EXIT.
EX.
O campo que recebe a FIELD-EXIT no caso é o campo DISKB, sendo assim simplesmente o seu valor pode
ser resgatado com o comando acima.
2º - GET
Para campos que não recebem a FIELD-EXIT.
EX.
Para recuperar campos com o comando GET, vá até o campo que deve ser recuperado e pressione F1 e
F9, nas suas INFORMAÇÕES TÉCNICAS recupere o campo ID DE PARAMETRO.
No caso acima veja quem é o ID DE PARAMETRO.
ID DE PARAMETRO: ZKNTTP
Utilize o comando GET para jogar o resultado para uma variável qualquer que no caso está sendo
representada por W_KNTTP.
3º - Função - DYNP_VALUES_READ
Ótima opção para recuperar campos da tela, recupera todos os tipos de campo, tanto o valor do campo que
está recebendo o FIELD-EXIT como campos de tabelas standard e tabelas estruturas.
Aconselhável recuperar o valor de campos que recebem o FIELD-EXIT com o comando MOVE INPUT
citado acima.
EX.
OS CÓDIGOS ESTARÃO COMPLETOS ABAIXO PARA O MELHOR ENTENDIMENTO.
DICA:
O SAP não debuga FIELD-EXIT então para que você tenha certeza de que os valores estão corretos junto ao
seu programa utilize mensagens de erro como:
MESSAGE E039(ZB) WITH W_EBENE.
isso lhe ajudará a ver os conteúdos das variáveis na BARRA DE STAUS.
EX.
Conteúdo de variáveis selecionas em um programa.
Comando SET
serve para setar um valor fixo ou que esteja em uma variável para um determinado campo.
DICA:
O comando SET só funcionará em campos que tenham ID DE PARAMETRO.
EX.
DATA: W_DSART1 LIKE FDES-DSART VALUE 'AB'.
SET PARAMETER ID 'FFA' FIELD W_DSART1.
OU
DATA: W_DSART1 LIKE FDES-DSART.

SET PARAMETER ID 'FFA' FIELD W_DSART1.
Neste caso o valor pode ter sido recuperado de qualquer maneira.
FIM...
Dois Programas para exemplo.
DICA:
Não deixe de ler os programas para o melhor entendimento.
Programa 1 – campo DISKB

Programa 2 – campo AVDAT
Programa 3 – campo AUFNR
1º - function field_exit_diskb.
*"----------------------------------------------------------------------
*"*"Interface local:
*" IMPORTING
*" REFERENCE(INPUT)
*" EXPORTING
*" REFERENCE(OUTPUT)
*"----------------------------------------------------------------------
***---------------------------------------------------------------------
***------------------------------***
***Tabela Interna usada na função***
***------------------------------***
data: w_dynpread like dynpread occurs 0 with header line,
***-------------------***
***Tabela Interna fdes***
***-------------------***
begin of t_fdes occurs 0,
bnkko like fdes-bnkko, "Conta do Razão tesouraria interna
end of t_fdes.
***---------------------------------***
***Variáveis recuperadas pela função***
***---------------------------------***
data: w_bukrs like fdes-bukrs, "Empresa
w_dsart like fdes-dsart, "Tipo fluxo de caixa
w_ebene like fdes-ebene, "Nível administração tesouraria
w_diskb like t035d-diskb, "Título de conta de tesouraria
***--------------------***
***Variáveis auxiliares***
***--------------------***
w_t035d_bnkko like t035d-bnkko. "Váriaval Auxiliar T035D
***--------------***
***input / output***
***--------------***
output = input.
***-----------------------------------------------***
***Recupera valor do campo que recebe a Field_Exit***
***-----------------------------------------------***
move input to w_diskb.
clear: w_bukrs,
w_dsart,
w_ebene.
free: w_dynpread.
***-----------------------------------------------------***
***Carrega a tabela interna com nome de tabelas e campos***
***-----------------------------------------------------***
w_dynpread-fieldname = 'FDES-BUKRS'.
append w_dynpread.
w_dynpread-fieldname = 'FDES-DSART'.
append w_dynpread.
w_dynpread-fieldname = 'FDES-EBENE'.
append w_dynpread.
***---------------------------***
***Função DYNP_VALUES_READ ***
*** Programa de tela: SAPMF40E***
*** Número da tela : 0101 ***
***---------------------------***
call function 'DYNP_VALUES_READ'
exporting
dyname = 'SAPMF40E'
dynumb = '0101'
tables
dynpfields = w_dynpread
exceptions
others = 1.
***-------------------------------***
***Move campos de tela encontrados***
***-------------------------------***
if sy-subrc is initial.
loop at w_dynpread.
if w_dynpread-fieldname eq 'FDES-BUKRS'.
move: w_dynpread-fieldvalue to w_bukrs.
elseif w_dynpread-fieldname eq 'FDES-DSART'.
move: w_dynpread-fieldvalue to w_dsart.
elseif w_dynpread-fieldname eq 'FDES-EBENE'.
move: w_dynpread-fieldvalue to w_ebene.
endif.
endloop.
else.
message e039(zb) with sy-subrc.
endif.
***-----------------------***
***Seleção na tabela T035D***
***-----------------------***
select single bnkko
from t035d
into w_t035d_bnkko
where
diskb = w_diskb and
bukrs = w_bukrs.
***----------------------***
***Seleção na tabela FDES***
***----------------------***
select bnkko
from fdes
into table t_fdes
where
bukrs = w_bukrs and
dsart = w_dsart and
ebene = w_ebene and
bnkko = w_t035d_bnkko.
append t_fdes.
***-------------------------------***
***Verifica título da conta DISKB***
***-------------------------------***
loop at t_fdes.
if t_fdes-bnkko = w_t035d_bnkko.
message e001(zb1) with w_t035d_bnkko : t_fdes-bnkko.
else.
message e000(zb1) with w_t035d_bnkko : t_fdes-bnkko.
endif.
endloop.
endfunction. "FIM DA FUNÇÃO FIELD_EXIT_DISKB
2º - function field_exit_avdat.
***********************************************************************
* *
* Objetivo: FIELD_EXIT_AVDAT *
* *
* Autor: Matheus Rangel Teixeira - SOLUZIONA *
* *
* Objetivo: Validação das datas na transação FF63. *
* *
************************************************************************
function field_exit_avdat.
*"----------------------------------------------------------------------
*" IMPORTING
*" REFERENCE(INPUT)
*" EXPORTING
*"----------------------------------------------------------------------
data w_dynpread like dynpread occurs 0 with header line.

data: w_datum like fdes-datum , "Data de administração de tesouraria
w_avdat like fdes-avdat , "Data do arquiv. vencimento automático
w_dsart like fdes-dsart , "Tipo de fluxo de caixa
w_avdat1 like sy-datum , "Data do arquiv. vencimento automático
w_datum1 like sy-datum . "Data de administração de tesouraria
output = input.
clear: w_datum,
w_avdat,
w_dsart.
free w_dynpread.
w_dynpread-fieldname = 'FDES-DATUM'.
append w_dynpread.
w_dynpread-fieldname = 'FDES-AVDAT'.
append w_dynpread.
w_dynpread-fieldname = 'FDES-DSART'.
append w_dynpread.
if sy-dynnr eq '0101'.
call function 'DYNP_VALUES_READ' "Função p/ capturar valores

exporting " dos campos na tela.
dyname = 'SAPMF40E'
dynumb = '0101'
tables
exceptions
others = 1.
else.
call function 'DYNP_VALUES_READ' "Função p/ capturar valores
exporting " dos campos na tela.
dyname = 'SAPMF40E'
dynumb = '0102'
tables
exceptions
others = 1.
endif.
if sy-subrc is initial.
loop at w_dynpread.
if w_dynpread-fieldname eq 'FDES-DATUM'.
concatenate w_dynpread-fieldvalue+6(4)
w_dynpread-fieldvalue+3(2)
w_dynpread-fieldvalue+0(2) into w_datum1.
elseif w_dynpread-fieldname eq 'FDES-AVDAT'.
concatenate w_dynpread-fieldvalue+6(4)
w_dynpread-fieldvalue+3(2)
w_dynpread-fieldvalue+0(2) into w_avdat1.
elseif w_dynpread-fieldname eq 'FDES-DSART'.
move: w_dynpread-fieldvalue to w_dsart.
endif.
endloop.
else.
message e039(zb) with sy-subrc.
endif.
* Validações das Datas
if sy-uname eq 'ABAP11'.
if w_avdat1 lt w_datum1.
message e229(zb) with w_avdat1 w_datum1.
elseif w_datum1 lt sy-datum and w_dsart ne 'FC'.
message e230(zb) with w_datum1 sy-datum .
endif.
endif. "fim do if que verifica usuário (ABAP11)
endfunction.
3º - function field_exit_aufnr.
*"----------------------------------------------------------------------
*" IMPORTING
*" REFERENCE(INPUT)
*" EXPORTING
*"----------------------------------------------------------------------
data w_aufnr type aufnr.
data w_knttp type aufnr.
data w_astkz like coas-astkz.
output = input.
move input to w_aufnr.
clear w_knttp.
get parameter id 'ZKNTTP' field w_knttp.
if w_knttp is initial.
get parameter id 'KNT' field w_knttp.
endif.
if sy-tcode cs 'ME5' and w_knttp ca 'ZW' and not w_aufnr is initial.
clear w_astkz.
select single astkz into w_astkz

from coas
where aufnr eq w_aufnr.
if sy-subrc ne 0.
message e000(zb) with 'Ordem não existe !!!'.
elseif w_astkz ne 'X'.
message e000(zb) with 'Ordem deve ser estatística !!!'.
endif.
endif.
set parameter id 'ZAFNR' field w_aufnr.
endfunction.

ABAP para Funcionais

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

ABAP para Funcionais

Caricato da

Copyright:

Formati disponibili

Capítulo 1 - Introdução ao ABAP

Tipos de programas ABAP

Tela de seleção (parâmetros de entrada)

Lista (saída do relatório)

Variantes Texto fonte

Convenções de nome de programa

Entre as ferramentas do workbench estão:

- O Function Builder: Criar, modificar e visualizar módulos de função do ABAP

Visualizando um programa ABAP

A tabela abaixo contém algumas das funções do editor.

O sistema exibirá todos os objetos de desenvolvimento da classe de desenvolvimento informada.

1. Vá para a tela inicial do Editor ABAP (SE38)

4. Dê um duplo clique no programa que você quer visualizar.

ABAP Dictionary – Introdução

Explorando as tabelas e as estruturas

Exibindo definição de tabela ou estrutura

Para exibir uma tabela ou estrutura no Dictionary:

1. Vá para a tela inicial do ABAP Dictionary (SE11)

A tela Conteúdo de tabela do data Browser é exibida:

Determinando campos exibidos

A instrução SELECT recupera registros do banco de dados.

O seguinte código mostra o uso da instrução SELECT:

A instrução REPORT é solicitada como a primeira linha de um report.

SELECT * FROM lfa1 ORDER BY lifnr.

Utilizando uma área de trabalho explícita

A instrução WRITE exibe o conteúdo da área de trabalho wa_fornec.

A execução deste programa produzirá a lista abaixo:

Todas as variáveis de sistema são definidas na estrutura syst .

Abaixo exemplo da utilização do sy-subrc com a instrução SELECT.

A execução deste programa produzirá o seguinte resultado:

Após a execução deste programa a saída seria a seguinte:

Ou, você poderia utilizar o operador de encadeamento:

TABLES: lfa1, lfb1.

Exemplo da utilização do operador de encadeamento num programa:

O seguinte código mostra o uso da instrução SELECT SINGLE:

Ao ser executado, o programa de exemplo produzirá a seguinte saída:

Comentários e documentação dos programas

Os comentários nos programas ABAP podem ser feitos de duas maneiras:

Uma tela com a documentação será exibida, conforme exemplo abaixo:

Tipos de tabelas no R/3

No R/3 há três tipos de tabela: tabelas transparentes, de pool e tabelas cluster.

Restrições nas tabelas de pool e de cluster

Determinando quando criar ou reutilizar domínios e elementos de dados

Para exibir um domínio no Dictionary:

1. Vá para a tela inicial do ABAP Dictionary (SE11)

Visualizando elementos de dados

Para exibir um elemento de dados no Dictionary:

1. Vá para a tela inicial do ABAP Dictionary (SE11)

Transações para navegação de dados

Literais de ponto flutuante: São especificados dentro de aspas simples como

Utilizando a instrução DATA para definir variáveis

DATA f1(2) TYPE c.

Há duas categorias principais de dados no ABAP: caracter e numérico.

Tipos de dados de caractere

Os tipos de dados de caractere são mostrados abaixo:

Tipo Descrição Comprimento Comprimento Valores Valor

Tipos de dados de numéricos

Os tipos de dados de numéricos são mostrados abaixo:

Tipo Descrição interna Comprimento Comprimento Decimais Valor

Mapeando tipos de dados do Dictionary para tipos de dados do ABAP

Dict. data type ABAP data type

Utilizando a instrução PARAMETERS para definir variáveis

Abaixo segue o exemplo de um report que utiliza a instrução parameters: