ABAP 01-Libre PDF

Int rodução aos Conceit os de
Desenvolviment o e Cust omização

de Relat órios
Int rodução aos Conceit os de Desenvolviment o e
Cust omização de Relat órios
Introdução ........................................................................................... 5
Composição........................................................................................ 5
Como ent ender a apost ila....................................................................... 5
Conhecimentos Básicos sobre a Plataforma de Desenvolvimento ABAP ................ 7
Caract eríst icas Principais ....................................................................... 7
O Repositório do R/ 3............................................................................... 8
O que é o Reposit ório ............................................................................ 8
Classes de desenvolviment o .................................................................... 8
O Dicionário de Dados........................................................................... 10
Definições básicas .............................................................................. 10
As caract eríst icas t écnicas das t abelas do R/ 3 ............................................ 13
Verificações de chave ext erna (f oreign keys) ............................................. 15
Processos de aj ust e e conversão de t abelas ............................................... 16
Visões no R/ 3.................................................................................... 17
Alô, Mundo! ........................................................................................ 20
Criando seu primeiro programa ABAP/ 4 .................................................... 20
Bibliotecas de Funções.......................................................................... 22
O que são as funções no R/ 3.................................................................. 22
RFC................................................................................................ 23
Funct ion Groups ................................................................................ 23
Os Criadores de Menus e Telas ................................................................ 24
Criando menus .................................................................................. 24
Criando Telas.................................................................................... 24
Criando Tabelas Internas e Estruturas Complexas de Armazenagem Temporária.. 28
Tabela int erna .................................................................................. 28
Tipos de t abelas int ernas...................................................................... 28
Ext ract s .......................................................................................... 29
O Open SQL ........................................................................................ 31
Comandos........................................................................................ 31
Campos de sist ema ............................................................................. 32
© I-PROVIDER Página 2
Trabalhando com os Mandant es.............................................................. 32

SELECT ........................................................................................... 32
INSERT ............................................................................................ 33
UPDATE........................................................................................... 33
MODIFY ........................................................................................... 34
DELETE ........................................................................................... 34
OPEN CURSOR, FETCH, CLOSE CURSOR ..................................................... 34
Criação de Listas Básicas........................................................................ 35
O comando WRITE.............................................................................. 35
Criando uma list a simples..................................................................... 35
Cabeçalhos e rodapés.......................................................................... 36
Mudando a apresent ação dos campos....................................................... 36
Modificando o format o de exibição st andard .............................................. 37
Posicionando os campos....................................................................... 38
Especificando unidades de medida e moedas.............................................. 38
Símbolos de Text o .............................................................................. 39
O SAP Query ....................................................................................... 43
Grupos de usuários e áreas funcionais ...................................................... 44
Definindo telas de seleção de parâmetros.................................................. 45
Diferença ent re o comando PARAMETERS e o comando SELECT-OPTIONS............. 45
Agrupando parâmet ros em bordas e melhorando o layout ............................... 48
Modificando o programa para usar bordas.................................................. 48
Janelas adicionais de parâmet ros............................................................ 49
Criação de Listas Complexas................................................................... 51
O Event o AT LINE-SELECTION................................................................. 51
HIDE............................................................................................... 51
List as em mais de dois níveis................................................................. 52
AT USER-COMMAND............................................................................. 53
Abrindo Telas Dent ro de Relat órios ......................................................... 53
Chamando t ransações a part ir de list agens ................................................ 54
Copyright 2005 I-PROVIDER. Todos os direitos reservados.

Este material é de propriedade intelectual da I-PROVIDER, sendo terminantemente proibida sua
reprodução, total ou parcial, por qualquer forma, sem autorização prévia e expressa..
R/ 3, ABAP, SAP, SAPScript , o logot ipo SAP e t odos os out ros serviços e marcas da SAP
são marcas regist radas da SAP AG.
Int rodução
Composição
Este material tem como objetivo principal apresentar o ambiente de programação ABAP aos
profissionais que não desenvolverão programas diretamente, mas necessitam conhecer a ferramenta
para embasar seu trabalho.
Para o aprendizado mais específico desta ferramenta, aconselha-se a preparação em programas de
treinamentos oficiais, junto a SAP Brasil.
Como entender a apostila
Este material foi desenvolvido com base nas operações do sistema SAP R/3, sendo em alguns casos
exemplificados com as próprias telas de utilização do sistema.
Todos os capítulos desta apostila foram estruturados nos conceitos técnicos do ABAP, compositores
dos elementos da linguagem de programação do SAP R/3, e possuem suas definições e exemplos
similares aos previstos em material técnico da própria SAP.
Os exercícios de fixação do contexto técnico serão aplicados conforme acompanhamento de
profissional capacitado, e serão atribuídos ao sistema, de acordo com a programação dos temas que
serão discutidos em workshop.
Conteúdo Programático
̌ Conhecimentos básicos sobre a plataforma de desenvolvimento ABAP;
̌ Trabalhando com o Repositório de Programas;
̌ Conhecendo os elementos do Dicionário de dados ABAP;
̌ Biblioteca de Funções;
̌ Criador de Menus e Telas;
̌ Classes de Desenvolvimento e tipos de programas;
̌ Desenvolvimento de relatórios e consultas;
̌ Definição de elementos de texto;
̌ Criando tabelas internas e estruturas complexas de armazenagem temporária;
̌ Definindo telas de seleção de parâmetros;
̌ Chamadas de telas de seleção em consultas complexas;
̌ Criação de listas básicas;
̌ Criação de listas complexas com recurso de drill down;
̌ Criação de consulta interativa com funções adicionais;
̌ Carregando telas em relatórios;
̌ Conhecimentos de comandos ABAP Open-SQL;
̌ Atribuindo funções extras aos relatórios e consultas;
̌ Chamando transações a partir de listagens.
Carga Horária : 28 horas
Conheciment os Básicos sobre a Plataforma de Desenvolviment o ABAP
Ca m a da de
Apre se nt a ç ã o
(Front -e nd)
Ca m a da de
Progra m a ABAP
Aplic a ç ã o
Se rvidor de
Ba nc o de
Da dos
Características Principais
O R/3 usa o modelo cliente-servidor de três camadas, com a primeira camada composta pelo
servidor de banco de dados, uma outra camada de aplicação, onde são executadas as regras de
negócio, e uma camada de apresentação, onde os usuários rodam o programa de front-end
responsável pela interface do usuário com o sistema.
O ABAP é a linguagem de programação nativa do SAP R/3, e é uma linguagem interpretada
de alto nível. Dentro do servidor de aplicação do R/3, todos os programas responsáveis pelas regras
de negócio são programas ABAP que fazem uso de bibliotecas escritas, em sua maioria, em
linguagem C (“kernel” do R/3).
Os programas ABAP ficam armazenados no banco de dados, sendo que o R/3 gera, na
primeira execução de cada programa ou em bloco, um código intermédiário pseudo-compilado,
específico para cada combinação de sistema operacional + versão do R/3. Até mesmo alguns níveis
de atualização de kernel tornam incompatível o código previamente gerado, havendo necessidade de
“recompilar” os programas ABAP.
Todo o desenvolvimento dos programas ABAP pode ser realizado usando ferramentas
disponibilizadas pelas transações apropriadas dentro do próprio R/3, dispensando o uso de
ferramentas externas. Essas transações serão detalhadas durante o curso.
O Reposit ório do R/ 3
O que é o Repositório
O Repositório do R/3 é a coleção de todos os programas ABAP, classes, interfaces, grupos

de função e objetos do Dicionário de Dados presentes num sistema R/3, quer sejam objetos
originais da SAP, quer sejam objetos criados pelo cliente.
Os programas e outros objetos do repositório criados pelo cliente devem estar no namespace
de cliente, ou seja, seus nomes devem começar com as letras Z ou Y (com exceção dos campos em
append structures, que devem começar por ZZ ou YY). Os clientes só devem alterar objetos com
nomes fora dessa especificação quando expressamente orientados pela SAP a fazê-lo (por exemplo,
para aplicar notas de correção). A SAP garante que os programas desenvolvidos pelos clientes que
observarem as especificações de namespace não serão afetados quando houver uma atualização do
sistema, como uma aplicação de Support Package. No entanto, caso seja alterado um programa
standard da SAP, não há garantias de que o programa alterado permanecerá como tal após qualquer modificação no
sistema. Para agregar funcionalidades a programas da SAP, existe o recurso das User Exits, que será
tratado posteriormente, na terceira semana do workshop.
Classes de desenvolvimento
O Repositório está separado pelos módulos funcionais, e os objetos nele contidos estão
separados logicamente em classes de desenvolvimento. As classes de desenvolvimento são agrupamentos
de objetos do repositório que estão relacionados entre si. Todo objeto do repositório deve pertencer
a uma classe de desenvolvimento e toda classe de desenvolvimento deve ter definido um transport
layer, que é uma definição de Basis que define qual é a rota de transporte (para quais sistemas o
objeto pode ser transportado numa change request, ou se não pode ser transportado, caso seja um
layer local).
Para encontrar os objetos no Repositório do R/3, existe o Sistema de Informação do

Repositório (transação SE84), que é uma coleção de relatórios que permitem procurar por um
determinado objeto e navegar pelas definições do Repositório.
O Dicionário de Dados
Definições básicas
O dicionário ABAP permite a administração central de todas as definições de dados do R/3,

permitindo a criação de tipos de dados definidos pelo usuário para uso posterior, além de vários itens
auxiliares ao desenvolvimento de programas (p.ex. search helps).
Podem ser definidas tabelas e visões dentro do dicionário. O R/3 se encarrega, durante a
ativação desses elementos, de criá-los no banco de dados. O dicionário permite, ainda, a criação de
índices, que agilizam as buscas. A definição de índices apropriados é de suma importância para o
bom desempenho do sistema. Cabe lembrar que uma busca sem índice realizada em uma tabela
extensa pode ter pesado custo em termos de performance.
As definições de tipos de dados dentro do R/3 incluem os elementos de dados, que
definem um tipo elementar descrevendo o tipo básico de dados, o comprimento e, eventualmente, as
casas decimais; as estruturas, que podem receber elementos de vários tipos (semelhante à
representação de um registro numa tabela); e os table types, que seriam “campos” em formato de
tabela. Por exemplo, uma estrutura do registro de uma estrutura de usuário que tivesse um campo
para números de telefone poderia usar um table type e permitir colocar vários números num mesmo
campo.
Além dessas definições, o dicionário ABAP permite criar os search helps, que são tabelas de
busca auxiliares aos campos de tela – são as buscas e tabelas que aparecem quando se tecla F4 dentro
de um campo em qualquer tela do R/3. Criando documentação para o elemento de dados dentro do
dicionário, automaticamente está disponível a ajuda do campo, que pode ser invocada usando-se a
tecla F1 dentro dos campos de tela. Pode-se, ainda, definir verificações de entrada automaticamente,
bastando definir uma relação de foreign key.
No dicionário também são criados os objetos de lock, que permitem definir o travamento
de dados dentro do R/3. Por exemplo, podem-se definir objetos de lock para impedir que dois
usuários editem a mesma informação ao mesmo tempo no sistema.
O dicionário é integrado às ferramentas de desenvolvimento e execução do R/3, permitindo
o acesso das ferramentas às definições nele contidas. Por exemplo, é possível navegar de um
programa que esteja sendo criado no editor ABAP para definições de campos, elementos e tabelas
usadas no programa.
Definição de tabelas
Uma tabela consiste de colunas (campos) e linhas (registros). Cada tabela possui um nome e
atributos, como por exemplo a classe de desenvolvimento e a autorização para manutenção. Cada
campo deve ter um nome único dentro da tabela, e pode fazer parte de uma chave. Cada tabela deve
ter uma chave primária, que é composta por campos cujos valores identificam unicamente os
registros de uma tabela. As tabelas definidas no dicionário de dados do R/3 são criadas no banco de
dados assim que ativadas.
Durante a ativação, a descrição da tabela dentro do dicionário é traduzida para a definição de

tabela correspondente na linguagem do banco de dados que estiver sendo usado. A ordem dos
campos no banco de dados não precisa seguir a ordem estabelecida no dicionário de dados (com
exceção dos campos de chave primária), o que permite a extensão das tabelas standard do R/3
através e append structures, que são definições de campos adicionais definíveis pelo usuário sem
haver a necessidade de alteração da definição normal da tabela standard. Os includes são estruturas
definidas separadamente que podem ser inseridas em outras tabelas.
O conceito de domínio de dois níveis

Basicamente, as tabelas dentro do R/3 são compostas de campos, cada um usando um
determinado elemento de dados, que por sua vez usam domínios. O domínio define o tipo básico
de dados, seu comprimento e o intervalo de valores permitido; o elemento de dados descreve o
significado de um domínio dentro de um determinado cenário. Por exemplo, um campo de código de
aeroporto de destino deve estar ligado a um elemento de dados “aeroporto de destino”, que por sua
vez usa um domínio “código de aeroporto”, que está definido como três posições de caractere,
apenas com letras.
As características técnicas das tabelas do R/ 3
Quando uma tabela é definida no dicionário de dados do R/3, devem ser definidas as
características técnicas (technical settings) para a tabela. Essas características são usadas para otimizar o
acesso e a armazenagem da tabela individualmente.
As características técnicas podem ser usadas para definir como a tabela deve ser manipulada
quando for criada no banco de dados, se ela deve ser incluída em buffer e de que forma, e se as
mudanças nela realizadas devem ser registradas em log.
Para definir a armazenagem da tabela, deve-se indicar uma classe de dados. Essa classe de
dados determina de que forma o banco de dados deve armazená-la. As classes principais são master
data, transaction data, organizational data e system data. Os dados mestres devem ser
classificados como master data, os dados transacionais como transaction data, a configuração
funcional como organizational data e os dados de sistema como system data. Geralmente, dentro de
um projeto, são criadas tabelas dos tipos master e transaction somente. De posse dessa informação, o
R/3 separa as tabelas em diferentes arquivos do banco de dados de forma a otimizar a performance.
A categoria de tamanho das tabelas permite ao R/3 alocar espaço no banco de dados de
acordo com o tamanho projetado para a tabela, de modo a evitar fragmentação dos dados.
Pode-se definir que uma determinada tabela será armazenada em buffer de memória. Com
isso, o acesso à tabela é otimizado, mas deve-se usar de bom senso para colocar tabelas em buffer.
Por exemplo, tabelas candidatas a entrar no buffer são dados mestres com muita utilização e
raramente atualizadas. Tabelas de dados transacionais não devem ser colocadas em buffer, pois cada
registro dentro delas é menos frequentemente acessado que nas tabelas de dados mestres, e estão
sujeitos a atualizações. A atualização de uma tabela que esteja no buffer provoca seu re-carregamento
com consequente impacto no desempenho dos programas.
O buffer pode ser definido nos modos full, no qual a tabela inteira é colocada no buffer,
single-record, onde apenas os registros eventualmente acessados são colocados no buffer, e
generic, no qual são colocados no buffer registros que tenham determinados valores na chave. Os
dados não são automaticamente colocados no buffer assim que o sistema entra no ar; isso só
acontecerá no primeiro acesso a um registro que esteja em um intervalo de buffer.
Caso seja necessário, pode-se definir o registro em log das alterações feitas numa tabela.
Porém, deve-se ter em mente que isso pode criar um impacto na performance do sistema.
Verificações de chave externa (foreign keys)
As foreign keys são campos, dentro de uma determinada tabela, que fazem referência aos
campos da chave de uma outra tabela e devem apenas apresentar valores que existam na tabela
referenciada. Por exemplo, numa tabela contendo os dados de um pedido, um campo de cliente deve
referenciar um cliente existente ou, automaticamente, quando se tentar colocar um pedido com um
cliente que não exista, ocorrerá um erro. As relações de chave externa são definidas na transação de
manutenção de tabelas do dicionário.
Processos de ajuste e conversão de tabelas
Deve-se assegurar que os objetos no dicionário de dados estejam sincronizadas com suas
implementações no banco de dados. Ao ser feita uma modificação na tabela, como por exemplo a
inclusão de um registro, as mudanças feitas no dicionário devem ser refletidas pelo R/3 no banco de
dados, quer seja através da alteração de estrutura (via comandoALTER TABLE do banco), ou
deletando e recriando a tabela¸ o que acarreta perda de dados, ou através do ajuste do banco,
que é um processo trabalhoso. Qualquer uma dessas formas pode ser escolhida pelo usuário; para
alguns tipos de modificação, apenas a alteração da estrutura não bastará, sendo necessária a deleção
ou ajuste da tabela.
Caso os dados na tabela não possam ser perdidos, deve-se fazer o ajuste da mesma, no qual a
tabela original é renomeada, é criada uma nova tabela com o nome original, e nessa tabela são
copiados os registros da tabela original. Dependendo da quantidade de dados na tabela, o ajuste pode
ter um tempo de execução considerável. Alguns problemas podem surgir durante a conversão
quando, por exemplo, algum arquivo do banco de dados for totalmente preenchido, ou os tipos de
campos forem alterados de modo a não poderem mais ser movidos via MOVE-
CORRESPONDING, que é o comando usado para fazer a movimentação dos dados da tabela
original para a nova tabela. Porém, o grande problema na conversão ocorre quando a chave é
reduzida de tamanho. Corre-se o risco de, considerada a nova chave, registros que não incorriam em
problemas de chave duplicada passarem a sê-lo. Nesse caso, apenas um dos registros será copiado, e
não se pode ter certeza qual será. Assim, é recomendável evitar ao máximo a alteração de chaves nas
tabelas criadas no R/3 que já possuam volume de dados produtivos.
Visões no R/ 3
As visões são queries de uma ou mais tabelas, que retornam um conjunto de dados que pode
ser tratado como uma tabela pelos programas ABAP. As visões são definidas no dicionário de dados,
estando disponíveis para uso em todo o sistema. As visões podem ser do tipo join, nas quais é
trazido um conjunto de dados a partir de várias tabelas unidas por joins; do tipo projection, nas
quais selecionam-se apenas os campos desejados de uma tabela específica; ou do tipo selection, nas
quais se deseja exibir apenas os registros que satisfaçam um determinado critério.
Exercícios de Fixação
Segue abaixo um conjunto de exercícios práticos para aprimorar o aprendizado referente a:
- Conhecimentos básicos sobre a plataforma de desenvolvimento ABAP

- O Repositório do SAP R/3
- O dicionário de dados
Exercício proposto:
Exercício 1
Criar uma tabela transparente, para controlar prazo de validade de produtos perecíveis.
A tabela deve ter os seguintes campos:
Campo CH Elem. Dados
MANDT X MANDT Mandante
WERKS X WERKS Centro
MATNR X MATNR Material
DTFAB DATAB Data de início de validade
PRVAL MHDHB Prazo de validade
Exercício 2
Criar uma Visão para visualizar os dados da tabela criada no exercício anterior.
Solução:
Exercício 1
1. Entre no Dicionário de Dados:
Pelo menu: Ferramentas - Abap/Workbench - Data Dictionary
Pela transação: SE11
2. Selecione TABELA BANCO DE DADOS, digite o nome da tabela a ser criada e depois
clique sobre o botão CRIAR.
3. Entre com uma descrição breve e defina Categoria da Tabela e Classe de Entrega.
4. Digite o nome dos campos, lembrando sempre de inserir os Campos Chave primeiro,
marcando-os na coluna CHAVE, e defina seus Elementos de Dados.
5. Salvar.
6. Identifique a Classe de Desenvolvimento.
7. Defina com as Opções Técnicas, clicando sobre o botão OPÇÕES TÉCNICAS.
8. Selecione o Tipo de Dados e Categor. Tamanho adequados para a tabela que está sendo
criada.
9. Saia da janela de Opções Técnicas, Salve e Ative a tabela.
Exercício 2
1. Entre no Dicionário de Dados:
Pelo menu: Ferramentas - Abap/Workbench - Data Dictionary
2. Selecionando VISÃO, digite com o nome da Visão a ser criada e clique sobre o botão
CRIAR,
3. Selecione tipo de visão como VISÃO DE BANCO DE DADOS.
4. Na pasta Tabelas/Condições Join, na coluna TABELAS, entre com o nome da tabela para a
qual a visão será criada.
5. Passando para a pasta Cpos.Visão, acrescente os campos que devem ser visualizados,
incluindo o campo mandante.
6. Salve.
8. Ative.
9. Para visualizar os dados, no menu, selecione: Utilitários - Conteúdo.
Alô, Mundo!
Criando seu primeiro programa ABAP
Vamos criar um programa ABAP simples para nos ambientarmos às peculiaridades da

programação para o SAP R/3. Como é usual, vamos criar um programa que escreva uma frase
simples na tela. Vamos entrar na transação SE38, solicitar a criação de um novo programa com o
nome ZHELLO:
REPORT HELLO.
WRITE: / ‘Alô, Mundo!’.
Com apenas duas linhas de código, acabamos de criar nosso primeiro programa ABAP.
Selecione F8 (executar), e missão cumprida. Por ser este exemplo muito simples, introduziremos um
exemplo mais elaborado, que permitirá explicar alguns pontos iniciais sobre a programação:
REPORT ZHELLO2.
INCLUDE ZCODIGO.
TABLES: SFLIGHT.
DATA: CAMPO_1(7) TYPE C,

CAMPO_2(4) TYPE N,
IT_SFLIGHT LIKE TABLE OF SFLIGHT,
WA_SFLIGHT LIKE LINE OF IT_SFLIGHT.
START-OF-SELECTION.
SELECT CARRID CONNID FLDATE SEATSMAX SEATSOCC

INTO CORRESPONDING FIELDS OF TABLE IT_SFLIGHT
FROM SFLIGHT
WHERE CARRID = 'AA'.
CAMPO_1 = 'LIVRE: '.
LOOP AT IT_SFLIGHT INTO WA_SFLIGHT.

CAMPO_2 = WA_SFLIGHT-SEATSMAX - WA_SFLIGHT-SEATSOCC.
WRITE: /10 WA_SFLIGHT-CONNID,
WA_SFLIGHT-CARRID,
CAMPO_1,
CAMPO_2.
ENDLOOP.
Vamos analisar cada componente do novo trecho de código. Primeiro, temos as declarações
REPORT, INCLUDE, TABLES e DATA. REPORT é a declaração básica do programa, que
especifica seu nome e eventualmente alguma opção extra. INCLUDE especifica um trecho de
programa que deve ser incluído durante a compilação/execução do programa. TABLES declara uma
área de trabalho para o uso de uma tabela do dicionário, e DATA contém as declarações dos campos
e áreas de dados internos ao programa. Existem outras declarações não incluídas neste programa, e,
dependendo do tipo de programa, as declarações aqui mostradas não são obrigatórias.
Em seguida temos um evento do ABAP, neste caso o evento START-OF-SELECTION, que
é disparado sempre no início do programa. Existem outros eventos e, neste caso, não seria realmente
necessário o evento, apenas o incluímos para explicá-lo. Um evento é encerrado pelo início de outro
evento ou pelo final do programa.
Dentro do evento temos os comandos, que executam efetivamente as ações dentro do ABAP.
Neste caso específico temos um comando SELECT, que busca os dados no banco e os coloca na
tabela interna, que é uma área de memória especificada na declaração DATA, um comando de
atribuição de valor para o campo CAMPO_1, e um LOOP na tabela interna que imprime algumas
informações baseado nas informações da tabela interna e dos campos locais.
Nos próximos capítulos estaremos detalhando com um pouco mais de profundidade a
criação de programas ABAP.
Bibliot ecas de Funções
O que são as funções no R/ 3
Dentro do R/3, as funções são elementos do repositório que encapsulam uma determinada
operação. Por estarem dentro do repositório, podem ser usadas por qualquer programa. No R/3, as
funções são definidas em uma transação apropriada, o Function Builder (SE37). Cada função deve
ter determinados os parâmetros de entrada, saída, tabelas que porventura sejam usadas e condições
de exceção que possam ser encontradas durante a execução.
Além do uso das funções standard do R/3, é útil criar uma função quando a operação será
usada por vários programas diferentes, aumentando o reuso do código e uniformizando a codificação
dos programas. Por exemplo, um programador ABAP mais experiente pode criar funções que
ocultam a complexidade de uma determinada operação, podendo ser usadas por programadores
menos experientes para elaborar programas que se tornam mais simples. Suponha que um programa
contenha acesso a várias tabelas críticas do R/3, com massa considerável de dados. Talvez esse
programa não possa ser criado por um programador iniciante, e o programa é então passado
inteiramente à responsabilidade de um pleno ou sênior, que pode ficar sobrecarregado com a
quantidade de programas atribuídos a ele, ou ela.
Usando funções, podemos ter um cenário em que o sênior apenas desenvolve a função de
busca, retornando os valores desejados, que seguem no processamento do programa, que agora está
simplificado e pode ser passado para um programador menos experiente. O sênior, ao desenvolver a
função, poderá concentrar-se em otimizar sua performance e adotar técnicas mais eficientes de
programação.
Isso não se aplica a todos os casos, mas a adoção dessa tática e de outros esquemas de
encapsulamento do R/3 (logical databases, classes) pode trazer benefícios à produtividade da equipe
de desenvolvimento.
A idéia central no uso das funções é que seu uso não dependa dos detalhes de sua
implementação (por exemplo, se vou usar uma função que retorna as vendas de um mês, deve bastar
que eu saiba quais valores devo passar e onde desejo receber o resultado, e não quais tabelas devem
ser verificadas e somadas), dentro de um conceito estrito de encapsulamento.
Para usar uma função dentro do R/3, usa-se o comando CALL FUNCTION. Existe um
mecanismo de busca no repositório (o botão Modelo presente no editor de programas) que, dado um
nome de função, automaticamente insere no código o esqueleto da chamada de função, com todos
seus parâmetros listados.
RFC
O RFC é um mecanismo do R/3 que permite a execução de uma função a partir de uma
outra máquina – por exemplo, digamos que o servidor PRD execute uma função RFC do servidor
QAS. Essa função irá ser executada no servidor QAS, e os resultados serão passados para o servidor
PRD. Qualquer função de usuário pode se tornar uma função RFC, bastando para tanto que seja
selecionada a opção apropriada nas opções técnicas do módulo de função. A chamada RFC não se
limita à comunicação entre sistemas R/3 – outros sistemas podem fazer uso desse protocolo. Porém,
ao invés do RFC, que é trabalhoso para ser usado de fora do R/3, a maneira atualmente mais
indicada para usar funcionalidades do R/3 a partir de um programa externo são as BAPIs (Business
Application Programming Interfaces), que usam um mecanismo RFC encapsulado e simplificado.
Function Groups
Toda função dentro do R/3 deve pertencer a um function group, que é um agrupamento de
funções com características e propósitos semelhantes. Quando um function group é transportado,
são transportadas juntas todas as funções a ele ligadas que tenham sido modificadas ou criadas.
Os Criadores de Menus e Telas
Criando menus
Dentro de um programa ABAP, é possível definir menus, botões e combinações de teclas específicas
para o contexto em que se esteja trabalhando. Por exemplo, pode-se colocar itens de menu referentes
à inserção de um pedido e outros itens diferentes para quando se estiver apenas exibindo um pedido.
Esses menus são definidos através do Menu Painter (SE41) e chamados, dentro do programa ABAP,
pelo comando SET PF-STATUS <nome>, onde <nome> é o nome definido para o conjunto de
menus, botões e combinações de tela escolhido.
Criando Telas
As telas, dentro do R/3, podem ser classificadas em selection-screens e dialogs. As selection-

screens são definidas através de declarações, e serão abordadas num capítulo especial. As dialogs
correspondem às telas criadas com o Screen Painter (SE51)¸que é uma ferramenta visual de definição
de telas. Dentro de uma tela, pode-se criar botões, campos de entrada e saída, tabs e outros
elementos.
- Alo Mundo!
- Biblioteca de Funções
- Os criadores de menus e telas
Exercício 1
Copie da apostila o programa ‘Alô, Mundo!’.
Declare as variáveis lc_frase1 como caracter com 26 posições, e lc_frase2 como caracter com
24 posições e atribua as frases ‘Meu primeiro programa ABAP’ à variável lc_frase1 e ‘Programando
para SAP R/3’ à variável lc_frase2.
Escreva as frases na tela nas linhas imediatamente abaixo de ‘Alô, Mundo!’.
Exercício 2
Para o programa ‘Alô, Mundo!’, crie uma barra de menu ‘Relatório’ com as opções de
Imprimir, Voltar e Encerrar.
Solução:
Exercício 1
1. Entre no Editor de programas ABAP:
Pelo menu: Ferramentas - Abap/Workbench - Editor Abap
2. Entre com o nome do Programa a ser criado e, com o botão de rádio Código Fonte
selecionado, clique sobre o botão CRIAR.
3. Na janela de Atributos do Programa, digite o título do programa e defina o tipo de
programa como Programa Executável e a Aplicação.
5. Na janela do editor, digite o código:
REPORT HELLO.
DATA: lc_frase1(26) type c,
lc_frase2(24) type c.
WRITE: / 'Alô, Mundo!'.
WRITE: / lc_frase1.
WRITE: / lc_frase2.
Exercício 2
1. Entre no Menu Painter:
Pelo menu: Ferramentas - Abap/Workbench – Menu Painter
2. Na caixa programa, digite o nome do programa para o qual será criada a barra de menus.
3. Selecione STATUS, digite o nome do menu a ser criado e clique sobre o botão CRIAR.
4. Entre com a descrição do Menu.
5. Na linha ‘Barra de Menu’, clique sobre o botão para incluir o menu.
6. Digite nome que se quer que apareça na barra de menu, no caso do exercício: ‘Relatório’.
7. Clique duas vezes sobre a palavra Relatório. Para inserir os itens do menu.
8. Inclua, na coluna de Código e Texto os códigos de comando e descrições desejados. No
caso do exercício: PRI – Imprimir, BACK – Voltar e %EX – Encerrar.
9. Salve e Ative.
11. Digite o nome do Programa do exercício anterior, com o botão de rádio Código Fonte
selecionado, clique sobre o botão MODIFICAR.
12. Faça a chamada do menu, digitando, no código do programa ABAP, o comando SET
PF-STATUS <nome>, onde <nome> é o nome do menu criado na transação SE41.
Criando Tabelas Int ernas e Est rut uras Complexas de Armazenagem

Temporária
REPORT ZTABELAINTERNA.
TYPES: BEGIN OF MYSTRUCT,

CARRID LIKE SPFLI-CARRID,
CONNID LIKE SPFLI-CONNID,
FLDATE LIKE SFLIGHT-FLDATE,
SEATSOCC LIKE SFLIGHT-SEATSOCC,
SEATSMAX LIKE SFLIGHT-SEATSMAX,
SEATFREE LIKE SFLIGHT-SEATSMAX,
END OF MYSTRUCT.
DATA: MYTABLE TYPE STANDARD TABLE OF MYSTRUCT

WITH NON-UNIQUE KEY CARRID CONNID
WITH HEADER LINE.
Tabela interna
Dentro de um programa ABAP, muitas vezes é impossível trabalhar apenas com os

comandos de seleção e alteração de dados diretamente na tabela. Para manipular localmente os dados,
o ABAP permite o uso de tabelas internas, que são áreas de memória organizadas como tabelas.
Essas tabelas internas podem ter o mesmo formato de uma tabela do banco de dados, o que as
qualifica para serem usadas como áreas de manipulação intermediária, o que traz benefícios em
termos de performance geral do R/3. Uma tabela interna é declarada através do comando DATA,
onde se especifica qual é o tipo de linha da tabela, se ela tem headerline e qual é a forma de operação
da mesma. A tabela pode ser manipulada por comandos de inserção (APPEND, INSERT,
COLLECT), deleção (DELETE, REFRESH) e alteração de dados (MODIFY, COLLECT).
Por exemplo, para declarar uma tabela interna, conforme no exemplo, usou-se a declaração
TYPES para declarar uma estrutura que contém os campos que desejamos ter na tabela. Em seguida,
a tabela é criada através da declaração DATA, usando a estrutura como modelo.
Tipos de tabelas internas
O ABAP oferece três tipos de tabelas internas: STANDARD, SORTED e HASHED. As

tabelas standard permitem o acesso sequencial aos dados, além de permitir o acesso mediante as
chaves especificadas na declaração das tabelas. As tabelas do tipo sorted já estão pré-ordenadas de
acordo com a chave – as operações realizadas nesse tipo de tabela devem ter o cuidado de não alterar
a ordem, sob pena de ocorrer um erro de execução. As tabelas do tipo hashed são organizadas de
acordo com a chave especificada e não permitem operações utilizando o número sequencial dos
registros. São adequadas a grandes volumes de dados.
Extracts
Extracts são estruturas de dados especiais que permitem montar uma área interna com
registros de tipos diferentes. A tabela interna está limitada a um tipo de linha de dados (registro) fixo,
enquanto o extract pode receber linhas com várias estruturas diferentes. Por exemplo, suponha que
você tenha que gerar um relatório das tabelas SPFLI e SFLIGHT. Você pode montar um extract
com linhas da SPFLI e da SFLIGHT em registros diferentes:
REPORT ZHELLO2.
TABLES: SPFLI, SFLIGHT.
FIELD-GROUPS: HEADER, CARRINFO, CONNINFO.
INSERT: SPFLI-CARRID SPFLI-CONNID SFLIGHT-FLDATE INTO HEADER.

INSERT: SPFLI-CITYFROM SPFLI-CITYTO INTO CARRINFO.
INSERT: SFLIGHT-PLANETYPE SFLIGHT-SEATSOCC SFLIGHT-SEATSMAX INTO
CONNINFO.
SELECT * FROM SPFLI.

EXTRACT CARRINFO.
SELECT * FROM SFLIGHT
WHERE CARRID = SPFLI-CARRID AND
CONNID = SPFLI-CONNID.
EXTRACT CONNINFO.
ENDSELECT.
ENDSELECT.
SORT.
LOOP.
AT CARRINFO.
WRITE: / SPFLI-CITYFROM, SPFLI-CITYTO.
ENDAT.
AT CONNINFO.
WRITE: /10 SFLIGHT-PLANETYPE, SFLIGHT-SEATSOCC, SFLIGHT-SEATSMAX.
ENDAT.
ENDLOOP.
No comando FIELD-GROUPS, são especificados os grupos de campos que serão usados no

extract. O grupo header deve sempre ser utilizado. Nesse grupo, você deverá incluir os campos que
fazem parte da chave de todos os tipos de registro que você terá em seu extract.
O comando INSERT insere os campos em cada tipo de registro (grupo de campos) definido.
Usando o comando EXTRACT, os dados são copiados para um novo registro com o tipo
especificado.
Para ler os dados do extract, primeiramente seu conteúdo deve ser ordenado, usando-se o
comando SORT. Não é necessário especificar que trata-se de um extract, o sistema o especifica
automaticamente. Feito o SORT, pode-se usar o comando LOOP..ENDLOOP para extrair os dados,
usando os eventos AT <nome field-group> para cada quebra de tipo de registro.
O Open SQL
O ABAP oferece um conjunto de comandos que permite realizar operações com os dados
armazenados no banco, o Open SQL. A idéia central do Open SQL é prover uma linguagem de
acesso ao banco independente de plataforma. Os comandos Open SQL têm de passar pelo
interpretador ABAP, que os traduz para os comandos SQL do banco de dados que esteja sendo
utilizado.
Comandos
Dentro do Open SQL, podem-se utilizar os seguintes comandos:
⁄ SELECT: permite a leitura de dados do banco de dados.
⁄ INSERT: insere dados no banco.
⁄ UPDATE: atualiza dados.
⁄ MODIFY: atualiza dados existentes ou os acrescenta caso não existam no banco.
⁄ DELETE: apaga registros do banco de dados.
⁄ OPEN CURSOR, FETCH, CLOSE CURSOR: respectivamente cria, lê e fecha um

cursor dentro do banco de dados.
Campos de sistema
Os dois principais campos de sistema envolvidos em operações do Open SQL são o SY-
SUBRC, que retorna 0 caso a operação tenha sido bem-sucedida, e o SY-DBCNT, que retorna o
número de registros afetados pelo comando.
Trabalhando com os Mandantes
Num comando Open-SQL não é necessário especificar o mandante nas cláusulas

discriminadoras dos comandos. Automaticamente, o interpretador ABAP definirá o mandante como
o mandante atual, a não ser que seja especificada a opção CLIENT SPECIFIED.
SELECT
O comando SELECT retorna um conjunto de dados (registros) que atendam a um

determinado critério. As cláusulas do comando SELECT são as seguintes:
⁄ SELECT <lista de campos>: Pode-se selecionar uma lista de campos a serem

retornados, separados por espaços, ou o caractere * para retornar todos os campos
disponíveis. A opção SINGLE retorna somente um registro que atenda às restrições
impostas. Caso a tabela tenha sido declarada através de TABLES, é automaticamente
criada um registro na memória com o mesmo nome para manipulá-la; caso o
SELECT traga campos de mais de uma tabela, não é possível utilizar esse artifício.
Nesse caso, as tabelas não precisam ser declaradas em TABLES, mas a seleção dos
campos deve separar o nome da tabela e o campo com um til (~). Exemplo:
TABLES: SFLIGHT.
DATA: IT_SFLIGHT LIKE SFLIGHT.
SELECT CARRID CONNID FLDATE SEATSOCC

FROM SFLIGHT INTO TABLE IT_SFLIGHT.
Ou
DATA: IT_SFLIGHT LIKE SFLIGHT.
SELECT SFLIGHT~CARRID SFLIGHT~CONNID SFLIGHT~FLDATE SFLIGHT~SEATSOCC

FROM SFLIGHT INTO TABLE IT_SFLIGHT
⁄ INTO [<lista de campos>| TABLE <tabela interna>]: Permite armazenar o retorno

numa tabela interna ou em campos definidos com o comando DATA. O uso de
SELECT sem especificar SINGLE ou INTO TABLE exige o uso de ENDSELECT.
⁄ FROM <tabela> [[INNER|LEFT OUTER] JOIN <tabela>, ..]: Especifica a origem

dos dados.
⁄ WHERE <condições>: A cláusula WHERE especifica as condições de busca. Por

exemplo, WHERE CARRID = ‘AA’ faz com que apenas os registros em que o
campo CARRID tenha conteúdo igual a ‘AA’ sejam retornados.
Maiores detalhes sobre o comando SELECT podem ser encontrados no Help On-Line do R/3.
INSERT
O comando INSERT insere um novo registro no banco de dados, a partir de uma área de
dados especificada em TABLES ou uma área declarada com DATA. Para usar INSERT, deve-se
colocar os dados desejados na área intermediária e, em seguida, chamar o comando INSERT. Caso a
área não seja especificada em TABLES, deve ser usada a opção FROM:
REPORT ZTESTE.
TABLES SPFLI.
DATA WA TYPE SPFLI.

WA-CARRID = 'LH'.
WA-CITYFROM = 'WASHINGTON'.
...
INSERT INTO SPFLI VALUES WA.
WA-CARRID = 'UA'.
WA-CITYFROM = 'LONDON'.
...
INSERT SPFLI FROM WA.
SPFLI-CARRID = 'LH'.
SPFLI-CITYFROM = 'BERLIN'.
...
INSERT SPFLI.
UPDATE
O comando UPDATE funciona como o comando INSERT, podendo alterar dados no

banco a partir de uma área ou tabela interna. No caso da tabela interna, não é necessário especificar a
cláusula WHERE: serão alterados os registros correspondentes de acordo com as chaves. Por
exemplo:
DATA: ITAB TYPE HASHED TABLE OF SPFLI

WITH UNIQUE KEY CARRID CONNID,
WA LIKE LINE OF ITAB.
WA-CARRID = 'UA'. WA-CONNID = '0011'. WA-CITYFROM = ...

INSERT WA INTO TABLE ITAB.
WA-CARRID = 'LH'. WA-CONNID = '1245'. WA-CITYFROM = ...

WA-CARRID = 'AA'. WA-CONNID = '4574'. WA-CITYFROM = ...

...
UPDATE SPFLI FROM TABLE ITAB.
MODIFY
O comando MODIFY opera da mesma forma que o comando UPDATE, mas insere um
novo registro caso o registro especificado não exista.
DELETE
O comando DELETE elimina registros do banco. Ele opera da mesma forma que o
comando INSERT.
OPEN CURSOR, FETCH, CLOSE CURSOR
Esses comandos permitem acessar o resultado da query sequencialmente, um registro após o

outro. Seu uso é desencorajado, por incorrer em problemas de performance. Recomenda-se o uso de
tabelas internas em seu lugar.
Criação de List as Básicas
O comando WRITE
O comando básico para criação de relatórios usando ABAP é o WRITE. Quando um

programa ABAP é executado, basta o interpretador ABAP encontrar este comando para disparar o
gerador de lista. A lista é um relatório visualmente simples, montado com letras de espaçamento
constante. Essa simplicidade aumenta a independência de plataforma do gerador de lista.
Criando uma lista simples
A sintaxe básica do comando é a seguinte:

WRITE [:] [/] [<campo>|<literal>] [, <campo>|<literal>] [, ...] [opções].
A sintaxe completa do comando pode ser encontrada no Help do R/3. Existem opções para
alterar a cor dos elementos da tela, criação de molduras e inserção de ícones na lista. Observe o
código a seguir:
REPORT ZAPOSTILA00 .
SELECT * FROM SPFLI.
WRITE: / SPFLI-CARRID, SPFLI-CONNID, SPFLI-CITYFROM,
SPFLI-AIRPFROM, SPFLI-CITYTO, SPFLI-AIRPTO.
ENDSELECT.
Com esse trecho de código apenas, o R/3 gera uma lista simples do conteúdo de alguns
campos da tabela SPFLI:
Cabeçalhos e rodapés
Existem alguns comandos e opções que permitem melhorar o aspecto e a funcionalidade de
cabeçalho usando a opção Saltar å Elementos de Texto å Títulos de Lista. Nesse caso, deve-se saber
uma lista. No exemplo, a lista ainda não tem cabeçalho. Para criá-los, pode-se editar diretamente o
Sistema å Lista å Título da Lista é possível editar o título no momento da exibição da lista, facilitando
previamente em que posição deve ficar o texto no cabeçalho. Por outro lado, utilizando-se a opção
muito o posicionamento dos textos. Também é possível suprimir a geração do título básico,
substituindo-o por um título composto pelo programa ABAP. Para tanto, deve-se colocar na
declaração REPORT do início do programa a opção NO STANDARD PAGE HEADING e
implementar no programa o evento TOP-OF-PAGE. Caso também queira um rodapé para cada
página, use o evento END-OF-PAGE para escrevê-lo.
Mudando a apresentação dos campos
Para melhorar a apresentação da lista, podemos modificar a forma como os campos são
exibidos. Por exemplo, podemos mudar a cor com a opção COLOR do comando WRITE; podemos
mudar a intensidade da cor com a opção INTENSIFIED {ON|OFF}, transformar o campo num
HOTSPOT para uso em listas com drill-down, e mudar o posicionamento dos campos com WRITE
AT. A opção COLOR admite qualquer uma das cores padrão do R/3, disponíveis na transação
LIBS:
Por exemplo, para modificar um campo de forma a usar a cor COL_KEY menos intensa,
como hotspot, centralizado, escreveríamos o código como segue:
WRITE: / SPFLI-CARRID COLOR COL_KEY INTENSIFIED OFF HOTSPOT CENTERED.
A opção HOTSPOT faz com que, ao se apontar o campo com o cursor, o mesmo fique no
formato de uma “mãozinha”, como num hyperlink da Internet, permitindo a seleção do registro com
um único clique do mouse. Essa característica é muito útil no processamento de listas em vários
níveis.
Modificando o formato de exibição standard
As opções dentro do comando WRITE têm efeito apenas no campo a que se referem. Caso se
necessite mudar todos os campos a partir de um determinado ponto do programa, pode-se usar o
comando FORMAT, com as mesmas opções de formatação vistas para o comando WRITE. Com
isso, todos os campos a seguir serão exibidos com as opções especificadas pelo comando FORMAT,
até que seja encontrado um novo comando FORMAT. Pode-se continuar usando os modificadores
no WRITE, mas os mesmos irão basear-se no novo padrão estabelecido no comando WRITE. Por
exemplo, caso seja colocado o comando
FORMAT COLOR COL_KEY INTENSIFIED ON CENTERED
todos os campos a seguir passarão a ser exibidos na cor COL_KEY INTENSIFIED, e serão
apresentados centralizados. Caso tenhamos em seguida o comando
WRITE: / SPFLI-CARRID INTENSIFIED OFF, SPFLI-CONNID.
a cor exibida para o campo SPFLI-CARRID será COL_KEY INTENSIFIED OFF, e não a cor
padrão sem INTENSIFIED. O campo SPFLI-CONNID aparecerá da forma estipulada no
comando FORMAT.
O formato pode retornar ao formato standard usando o comando FORMAT RESET.
Posicionando os campos
Pode-se alterar o posicionamento dos campos dentro de uma linha colocando o número da
coluna na qual queremos que o campo comece na frente do campo. Pode-se também especificar a
largura do campo colocando a mesma em seguida, entre parênteses (sem essa opção, o tamanho do
campo utilizado será o tamanho dele no dicionário de dados). Por exemplo, para posicionarmos o
mesmo campo que modificamos anteriormente na décima coluna, estabelecendo um tamanho de
cinco caracteres, usamos o comando
WRITE: /10(5) SPFLI-CARRID COLOR COL_KEY INTENSIFIED OFF HOTSPOT.
Especificando unidades de medida e moedas
Para formatar automaticamente na lista campos numa determinada unidade de medida e

valores monetários, pode-se utilizar as opções UNIT e CURRENCY, seguidas do campo que
contém a chave da unidade, após o campo que se quer formatar. Com isso, o campo será formatado
de acordo com a definição nas tabelas standard de unidades e de moedas do R/3. Veja o exemplo a
seguir:
WRITE: /20(6) SFLIGHT-FLDATE,

SFLIGHT-CURRENCY,
'Sem CURRENCY:', (12) SFLIGHT-PAYMENTSUM,
'Com CURRENCY:', (12) SFLIGHT-PAYMENTSUM
CURRENCY SFLIGHT-CURRENCY.
Um trecho do report seria:

150420 ITL Sem CURRENCY: 683.231,44 Com CURRENCY: 68.323.144
130520 ITL Sem CURRENCY: 318.202,60 Com CURRENCY: 31.820.260
Sem o uso da opção CURRENCY, o valor é apresentado no formato genérico do usuário; com
o CURRENCY, mesmo caso tenhamos moedas diferentes em cada registro, cada uma será exibida
no formato correto.
Símbolos de Texto
O ABAP permite a criação de símbolos de texto, que são elementos do repositório que
permitem a criação de tabelas de texto para uso nos programas ABAP. Os símbolos de texto são
criados dentro de classes de mensagem, que servem para separar logicamente os símbolos de texto
relacionados. Dentro da classe de mensagem, cada texto deve ser identificado por um número de três
posições. Cada símbolo de texto pode ser criado em várias linguagens.
Suponha que exista o seguinte trecho de código:
WRITE: /10 'Assentos ocupados:', SFLIGHT-SEATSOCC.
Utilizando símbolos de texto, o comando ficaria

WRITE: /10 TEXT-001(ZCLMENS), SFLIGHT-SEATSOCC.
Toda vez que o interpretador ABAP encontra um campo que começa com TEXT, coloca
naquela posição um símbolo de texto correspondente ao número após o hífen na classe entre
parênteses. Caso seja usada a opção MESSAGE-ID <classe> na declaração REPORT, não é
necessário especificar a classe de mensagem junto ao símbolo de texto. O uso de símbolos de texto
pode simplificar a manutenção de programas complexos ao agrupar todas as mensagens de texto em
um só local.
Para editar os símbolos de texto, use, na janela do editor ABAP, a opção Saltar å Elementos
de Texto å Símbolos de Texto.
- Criando tabelas internas e estruturas complexas de armazenagem temporária

- O Open SQL
- Criação de Listas Básicas
Exercício 1
Criar um programa que imprima os campos CARRID, CONNID, CITYFROM,
AIRPFROM, CITYTO e AIRPTO da tabela SPFLI. Os dados devem ser armazenados em uma
tabela interna antes de serem impressos.
O relatório deve ser impresso com as cores das linhas intercaladas entre cinza e branco.
Exercício 2
Utilizando o comando DELETE do Open_SQL, apague da tabela interna todos os registros
onde o campo CITYFROM = ‘SINGAPORE’.
Exercício 3
Monte o cabeçalho como a seguir:
Nota: As descrições devem estar definidas como símbolos de texto.
RELAÇÃO DE VÔOS
ID Num. Partindo de Aer. Pousando em Aer.
Solução:
Exercício 1

2. Entre com o nome do Programa a ser criado e, com o botão de rádio Código Fonte
selecionado, clique sobre o botão CRIAR.
3. Na janela de Atributos do Programa, digite o título do programa e defina o tipo de
programa como Programa Executável e a Aplicação.
5. Na janela do editor, digite o código:
DATA: lc_cor type c value '1',
begin of T_SPFLI occurs 0,

carrid like spfli-carrid,
connid like spfli-connid,
cityfrom like spfli-cityfrom,
airpfrom like spfli-airpfrom,
cityto like spfli-cityto,
airpto like spfli-airpto,
end of T_SPFLI.
START-OF-SELECTION.
SELECT carrid connid cityfrom airpfrom cityto airpto

FROM SPFLI into table T_SPFLI.
Loop at T_SPFLI.
if lc_cor = '1'.
FORMAT COLOR 2 INTENSIFIED OFF.
clear lc_cor.
else.
FORMAT RESET.
lc_cor = '1'.
endif.
WRITE: / T_SPFLI-CARRID, T_SPFLI-CONNID,
T_SPFLI-CITYFROM, T_SPFLI-AIRPFROM,
T_SPFLI-CITYTO, T_SPFLI-AIRPTO.
Endloop.
Exercício 2
1. No programa, após a seleção dos dados, digitar o código:

Código: DELETE t_spfli WHERE cityfrom = 'SINGAPORE'.
Exercício 3
na opção Saltar å Elementos de Texto å Símbolos de Texto e defina os símbolos com os

1. Na tela de edição do programa, para definir os símbolos de texto para o cabeçalho, entre
textos:
001 RELAÇÃO DE VÔOS
002 ID
003 Num.
004 Partindo de
005 Aer.
006 Pousando em
2. Salve os textos e Ative.

3. Na tela de edição do programa, entre a declaração da tabela interna e o evento START-
OF-SELECTION, digite o código:
TOP-OF-PAGE.
WRITE: /22 text-001, 60 ''.
FORMAT COLOR 2 INTENSIFIED ON.
WRITE: /1 text-002, 05 text-003, 10 text-004,
31 text-005, 35 text-006, 56 text-005, 60 ''.
Nota: 60 ''. é usado para que a linha fique da cor desejada até a coluna 60.
O SAP Query
Algumas consultas podem ser elaboradas usando-se a ferramenta SAP Query. Nela, é possível ao
usuário criar consultas visualmente, sem conhecimento da linguagem de programação.
Os dados em uma Query podem ser ordenados, agrupados, totalizados, etc., e os relatórios podem
ser impressos, gravados em planilhas, arquivos ou editores de texto, ou podem ser enviados a um ou
mais destinatários.
Exemplo de utilização de Querys:
• Relatórios simples e de utilização esporádica.
• Auxiliar na conferência das Cargas de Dados.
• Listar dados incorretos no pós-Go Live.
A utilização de Querys é desaconselhada para:

• Criar relatórios complexos, que exijam a leitura de várias tabelas no banco de dados, ou que
sejam utilizados com freqüência.
• Listar dados que “não existem” no banco de dados.
Exemplo: Produtos Acabados sem Listas Técnicas
Pontos Positivos Pontos Negativos
X Possibilita criar relatórios rapidamente sem a X Baixa performance se comparado com

necessidade de criar programas em ABAP. programas ABAP.
X Os relatórios podem ser criados por usuários X Limitações para relatórios que exigem a
finais. leitura de muitas tabelas.
X Facilidades e recursos na sua criação e X Não é possível incluir lógica de

utilização. programação.
X Controle de acesso aos dados é deficiente.
Grupos de usuários e áreas funcionais
Para poder criar uma SAP Query, deve existir pelo menos um grupo de usuários e uma
área funcional criados. O grupo de usuários contém os usuários que podem criar e rodar queries, e
as áreas funcionais são definições de quais dados serão usados na query. Por exemplo, pode-se criar
uma área funcional com um join de várias tabelas e com campos calculados, além dos campos
definidos nas tabelas. A área funcional deve estar sempre associada a um ou mais grupos de usuários
para ser utilizada, e apenas os usuários que fazem parte dos grupos podem criar queries que a
acessem.
As áreas funcionais são criadas na transação SQ02, e os grupos de usuários são definidos na
transação SQ03.
Criando um grupo de usuários – os grupos de usuários são criados na transação SQ02. A
operação é muito simples – basta definir o nome do grupo e uma descrição, e em seguida colocar os
nomes dos usuários que dele fazem parte.
Criando uma área funcional – as áreas funcionais são criadas na transação SQ03. Nela são
definidas as tabelas que compõem a área funcional, e seus relacionamentos. que é um conjunto de
dados a serem usados pela query (composto de tabelas, visões e/ou dados de arquivos TXT, por
exemplo).
A query propriamente dita é criada usando-se a transação SQ01. Nela, escolhe-se a área
funcional que será usada na query (há uma lista com as áreas funcionais associadas ao grupo ao qual
o usuário pertence) e qual será a estrutura da lista a ser exibida.
Definindo t elas de seleção de parâmet ros
Para selecionar intervalos de dados a serem exibidos em um relatório, o R/3 disponibiliza os

comandos PARAMETERS e SELECT-OPTIONS.
Em todo relatório, existe uma tela padrão de seleção – a tela 1000 – que é ativada sempre que
o sistema encontra uma declaração PARAMETERS ou SELECT-OPTIONS sem especificação de
número de tela. Portanto, para criar uma tela de seleção simples, basta especificar dentro do
programa os parâmetros, como no exemplo a seguir:
REPORT ZAPOSTILA00 .
TYPES: BEGIN OF MYSTRUCT,

CARRID LIKE SPFLI-CARRID,
CONNID LIKE SPFLI-CONNID,
FLDATE LIKE SFLIGHT-FLDATE,
SEATSOCC LIKE SFLIGHT-SEATSOCC,
SEATSMAX LIKE SFLIGHT-SEATSMAX,
SEATFREE LIKE SFLIGHT-SEATSMAX,
END OF MYSTRUCT.
DATA: MYTABLE TYPE STANDARD TABLE OF MYSTRUCT

WITH NON-UNIQUE KEY CARRID CONNID
WITH HEADER LINE.
SELECT-OPTIONS: S_CARRID FOR SPFLI-CARRID,

S_CONNID FOR SPFLI-CONNID.
PARAMETERS: S_CHECK AS CHECKBOX,

S_RADIO1 RADIOBUTTON GROUP RAD,
S_RADIO2 RADIOBUTTON GROUP RAD,
S_RADIO3 RADIOBUTTON GROUP TTN,
S_RADIO5 RADIOBUTTON GROUP TTN.
…
Diferença entre o comando PARAMETERS e o comando SELECT-OPTIONS
O comando PARAMETERS permite que se especifique um valor único e oferece a opção de

colocar os valores como checkboxes, nos quais o usuário pode escolher como um flag, ou radiobuttons,
que devem ser agrupados para que o usuário escolha entre as opções disponíveis num grupo.
Sintaxe básica do comando PARAMETERS:
PARAMETERS: p_carrid LIKE spfli-carrid.
O comando PARAMETERS pode aceitar características adicionais, que são opcionais, as

mais utilizadas são:
DEFAULT : Toda vez que o programa é executado, o campo já vem preenchido com um
valor default na tela de seleção.
DECIMALS dec: Número de casas decimais para campos tipo p.

MEMORY ID: Toda vez que o programa é executado, o campo já vem preenchido com o
último valor entrado pelo usuário em um campo com o mesmo Memory ID.
MATCHCODE OBJECT mobj: Atribui um matchcode para o campo.
NO-DISPLAY: Não exibe o campo na tela de seleção.
LOWER CASE: O campo se torna sensível a letras maiúsculas e minúsculas.
OBLIGATORY: O preenchimento do campo é obrigatório.
A cláusula WHERE, nos comandos OPEN-SQL, deve se referir ao campo normalmente,
como no exemplo:
SELECT carrid connid FROM spfli WHERE carrid = p_carrid.
ENDSELECT.
O comando SELECT-OPTIONS tem como característica que o campo de seleção possa

conter um ou mais intervalos de valores possíveis, inclusive indicando intervalos e valores que devem
ser excluídos do resultado. Como o SELECT-OPTIONS permite uma “extensão” de seleção, o SAP
guarda os valores do SELECT-OPTIONS em uma tabela interna de quatro campos, similar a esta:
SIGN OPTION LOW HIGH

I NE DL
I BT AA LH
Este exemplo, significa que os valores para esta seleção devem estar entre ‘AA’ e ‘LH’,
excluindo ‘DL’.
Sintaxe básica do comando SELECT-OPTIONS:
SELECT-OPTIONS: s_carrid FOR spfli-carrid.
O comando SELECT-OPTIONS pode aceitar características adicionais, que são opcionais,

as mais utilizadas são:
DEFAULT : Toda vez que o programa é executado, o campo já vem preenchido com um
VALOR default na tela de seleção.
DEFAULT g TO h: Toda vez que o programa é executado, o campo já vem preenchido com
um INTERVALO default na tela de seleção.
DEFAULT g ... OPTION xx ... SIGN s e DEFAULT g TO h ... OPTION xx ... SIGN s:
Definir os VALORES e INTERVALOS default que devem ser excluídos do resultado.
O valor default para SIGN é I (Inclusão) e para OPTION é EQ (Igual).
O campo SIGN também pode aceitar o valor E (Exclusão), e o campo OPTION pode
aceitar os valores: EQ (Igual), NE (Não Igual), CP (Contém (para valores com *)), NP (Não pode
conter (valores com *)), GE (Maior Igual), LT (Menor que), LE (Menor Igual) e GT (Maior que).
MEMORY ID pid: MEMORY ID: Toda vez que o programa é executado, o campo já vem
preenchido com o último valor entrado pelo usuário em um campo com o mesmo Memory ID.
MATCHCODE OBJECT mobj: : Atribui um matchcode para o campo.
NO-DISPLAY: Não exibe o select-option na tela de seleção.
LOWER CASE: O campo se torna sensível a letras maiúsculas e minúsculas.
OBLIGATORY: O preenchimento é obrigatório.
NO-EXTENSION: Não exibe o botão a direita do select-option, permitindo somente um
intervalo de seleção.
NO INTERVALS: Não exibe a segunda caixa do intervalo. Não permitindo assim definição
de intervalos na seleção.
A cláusula WHERE, nos comandos OPEN-SQL, deve se referir ao campo como no
exemplo:
SELECT carrid connid FROM spfli WHERE carrid IN s_carrid.
ENDSELECT.
Agrupando parâmetros em bordas e melhorando o layout
Pode-se melhorar o layout dos parâmetros logicamente relacionados agrupando-os em blocos

com a opção BEGIN OF BLOCK…END OF BLOCK. Caso usemos o exemplo anterior sem
nenhuma outra formatação, a saída na tela ficará confusa:
Modificando o programa para usar bordas
Para melhorar o aspecto da janela de seleção anterior, vamos utilizar a opção BEGIN OF
BLOCK … END OF BLOCK no mesmo trecho de código:
…
SELECTION-SCREEN BEGIN OF BLOCK BL1 WITH FRAME TITLE TEXT-001.
SELECTION-SCREEN END OF BLOCK BL1.
PARAMETERS: S_CHECK AS CHECKBOX.


PARAMETERS: S_RADIO1 RADIOBUTTON GROUP RAD,
S_RADIO2 RADIOBUTTON GROUP RAD.

PARAMETERS: S_RADIO3 RADIOBUTTON GROUP TTN,
SELECTION-SCREEN END OF BLOCK BL4

.…
Com isso, criamos bordas ao redor de cada grupo logicamente ligado, melhorando o aspecto da tela e
evitando confusão no momento de sua utilização:
Janelas adicionais de parâmetros
Podem ser definidas janelas além da janela 1000 default – para tanto, basta agrupar os select-
options e parameters dentro das declarações SELECTION-SCREEN BEGIN OF SCREEN
<número da tela> e SELECTION SCREEN END OF SCREEN <número da tela>. Essa janela
deverá ser posteriormente chamada com o uso do comando CALL SELECTION SCREEN seguido
do número definido da tela, inclusive podendo-se transformá-la numa tela modal usando a opção AS
WINDOW na declaração SELECTION-SCREEN BEGIN OF SCREEN e a opção STARTING
AT/ENDING AT com as coordenadas (coluna, linha) das extremidades superior esquerda e inferior
direita da tela na chamada CALL SELECTION SCREEN. Por exemplo, modificando o código da
seguinte forma:
...


PARAMETERS: S_CHECK AS CHECKBOX.
SELECTION-SCREEN BEGIN OF SCREEN 0150 AS WINDOW.

PARAMETERS: S_RADIO1 RADIOBUTTON GROUP RAD,
S_RADIO2 RADIOBUTTON GROUP RAD.

PARAMETERS: S_RADIO3 RADIOBUTTON GROUP TTN,
SELECTION-SCREEN END OF SCREEN 0150.
START-OF-SELECTION.
CALL SELECTION-SCREEN 0150 STARTING AT 20 5 ENDING AT 90 15.
...
Além de surgir a janela padrão de select-options, surgirá uma nova janela modal a seguir:
Criação de List as Complexas
Até agora, as listas criadas apresentam um nível de dados apenas, mas o ABAP tem recursos
que permitem a exibição de listas de detalhe a partir de uma lista.
O Evento AT LINE-SELECTION
O processamento das listas de detalhe dentro do R/3 é feito pelo evento AT LINE-
SELECTION. O R/3 executa os comandos que houver dentro desse evento toda vez que o usuário
clica duas vezes sobre uma linha em uma lista ouclica sobre um campo marcado com HOTSPOT, ou
teclando-se F2 sobre um registro, ou escolhendo um botão que tenha o código standard ‘PICK’ a ele
associado.
HIDE
Através do comando HIDE, é possível armazenar informação a respeito de uma linha para
uso do evento AT LINE-SELECTION. Suponha que exista uma lista com os vôos para uma
determinada companhia aérea, e deseja-se exibir as reservas para aquele vôo. Para exibir a lista, é
necessário armazenar em algum local informações sobre a linha selecionada pelo usuário, e isso pode
ser feito através do comando HIDE do ABAP.
O comando HIDE guarda a informação sobre os campos desejados, além do número da
linha que está sendo processada, em uma tabela interna, que é automaticamente acessada no evento
AT LINE-SELECTION. Veja o seguinte exemplo:
REPORT ZTESTE.
TABLES: SFLIGHT, SBOOK.
START-OF-SELECTION.
SELECT * FROM SFLIGHT.

WRITE: SFLIGHT-CARRID, SFLIGHT-CONNID, SFLIGHT-FLDATE, SFLIGHT-SEATSOCC.
HIDE: SFLIGHT-CARRID, SFLIGHT-CONNID, SFLIGHT-FLDATE.
ENDSELECT.
AT LINE-SELECTION.
SELECT * FROM SBOOK
WHERE CARRID = SFLIGHT-CARRID AND
CONNID = SFLIGHT-CONNID AND
FLDATE = SFLIGHT-FLDATE.
WRITE: / SBOOK-CARRID, SBOOK-CONNID, SBOOK-FLDATE, SBOOK-CUSTOMID.
ENDSELECT.
Dentro desse programa, a cada linha lida no comando SELECT, está sendo armazenada
informação sobre a chave dentro da área de HIDE. Não é necessário que os campos selecionados
com HIDE façam parte da lista impressa via WRITE. Quando o usuário seleciona um determinado
registro, o processador de lista ABAP automaticamente procura na área de HIDE o registro

correspondente àquele número de linha, e os disponibiliza para uso com o mesmo nome.
Cabeçalhos de listas secundárias

Para definir um cabeçalho próprio para listas secundárias, existe o evento TOP-OF-PAGE
DURING LINE-SELECTION, que permite redefinir o cabeçalho e os comandos disponíveis
dentro da lista secundária. Por exemplo,
REPORT ZTESTE NO STANDARD PAGE HEADING.
START-OF-SELECTION.
...
TOP-OF-PAGE.
SET PF-STATUS ‘LISTA1’.
WRITE: ‘Lista Primária’.
TOP-OF-PAGE DURING LINE-SELECTION.

SET PF-STATUS ‘LISTA2’.
WRITE: ‘Lista Secundária’.
AT LINE-SELECTION.
...
Listas em mais de dois níveis
Quando a lista apresentar mais de dois níveis, é necessário identificar o nível que está sendo
processado – só existe um evento AT LINE-SELECTION e um TOP-OF-PAGE DURING LINE-
SELECTION por programa. Para tanto, deve-se utilizar o campo de sistema SY-LSIND, que tem o
nível corrente de lista. A primeira sub-lista tem SY-LSIND igual a 1, a segunda, 2, e assim por diante,
até o subnível máximo 19. Por exemplo:
REPORT ZTESTE2N NO STANDARD PAGE HEADING.
START-OF-SELECTION.
SELECT * FROM SFLIGHT.

WRITE: SFLIGHT-CARRID, SFLIGHT-CONNID, SFLIGHT-FLDATE, SFLIGHT-SEATSOCC.
HIDE: SFLIGHT-CARRID, SFLIGHT-CONNID, SFLIGHT-FLDATE.
ENDSELECT.
TOP-OF-PAGE.
WRITE: ‘Vôos’.
TOP-OF-PAGE DURING LINE-SELECTION.

CASE SY-LSIND.
WHEN 1.
WRITE: ‘Reservas’.
WHEN 2.
WRITE: ‘Cliente’.
ENDCASE.
AT LINE-SELECTION.
CASE SY-LSIND.
WHEN 1.
SELECT * FROM SBOOK
HIDE: SBOOK-CUSTOMID.
ENDSELECT.
WHEN 2.
SELECT * FROM SCUSTOM
WHERE ID = SBOOK-CUSTOMID.
WRITE: / SCUSTOM-ID, SCUSTOM-NAME.
ENDSELECT.
ENDCASE.
AT USER-COMMAND
O processamento de lista também pode ser feito através do evento AT USER-COMMAND.

Nesse caso, será feito o processamento dos comandos (menu, teclas de função, botões da barra),
além do comando standard PICK.
Abrindo Telas Dentro de Relatórios
Uma lista secundária pode ser mostrada dentro de uma janela ao colocar-se a declaração
WINDOW STARTING AT <col> <lin> [ENDING AT <col> <lin>]. Os comandos WRITE
subseqüentes serão direcionados para a janela especificada. Por exemplo, alterando o código da
seguinte maneira, podemos criar janelas nas listas secundárias:
AT LINE-SELECTION.
CASE SY-LSIND.
WHEN 1.
WINDOW STARTING AT 5 3 ENDING AT 40 10.
SELECT * FROM SBOOK
HIDE: SBOOK-CUSTOMID.
ENDSELECT.
WHEN 2.
SELECT * FROM SCUSTOM
WHERE ID = SBOOK-CUSTOMID.
WRITE: / SCUSTOM-ID, SCUSTOM-NAME.
ENDSELECT.
ENDCASE.
Chamando transações a partir de listagens
Para chamar uma transação a partir de uma listagem, pode-se utilizar o comando CALL
TRANSACTION <codtran> dentro do AT LINE-SELECTION, onde <codtran> é o código da
transação. Após executar a transação, o controle de execução passará para a linha seguinte ao CALL
TRANSACTION.
- O SAP Query
- Definindo telas de seleção de parâmetros
- Criação de Listas Complexas
Exercício 1
1. Criar uma query, que exiba os CARRID, CONNID, CITYFROM, AIRPFROM,
CITYTO e AIRPTO da tabela SPFLI.
Exercício 2
1. Para o programa do exercício anterior, criar uma tela de seleção similar a:
Select-Options
Parameters
Sem extensão
Obrigatório
Exercício 3
1. Fazer com que toda vez que o cursor do mouse passe sobre um campo da coluna Vôo,
tome a forma de uma “mãozinha”.
2. Exiba uma janela contendo o nome da empresa aérea, o número do vôo, nome do
aeroporto, cidade e horário de saída do vôo e nome do aeroporto, cidade e horário de
chagada do vôo referente a linha clicada na tela.
Solução:
Exercício 1
1. Criar Grupo de Usuários:

1.1. Acessar a transação SQ03.
1.2. Entrar o nome do Grupo de Usuários e teclar em CRIAR.
1.3. Atribuir usuários ao Grupo e Salvar.
2. Criar a Área Funcional:

2.3. Entrar o nome da Área Funcional e teclar em CRIAR.
2.4. Entrar a Denominação e a primeira tabela que será lida.
Obs: Não confundir Grupo de autorização com Grupo de usuários.
2.5. A tela de junção de tabelas (JOIN) é exibida, inserir as tabelas na ordem em que
devem ser lidas.
2.6. Alterar a Condição Join, se necessário, clicando com o botão direito do mouse.
INNER: Só lista o registro da Tabela direita se o registro da Tabela esquerda
existir. Após a conclusão, Clicar F3 (Voltar).
2.7. Voltando da tela de JOIN,
2.8. Escolher: Criar Grupo de Campos Vazio.
2.9. Eliminar os Grupos de campos.
Obs: A SAP recomenda manter um Grupo de campos para cada tabela.
2.10. Criar um novo Grupos de Campos.
2.11. Arrastar os campos desejados para o Grupo de campos. A ordem dos campos não
é importante.
2.12. Gerar e salvar.
3. Atribuir a Área Funcional a um ou mais Grupos de Usuários:

4.2. Entrar o nome da Área Funcional e clicar sobre “Atribuição a Grupos de Usuários”.
4.3. Marcar os Grupos, salvar e sair.
4. Criar a Query:
4.2. Entrar o nome da Query e clicar em CRIAR.
4.3. Escolher a Área Funcional que será a base para a Query.
4.4. Entrar o Título (que será o título do relatório) e o número de colunas.
4.5. Clicar em Tela seguinte ou teclar F6.
4.6. Selecionar o Grupo ou os Grupos de campos que serão utilizados na Query.
OBS: Nem todos os Grupos de campos precisam ser utilizados.

4.7. Marcar os campos que serão Critério de seleção.
4.8. Indicar em que ordem os campos devem aparecer na tela de Seleção:
4.9. Neste ponto é recomendável salvar a Query e depois clicar em Lista básica.
4.10. Indicar em que linha do relatório cada campo deve ser exibido, em que seqüência,
qual o critério de ordenação e os campos que devem ser totalizados e contados.
4.1. Salvar.
Exercício 2

2. Entre com o nome do Programa a ser alterado e, com o botão de rádio Código Fonte
selecionado, clique sobre o botão MODIFICAR.
na opção Saltar å Elementos de Texto å Símbolos de Texto e defina os símbolos com os

3. Na tela de edição do programa, para definir os símbolos de texto para o cabeçalho, entre
textos:
007 Relação de Vôos
008 Localidades
4. Inclua os parâmetros como a seguir:

TABLES: spfli.
SELECTION-SCREEN BEGIN OF BLOCK bl1 WITH FRAME TITLE text-007.

SELECT-OPTIONS: s_carrid FOR spfli-carrid NO INTERVALS,
s_connid FOR spfli-connid.
SELECTION-SCREEN ULINE.
SELECTION-SCREEN BEGIN OF BLOCK bl2 WITH FRAME TITLE text-008.
PARAMETERS: p_cityfr LIKE spfli-cityfrom,
p_cityto LIKE spfli-cityto.
SELECTION-SCREEN END OF BLOCK bl2.
SELECTION-SCREEN END OF BLOCK bl1.
Exercício 3
1. Inclua a linha de comando HIDE, dentro do Looping de impressão dos registros:

LOOP AT t_spfli.
IF lc_cor = '1'.
CLEAR lc_cor.
ELSE.
FORMAT RESET.
lc_cor = '1'.
ENDIF.
WRITE: / t_spfli-carrid, t_spfli-connid,
t_spfli-cityfrom, t_spfli-airpfrom,
t_spfli-cityto, t_spfli-airpto, 60 ''.
HIDE: t_spfli-carrid, t_spfli-airpfrom, t_spfli-cityfrom,
t_spfli-deptime, t_spfli-airpto, t_spfli-cityto,
t_spfli-arrtime.
ENDLOOP.
2. Inclua o evento AT SELECTION-SCREEN com o código:
AT LINE-SELECTION.

SELECT carrname
FROM scarr
INTO lc_name
WHERE carrid = t_spfli-carrid.
WRITE: / 'Empresa Aérea:', lc_name.
ENDSELECT.
FORMAT COLOR 2 INTENSIFIED ON.
WRITE: / 'Vôo Número :', t_spfli-connid, 35 ''.
WRITE: / 'Partindo de :', 35 ''.
FORMAT reset.
SELECT name
FROM sairport
INTO lc_name
WHERE id = t_spfli-airpfrom.
write: /3 'Aeroporto :', lc_name.
endselect.
WRITE: /3 'Cidade :', t_spfli-cityfrom.

WRITE: /3 'Horário :', t_spfli-deptime.
WRITE: / 'Chegando em :', 35 ''.
FORMAT reset.
SELECT name
FROM sairport
INTO lc_name
WHERE id = t_spfli-airpto.
write: /3 'Aeroporto :', lc_name.
endselect.
WRITE: /3 'Cidade :', t_spfli-cityto.

WRITE: /3 'Horário :', t_spfli-arrtime.

ABAP 01-Libre PDF

Enviado por

Dados do documento

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?

Direitos autorais:

Formatos disponíveis

ABAP 01-Libre PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Int rodução aos Conceit os de

Desenvolviment o e Cust omização

Trabalhando com os Mandant es.............................................................. 32

Copyright 2005 I-PROVIDER. Todos os direitos reservados.

Como entender a apostila

Carga Horária : 28 horas

Conheciment os Básicos sobre a Plataforma de Desenvolviment o ABAP

O Repositório do R/3 é a coleção de todos os programas ABAP, classes, interfaces, grupos

Para encontrar os objetos no Repositório do R/3, existe o Sistema de Informação do

O dicionário ABAP permite a administração central de todas as definições de dados do R/3,

Durante a ativação, a descrição da tabela dentro do dicionário é traduzida para a definição de

O conceito de domínio de dois níveis

As características técnicas das tabelas do R/ 3

Verificações de chave externa (foreign keys)

Processos de ajuste e conversão de tabelas

Segue abaixo um conjunto de exercícios práticos para aprimorar o aprendizado referente a:

- Conhecimentos básicos sobre a plataforma de desenvolvimento ABAP

Criando seu primeiro programa ABAP

Vamos criar um programa ABAP simples para nos ambientarmos às peculiaridades da

WRITE: / ‘Alô, Mundo!’.

DATA: CAMPO_1(7) TYPE C,

SELECT CARRID CONNID FLDATE SEATSMAX SEATSOCC

CAMPO_1 = 'LIVRE: '.

LOOP AT IT_SFLIGHT INTO WA_SFLIGHT.

Bibliot ecas de Funções

O que são as funções no R/ 3

Os Criadores de Menus e Telas

As telas, dentro do R/3, podem ser classificadas em selection-screens e dialogs. As selection-

Segue abaixo um conjunto de exercícios práticos para aprimorar o aprendizado referente a:

Criando Tabelas Int ernas e Est rut uras Complexas de Armazenagem

TYPES: BEGIN OF MYSTRUCT,

DATA: MYTABLE TYPE STANDARD TABLE OF MYSTRUCT

Dentro de um programa ABAP, muitas vezes é impossível trabalhar apenas com os

Tipos de tabelas internas

O ABAP oferece três tipos de tabelas internas: STANDARD, SORTED e HASHED. As

TABLES: SPFLI, SFLIGHT.

FIELD-GROUPS: HEADER, CARRINFO, CONNINFO.

INSERT: SPFLI-CARRID SPFLI-CONNID SFLIGHT-FLDATE INTO HEADER.

SELECT * FROM SPFLI.

No comando FIELD-GROUPS, são especificados os grupos de campos que serão usados no

Dentro do Open SQL, podem-se utilizar os seguintes comandos:

⁄ SELECT: permite a leitura de dados do banco de dados.

⁄ INSERT: insere dados no banco.

⁄ UPDATE: atualiza dados.

⁄ MODIFY: atualiza dados existentes ou os acrescenta caso não existam no banco.

⁄ DELETE: apaga registros do banco de dados.

⁄ OPEN CURSOR, FETCH, CLOSE CURSOR: respectivamente cria, lê e fecha um

Trabalhando com os Mandantes

Num comando Open-SQL não é necessário especificar o mandante nas cláusulas

O comando SELECT retorna um conjunto de dados (registros) que atendam a um

⁄ SELECT <lista de campos>: Pode-se selecionar uma lista de campos a serem

DATA: IT_SFLIGHT LIKE SFLIGHT.

SELECT CARRID CONNID FLDATE SEATSOCC

DATA: IT_SFLIGHT LIKE SFLIGHT.

SELECT SFLIGHT~CARRID SFLIGHT~CONNID SFLIGHT~FLDATE SFLIGHT~SEATSOCC

⁄ INTO [<lista de campos>| TABLE <tabela interna>]: Permite armazenar o retorno

⁄ FROM <tabela> [[INNER|LEFT OUTER] JOIN <tabela>, ..]: Especifica a origem

⁄ WHERE <condições>: A cláusula WHERE especifica as condições de busca. Por

DATA WA TYPE SPFLI.

O comando UPDATE funciona como o comando INSERT, podendo alterar dados no

DATA: ITAB TYPE HASHED TABLE OF SPFLI

WA-CARRID = 'UA'. WA-CONNID = '0011'. WA-CITYFROM = ...

WA-CARRID = 'LH'. WA-CONNID = '1245'. WA-CITYFROM = ...