HANA

HANA – CRIAR PASTA NO REPOSITÓRIO

Entrar no eclipse

Selecione a perspectiva do Hana

Selecione a aba Systems

Clique com o botão direito no ambiente onde deseja conectar e clique em Log on

Informe a senha e clique em OK

Clique na aba repositories

Localize a pasta da sua turma e com o botão direito nela selecione new e depois Repository
Package

Será exibida uma janela com o nome da pasta da sua turma. Adicione um ponto “.” e depois o
nome da pasta que quer criar. Em seguida clique em Finish
Pronto a sua pasta estará criada e você poderá criar seus objetos dentro dela
 HANA - Criar Calculation view para tabela da SE11

Identificar na se11 a tabela para o qual se deseja criar a calculation view. Exemplo tabela Z:

No eclipse abrir a perspectiva Hana

Localizar a pasta onde será criada a calculation view

Com o botão direito na pasta selecionar New, e Calculation view

Preencher o nome da Calculation view, selecionar o tipo Graphical, em Data Category, deixar
em branco e clicar em Finish

A Calculation view será criada vazia

Clique na caixa Semantics, e vá até a aba View Properties. Coloque a propriedade Default
Client como “Cross Client” e limpe o campo Apply Privilegies
Clique na caixa Projection e selecione o botão “+” verde

Digite o nome da sua tabela, e aguarde até a pesquisa ser concluída. Selecione o nome da
tabela no esquema correto e clique em OK

A tabela será incluída na caixa projection

Na janela de Details marque os campos da tabela que deseja que fiquem disponíveis na view
que está criando

Os campos serão adicionados na tabela de saída da calculation view. Agora é só ativar.

 HANA - Criar Calculation view Script

Entrar no eclipse e selecionar a perspectiva Sap hana development

Selecionar a aba Systems, clicar no sistema que deseja conectar com o botão direito e escolher
Logon

Informe o usuário e senha e clique em OK

Verifique se o ícone verde apareceu, indicando que a conexão está ok

Selecione a aba Repositories

Expandir a pasta no sistema onde está conectado até abrir a pasta onde deseja criar a
calculation view (nesse caso a pasta treinamento)
Dentro da pasta treinamento, vamos criar a pasta “teste”, que vai ser a pasta onde você vai
criar os seus objetos hana. Clique com o botão direito na pasta treinamento, escolha New e
depois Repository Package

Complemente o nome da pasta com “.teste” e clique em Next

Coloque uma descrição (opcional) e clique em Finish

Certifique-se de que a pasta foi criada corretamente

Os passos acima só são necessários se você ainda não tem a pasta criada. Agora vamos criar a
calculation view. Clique com o botão direito na pasta onde quer criar a calculation view e
selecione New e depois Calculation view

Preencha o nome da calculation view, modifique o tipo da view para SQL Script e clique em
Finish
A calculation view será criada na pasta e será aberta do lado direito

Agora vamos ajustar as propriedades da calculation view. Clique uma vez para selecionar a
caixa Semantics, e depois clique na aba View Properties

Na aba View properties, limpe os campos Data Category e Apply Privileges

Agora vamos criar os placeholders. Placeholders são os parâmetros de entrada da calculation

view. Podemos definir nenhum, um, ou vários parâmetros de entrada. Eles podem ser
utilizados para fazer filtros nas tabelas que vamos selecionar dentro da calculation view. Para
isso clique na aba Parameters/Variables
Vamos criar 3 parâmetros, mandante, data inicio e data fim.

Para criar um parâmetro de entrada clique na seta para baixo do lado direito do botão “+” e
selecione Create Input Parameter

Informe o nome do primeiro parâmetro P_MANDT, o tipo de dados NVARCHAR, o tamanho 3 e

clique em OK

Veja que o parâmetro será listado na aba Parameters/Variables

Repita o passo acima para criar mais 2 parametros:

P_DT_INI NVARCHAR 8

P_DT_FIM NVARCHAR 8

Verifique se os três parâmetros foram criados na aba Parameters/Values

Agora vamos criar os parâmetros de saída da calculation view. A calculation view sempre
retorna um parâmetro que é do tipo tabela, com uma ou várias colunas.

Clique na caixa Script View

Do lado direito será exibida uma janela Output. Dentro desta janela existe uma pasta
“Columns” e é nessa pasta que vamos criar as colunas da tabela de saída da calculation view

Para criar as colunas clique com o botão direito em Columns e selecione Create columns.
Neste exemplo, na nossa calculation view nós vamos ler a view
"_SYS_BIC"."sap.glo.tmflocbr.ctr/EMPRESA_FEDERAL" e retornar uma tabela com 2 colunas
Código do município e Endereço (Colunas COD_MUN_ESTABELEC e ENDERECO)

Na tela abaixo preencha os campos conforme o print e clique em ok

As colunas da tabela serão criadas dentro da pasta Columns na janela Output. Repare que é
possível ver também os parâmetros de entrada da calculation view

Agora vamos fazer a parte da seleção de dados da calculation view. Essa parte deve ser feita
entre os comando BEGIN e END da caixa Script View.
Você pode fazer diversas seleções, cálculos e processamentos dentro da calculation view.
Porém para preencher a tabela de saída da view (que tem as 2 colunas que criamos), é
necessário preencher a variável VAR_OUT.

VAR_OUT é a variável pré-definida da calculation view que usamos para preencher a saída,
então a seleção de dados que colocamos nessa variável deve conter exatamente os mesmos
campos que foram definidos na pasta Columns da janela Output.

Selecione os campos COD_MUN_ESTABELEC e ENDERECO da view standard

"_SYS_BIC"."sap.glo.tmflocbr.ctr/EMPRESA_FEDERAL" para preencher a variável VAR_OUT

Note que a view standard EMPRESA_FEDERAL tem 2 placeholders, P_DT_INI e P_DT_FIN. Nós
estamos passando os nossos parâmetros de entrada P_DT_INI e P_DT_FIN para a view
standard através do placeholder. Porém na view não existe placeholder para o campo mandt,
então estamos fazendo o filtro pelo mandt na condição WHERE.

Observe também que estamos selecionando os campos COD_MUN_ESTABELEC e ENDERECO,

que tem o mesmo nome e estão na mesma ordem que os campos definidos em Columns na
janela Output. E o resultado é preenchido na variável VAR_OUT que garante que o resultado
dessa seleção será a saída da calculation view.

Clique no botão Activate para ativar a view criada

Você pode verificar na aba Job log se a ativação ocorreu com sucesso ou se houve algum erro

Pronto. Neste momento a calculation view está criada e foi ativada. Agora podemos testar
antes de utilizar.

Clique com o botão direito na sua calculation view e selecione Generate Select SQL
Uma nova janela do console sql do hana será aberta com um comando SELECT gerado para a
sua calculation view

Veja que o select contém somente os campos que foram definidos na pasta Columns da janela
Output e que os placeholders foram definidos a partir dos parâmetros de entrada da sua view.

Altere os placeholders substituindo <Enter Value> por valores válidos para executar a consulta

Nesse caso preenchi o mandante e as datas início e fim no formato AAAAMMDD.

Clique em executar para ver o resultado.

Dentro da aba de console será criada uma nova aba chamada “Result” onde o resultado da
seleção da view será exibido

Pronto. A Calculation view está criada e já pode ser utilizada em outros objetos do hana ou ser
utilizada pelo abap.
 HANA – Criar view gráfica (exemplo com Join)

Para criar uma view gráfica com o join de 2 tabelas, seguir os passos abaixo:

Entrar no eclipse

Selecione a perspectiva do Hana

Selecione a aba Systems

Clique com o botão direito no ambiente onde deseja conectar e clique em Log on

Informe a senha e clique em OK

Clique na aba repositories e selecione a pasta onde quer criar a view. Caso não tenha uma
pasta sua ainda, crie uma dentro da pasta da turma

Com o botão direito na pasta, selecione New e Calculation view

Preencha o nome da calculation view, selecione o tipo Graphical e deixe o Data Category em
branco e clique em Finish
A Calculation view será criada

Clique na caixa Semantics

Clique em view Properties e troque Default Client para Cross client e limpe o campo Apply
privileges

Agora vamos adicionar nossa primeira view para fazer o join. Clique no botão projection e
depois clique abaixo das caixinhas para colar a nova projection
Clique no botão verde com o sinal de + para adicionarmos a view correspondente à primeira
tabela do join

Digite o nome da sua view correspondente à primeira tabela do join, aguarde até que a view
apareça na lista de opções, selecione a view da sua pasta e clique em ok

A view será adicionada na projection

Agora vamos adicionar uma nova projection para colocar a view da segunda tabela

Clique no botão projection e depois clique abaixo das caixinhas para colar a nova projection

Clique no botão verde da projection que acabou de adicionar para colocarmos a view da
segunda tabela

Digite o nome da sua view correspondente à segunda tabela do join, aguarde até que a view
apareça na lista de opções, selecione a view da sua pasta e clique em ok
A view será adicionada na projection

Agora que já adicionamos as tabelas envolvidas, vamos selecionar quais campos de cada view
farão parte do nosso join.

Clique na primeira projection (da primeira tabela)

Na janela de details, marque os campos que deseja que façam parte do join (tanto os campos
que você quer na saída da sua calculation view quanto os campos que forem necessários para
fazer o join). Os campos ficaram com uma bola laranja indicando que estão selecionados

Agora clique na segunda projection (da sua segunda tabela) e marque os campos lá também
Agora vamos adicionar a caixinha do join. Clique no ícone do join e clique na área de Scenario
para adicionar a nova caixa

Agora vamos ligar as 2 projections no join. Arraste a bolinha acima da “Projection_1” até
encontrar a bolinha abaixo de Join_1

Após arrastar ficará assim, indicando que o Join_1 já enxerga a Projection_1

Vamos fazer a mesma coisa para a segunda projection. Arraste a Projection_2 até a bolinha
inferior de Join_1. Deverá ficar assim indicando que o Join_1 já enxerga a Projection_2

Agora vamos fazer a ligação do join (correspondente ao “ON” do select). Clique na caixa do
Join_1

A ligação entre estas tabelas é feita através dos campos MANDT e MATNR. Arraste o campo
mandante de uma tabela até a outra e depois o campo MATNR.

A ligação do join está feita. Agora vamos selecionar quais campos irão para a saída da nossa
calculation view.

Marque as bolinhas para marcar os campos que você quer que sejam campos de saída na sua
calculation view. Eles vão ficar na cor laranja
Agora só falta ligar o join na Projection de saída. Arraste a bolinha de cima do join até alcançar
a bolinha de baixo da Projection

Após arrastar deverá ficar assim

Por fim selecione a caixa Projection que contém o Join_1

Clique com o botão direito em Join_1 na Janela “Details” e selecione “Add All to Output”

Pronto. Agora as colunas fazem parte da saída da sua calculation view

Agora é só ativar a view e ela está pronta para ser utilizada

Você vai ver na aba Job Log se a ativação ocorreu com sucesso
 HANA – Criar parâmetros de entrada na view gráfica

Para este passo é necessário ter executado o documento “HANA 2 - Criar view grafica com
join”

Entrar no eclipse

Selecione a perspectiva do Hana

Selecione a aba Systems

Clique com o botão direito no ambiente onde deseja conectar e clique em Log on

Informe a senha e clique em OK

Na aba repositories localize a view onde deseja criar o parâmetro de entrada. Clique 2x na
view para abrir

Clique na primeira caixa da view

Em Input Parameters clique com o botão direito e selecione New

Na janela que abrir, informe o nome do parâmetro o data type e o tamanho, e clique em OK

O parâmetro será criado

Agora clique na caixa onde deseja utilizar este parâmetro como filtro. Neste exemplo vamos
filtrar a MAKT. Então clique na caixa Projection_2
Com a caixa selecionada, vá no quadro Output e clique 2x em Expression

Será aberta a janela de construção de expressões

Nesta janela utilize os elementos no quadro Elements para construir a expressão que irá filtrar
o campo SPRAS da view de acordo com o parâmetro de entrada IV_SPRAS

A expressão deve ser "SPRAS"='$$IV_SPRAS$$'. Clique em OK

A expressão será criada e um ícone indicando que a caixa agora tem uma
expressão será exibido do lado direito

Ative novamente a view

Pronto agora você já pode utilizar a calculation view com um parâmetro de entrada que será
utilizado como filtro na seleção dos dados
 HANA – Criar procedure

Entrar no eclipse na perspectiva Hana

Selecionar a pasta onde deseja criar a procedure e com o botão direito na pasta selecionar,
New e Other

No campo de texto, digite “stored”, selecione Stored Procedure e clique em Next

Informe o nome da procedure, o schema e clique em Finish

O template da procedure será criado

Adicione os parâmetros de entrada e saída conforme necessário

Adicione a lógica de processamento para buscar os dados e preencher a saída

Pronto, só falta ativar a procedure.

 HANA – Debugar procedure

Entre no eclipse, vá até a perspectiva Hana, selecione a aba Systems e faça o logon no
ambiente onde deseja debugar a procedure

Vá para a aba Repositories, localize a procedure que deseja debugar e clique 2x para abrir

Alterne para a perspectiva de debug

Nessa perspectiva clique 2x no lado esquerdo das linhas onde deseja colocar pontos de parada
Clique na seta ao lado do botão de debug, selecione Debug As e depois Sap hana stored
procedure

Altere a descrição para um nome mais amigável para poder recuperar esta configuração de
debug posteriormente

Clique na aba Input parameters, preencha os parâmetros de entrada da procedure, depois

clique em Apply e Debug
Na aba debug o sistema ficará em Running até chegar no seu ponto de parada

Quando alcançar o ponto de parada o status sairá de Running e indicará onde ele está parado.
Além disso a cor da linha irá mudar indicando que o debug está parado nela

Você pode clicar no botão Resume (F8) para o debug avançar até o próximo ponto de parada
Você pode visualizar as variáveis do lado direito da tela e para visualizar seleções já efetuadas
nas procedures basta clicar com o nome direito em uma delas e escolher Open data preview

Para encerrar o debug basta executar até o fim ou clicar no botão Terminate

Quando o debug acabar o status ficará assim

ABAP
 ABAP - Open SQL

A primeira forma que temos para um programa abap acessar os objetos do Hana, é através do
Open SQL. O open sql é o formato que sempre usamos para acessar o banco de dados nas
versões do SAP ECC e anteriores. Esta forma continua funcionando e pode ser utilizada, porém
ao mantermos o open sql não conseguiremos utilizar alguns recursos poderosos oferecidos
pelo Hana.

Para utilizar o Open SQL para acessar o Hana você só precisa codificar o seu sql da forma que
sempre fez nas versões anteriores.

Ex:

Para o Open SQL funcionar a tabela precisa ser visível no Dicionário de dados (transação SE11)
 ABAP - ADBC – Abap Database Connectivity

ADBC é uma API que permite que você codifique comandos nativos do Hana no abap para que
sejam executados no banco de dados.

Para isto você precisará de 3 classes e 2 variáveis auxiliares

O primeiro passo é buscar a conexão com o banco de dados

Em seguida devemos instanciar a classe que fará o comando sql

Depois vamos montar usar nossa primeira variável auxiliar para montar manualmente o
comando SQL. Atentar para o fato que não estamos usando o Open SQL mas sim o SQL nativo
do Hana

Chamar a classe que executa o SQL passando o comando sql que foi montado acima
Agora vamos utilizar nossa segunda variável auxiliar para fazer a ligação entre a tabela interna
que irá receber o resultado do select e o parâmetro de retorno da classe que executou o sql

Agora vamos chamar o método que executa realmente o sql e traz o retorno para a tabela
interna do programa abap

Por último só precisamos encerrar as conexões

Segue abaixo um código completo de exemplo de como fazer uma chamada ADBC utilizando
sql nativo do Hana
*&---------------------------------------------------------------------*
*& Report ZWW_EXEMPLO_02_ADBC
*&---------------------------------------------------------------------*
*&
*&---------------------------------------------------------------------*
REPORT zww_exemplo_02_adbc_basico MESSAGE-ID 00.

TYPES: BEGIN OF ty_t001,

bukrs TYPE t001-bukrs,
butxt TYPE t001-butxt,
END OF ty_t001.

DATA lt_t001 TYPE TABLE OF ty_t001.

DATA: lo_sql_connection TYPE REF TO cl_sql_connection,

lo_sql_statement TYPE REF TO cl_sql_statement,
lo_sql_result_set TYPE REF TO cl_sql_result_set,
lo_data TYPE REF TO data,
 lv_sql TYPE string.

PARAMETERS p_land1 TYPE t001-land1.

START-OF-SELECTION.

TRY.
"Buscar a conexão com o banco de dados
"Se não passar o nome da conexão ele busca a conexão default do banco
lo_sql_connection = CAST #( cl_sql_connection=>get_connection( ) ).

CATCH cx_sql_exception INTO DATA(lo_sql_exception).

MESSAGE e398 WITH lo_sql_exception->get_text( ).
ENDTRY.

"Instanciar a classe do sql usando a conexao estabelecida

lo_sql_statement = NEW cl_sql_statement(
con_ref = lo_sql_connection
).

"Montar string SQL nativo que será executado no HANA

lv_sql = |SELECT BUKRS, BUTXT FROM T001 WHERE LAND1 = '| && p_land1 && |'|.

TRY.
"Executar o comando SQL no Hana
lo_sql_result_set = lo_sql_statement->execute_query(
EXPORTING
statement = lv_sql
).

CATCH cx_sql_exception INTO lo_sql_exception.

MESSAGE e398 WITH lo_sql_exception->get_text( ).
ENDTRY.

"Atribuir a referência da tabela interna que irá receber os dados

"ao objeto lo_data
GET REFERENCE OF lt_t001 INTO lo_data.

"Colocar o objeto lo_data como parâmetro para receber o resultado do sql

lo_sql_result_set->set_param_table(
EXPORTING
itab_ref = lo_data
).

TRY.
"Atualizar a tabela interna com o retorno do sql
lo_sql_result_set->next_package( ).

CATCH cx_sql_exception INTO lo_sql_exception.

MESSAGE e398 WITH lo_sql_exception->get_text( ).
ENDTRY.

lo_sql_result_set->close( ).

TRY.
lo_sql_connection->close( ).

CATCH cx_sql_exception INTO lo_sql_exception.

MESSAGE e398 WITH lo_sql_exception->get_text( ).
ENDTRY.

cl_demo_output=>display( lt_t001 ).
 ABAP - AMDP – Abap Managed Database Procedure – Leitura de tabelas
do Dicionário de Dados

AMDP é uma procedure do Hana. Porém ela é criada dentro de uma classe abap e ao ser
ativada, internamente é convertida em uma procedure.

Para utilizarmos o AMDP para acessar o hana é necessário criar uma classe, pois o acesso
AMDP ao hana é feito através de um método com características específicas.

Quando vamos criar a classe para utilizar o método AMDP precisamos fazer a edição através
do eclipse pois o SAPGUI não tem suporte completo a este tipo de método.

Você pode iniciar a criação da sua classe pela se24 se achar melhor porém em seguida é
necessário abrir o eclipse para continuar o desenvolvimento.

É necessário utilizar a interface IF_AMDP_MARKER_HDB para a classe funcionar.

Após a criação da classe (no abap ou no eclipse), vamos criar um método para fazer o acesso
ao hana.

Todos os parâmetros de entrada e saída do método devem ser “por valor” ou seja, devem ter
o comando VALUE em cada parâmetro.
Na seção IMPLEMENTATION vamos codificar a seleção dos dados utilizando sql nativo do
Hana. Como trata-se de uma tabela do dicionário de dados, é necessário informar o nome da
tabela no próprio método.

Segue abaixo o código completo da classe como exemplo de AMDP lendo tabela do dicionário
de dados
CLASS zwwcl_exemplo_03_amdp DEFINITION
PUBLIC
FINAL
CREATE PUBLIC .

PUBLIC SECTION.

INTERFACES if_amdp_marker_hdb.

TYPES: BEGIN OF ty_t001,

bukrs TYPE t001-bukrs,
butxt TYPE t001-butxt,
END OF ty_t001 .

TYPES ty_tab_t001 TYPE TABLE OF ty_t001 .

METHODS selecionar_t001
IMPORTING
VALUE(iv_land1) TYPE t001-land1
EXPORTING
VALUE(et_empresas) TYPE ty_tab_t001 .

PROTECTED SECTION.

PRIVATE SECTION.

ENDCLASS.

CLASS zwwcl_exemplo_03_amdp IMPLEMENTATION.

METHOD selecionar_t001 BY DATABASE PROCEDURE FOR HDB LANGUAGE SQLSCRIPT USING t001.

--teste
et_empresas =
select bukrs, butxt
from t001
where land1 = :iv_land1
;

ENDMETHOD.

ENDCLASS.
Agora precisamos criar um report que irá chamar esta classe para exibir os dados selecionados.

No report basta instanciar a classe normalmente e chamar o método amdp

Segue abaixo código de exemplo

REPORT zww_exemplo_03_amdp.

PARAMETERS p_land1 TYPE t001-land1.

START-OF-SELECTION.

DATA(lo_amdp) = NEW zwwcl_exemplo_03_amdp( ).

lo_amdp->selecionar_t001(
EXPORTING
iv_land1 = p_land1
IMPORTING
et_empresas = DATA(lt_empresa)
).

cl_demo_output=>display( lt_empresa ).
 AMDP – Abap Managed Database Procedure – Leitura de objetos do Hana
– Calculation View

Para selecionar um objeto do hana, assim como fizemos para selecionar objetos do dicionário
de dados, precisamos de uma classe.

Esta classe deve ter um método com todos os parâmetros “por valor”

Em seguida devemos fazer a implementação do método mas neste caso não é necessário citar
o objeto no nome do método, basta fazer a seleção diretamente.
Segue abaixo código de exemplo
CLASS zwwcl_exemplo_04_amdp_calc_vie DEFINITION
PUBLIC
FINAL
CREATE PUBLIC .

PUBLIC SECTION.

INTERFACES if_amdp_marker_hdb.

TYPES: BEGIN OF ty_mara,

matnr TYPE mara-matnr,
ernam TYPE mara-ernam,
matkl TYPE mara-matkl,
lvorm TYPE mara-lvorm,
END OF ty_mara .

TYPES ty_tab_mara TYPE TABLE OF ty_mara .

METHODS selecionar_mara
IMPORTING
VALUE(iv_mtart) TYPE mara-mtart
EXPORTING
VALUE(et_materiais) TYPE ty_tab_mara .

PROTECTED SECTION.

PRIVATE SECTION.

ENDCLASS.

CLASS zwwcl_exemplo_04_amdp_calc_vie IMPLEMENTATION.

METHOD selecionar_mara BY DATABASE PROCEDURE FOR HDB LANGUAGE SQLSCRIPT.

et_materiais =
select
matnr,
ernam,
matkl,
lvorm
from
"_SYS_BIC"."13209.view/CV_MARA"
where
mtart = :iv_mtart
;

ENDMETHOD.

ENDCLASS.

Em seguida basta fazer o programa que irá chamar esta classe e executar o método
 AMDP – Abap Managed Database Procedure – Leitura de objetos do Hana
– PROCEDURE

Para chamar uma procedure no hana através do amdp, também precisamos de uma classe.

Dentro do método fazemos a chamada normal da procedure como se estivéssemos no hana

E por último criamos um programa para chamar este método AMDP

Segue exemplo
CLASS zwwcl_exemplo_06_amdp_proc DEFINITION
PUBLIC
FINAL
CREATE PUBLIC .

PUBLIC SECTION.

INTERFACES if_amdp_marker_hdb.

TYPES: BEGIN OF ty_materiais,

matnr TYPE c LENGTH 40,
matkl TYPE c LENGTH 9,
spras TYPE char1,
maktx TYPE c LENGTH 40,
mtart TYPE c LENGTH 4,
END OF ty_materiais .

TYPES ty_tab_materiais TYPE TABLE OF ty_materiais .

METHODS chamar_procedure_hana
IMPORTING
VALUE(iv_grupo_mercadoria) TYPE mara-matkl
VALUE(iv_idioma) TYPE makt-spras
VALUE(iv_tipo_material) TYPE string
EXPORTING
VALUE(et_lista_materiais) TYPE ty_tab_materiais .

PROTECTED SECTION.

PRIVATE SECTION.

ENDCLASS.

CLASS zwwcl_exemplo_06_amdp_proc IMPLEMENTATION.

METHOD chamar_procedure_hana BY DATABASE PROCEDURE FOR HDB LANGUAGE SQLSCRIPT.

CALL "_SYS_BIC"."13209.procedure::PR_MARA_MAKT" (
IV_MATKL => :iv_grupo_mercadoria,
IV_SPRAS => :iv_idioma,
IV_MTART => :iv_tipo_material,
ET_MATERIAIS => :et_lista_materiais
);

ENDMETHOD.

ENDCLASS.
CDS
 CDS

CDS significa Core Data Servies. É uma nova técnica de desenvolvimento criada pela SAP para
sistemas S/4Hana. CDS é uma ampliação do SQL. É criado e desenvolvido no abap e executado
no hana.

Tipos de CDS

BASIC (INTERFACE)

As views CDS básicas são desenvolvidas para expor os dados mestre, como mestre do cliente,
mestre de materiais, parceiro de negócios, etc. Eles consomem as tabelas físicas do SAP para
ler os dados. Eles também são chamados de views INTERFACE e para padrões de nomenclatura
SAP usa 'I' entre o nome da visualização: * _I_ *

É a view que interage diretamente com o banco de dados. Views básicas acessam tabelas e
outras views básicas.

COMPOSITE

Essas views são configuradas como uma associação de conjuntos de dados principais OU dados
principais e dados transacionais. Elas podem consumir views básicas ou outras views
compostas para ler dados. Para padrões de nomenclatura, SAP usa ‘CO’ entre o nome da view:
* _CO_ *

Não interagem com o banco de dados diretamente. Elas interagem com views básicas ou
outras views composite.

CONSUMPTION

Essas views são criadas como a última camada do modelo analítico CDS. Estas são as views
prontas para serem consumidas pelas ferramentas de UI, SAPUI5, Analytical queries, Bex,
Lumira, Webi, Analysis for Office etc.

Podem ser acessadas por usuários de negócios a partir de um relatório. Essas views podem
consumir todas as outras views básicas ou compostas para ler dados e criar um conjunto de
dados final que será exibido nas telas ou em qualquer outra saída.

Para padrões de nomenclatura, SAP inicia o nome da visão com ‘C’: C_ *

PRIVATE

Essas views são privadas da SAP e não devem ser usadas ou criadas por ninguém que não seja
a SAP. A SAP pode alterar sua configuração sem qualquer aviso aos clientes. Para padrões de
nomenclatura, SAP inicia o nome da visão com ‘P’: P_ * ou PRV_*
 CDS – Criar CDS básica

Vamos ver aqui como criar uma view CDS básica

Quando uma view CDS é criada ela cria automaticamente 2 objetos:

1) DDIC view – View que pode ser visualizada na SE11

2) Hana View – Objeto criado no Hana DB

Depois que criarmos nossa cds view vamos visualizar os objetos acima

Para criar uma view básica proceder da seguinte forma.

Entrar no Eclipse e selecionar a perspectiva abap

Escolha um pacote ou clique com o botão direito em Local Objects (para criar uma CDS
somente para testes), depois selecione New e Other ABAP Repository Object

Na janela abaixo, selecione Core Data Services, Data Definition e clique em Next
Preencha o nome da view (Seguindo as regras do abap, começando com Z ou Y e respeitando
os limites de nomes da se11), preencha a descrição e clique em Next

Selecione uma opção de request e clique em Next. Neste exemplo estou usando pacote local
então não é possível informar request.
Selecione “Define view” e clique em Finish.

A view será criada com o nome fornecido.

Os elementos iniciados com “@” são chamados de Annotations e servem para passar
informações de configuração na definição da view.

A primeira Annotation é a @AbapCatalog.sqlViewName: ''

Aqui vamos adicionar o nome da DDIC-SQL view, ou seja, o nome que será exibido na SE11
para esta CDS view. Este nome não pode ser o mesmo da view CDS e deve seguir as regras de
nomes de views da SE11. (Ex. começar com Z, não passar de 16 caracteres...)
 • Preencha este campo com ZSQL_VIEW_BASIC

A segunda Annotation é a @AbapCatalog.compiler.compareFilter: true

Essa anotação define o comportamento do filtro dos dados, ou seja, primeiro compara as
condições do filtro e, se elas corresponderem, aí os dados são buscados. Se a visão CDS tiver
condições de join, elas serão executadas somente depois que as condições do filtro forem
correspondidas.

A terceira Annotation é a @AbapCatalog.preserveKey: true

Outra anotação importante das views CDS. Toda tabela de banco de dados no SAP têm chaves
definidas e as visualizações CDS são sempre criadas em cima dessas tabelas de banco de
dados. Agora, qualquer tabela de banco de dados pode ter várias chaves definidas e você pode
não querer que essas chaves sejam os campos-chave de sua visualização. Então, se você definir
esta anotação como verdadeira, os únicos campos que você define como campos-chave
dentro de sua visualização CDS adicionando a palavra "KEY" na frente desses campos serão os
campos-chave para a visualização CDS.

A quarta Annotation é a @AccessControl.authorizationCheck: #CHECK

Esta anotação é usada para adicionar segurança à visualização do CDS. Quando a visualização
CDS está pronta para ser implementada, é importante restringir os dados com base na
autorização.

• Por enquanto, troque para #NOT_REQUIRED

A quinta Annotation é a @EndUserText.label: 'View basica'

Esta anotação é usada para aplicar um rótulo à view.

Sua view deve estar assim

Agora vamos adicionar campos à nossa CDS. Para efeitos de teste, criei essa tabela na se11 e
ela será a base da nossa view CDS
Para adicionar campos à view, altere o texto “data_source_name” para o nome da tabela,
coloque o cursor dentro das chaves e pressione CTRL SPACE

Selecione Insert all elements para incluir todos os campos ou clique 2x em cada um para
adicionar

Uma vez que a view é criada no ABAP o campo mandt é tratado pelo sistema, e se não for
necessário tratar mandantes múltiplos ele pode ser comentado (2 traços comentam a linha).
Adicione a palavra Key no campo Empresa para que ele seja a chave da view CDS
Clique no botão de ativar para ativar a view CDS

Na janela Outline você pode visualizar a estrutura da view

Conforme mencionado anteriormente, quando você ativa uma view CDS, 2 objetos são
criados, 1 no Hana e 1 no abap.

O nome destacado na imagem é o nome que será criado na SE11 (DDIC).

Entre na se11 e visualize o objeto criado

Note que na view DDIC é possível visualizar a fonte DDL que é a nossa CDS

Na perspectiva do Hana é possível visualizar o objeto criado lá também.

Alterne para a perspectiva hana

Selecione a aba Systems

Conecte-se ao Hana no ambiente correspondente ao abap onde a view CDS foi criada. Depois
localize na pasta Catalog o Schema que está utilizando (é possível ver o schema no sapgui em
Sistema / Status) e dentro dele clique com o botão direito em Views e depois Filters

Digite o nome da view e clique em OK

A view será exibida

Você pode clicar 2x para abrir a view e verificar o comando CREATE que foi montado para criar
esta view

Com isso nossa primeira CDS view está criada e já pode ser utilizada tanto no abap quanto no
Hana.

Na minha tabela de testes ZWANDERCDS eu inseri alguns dados de teste

Na se16 é possível visualizar o objeto DDIC criado junto à view CDS e consultar os dados como
se fosse uma tabela transparente

Resultado da se16
Também no Hana é possível visualizar os dados, basta clicar com o botão direito e selecionar
Open Data Preview

Resultado no hana

Nossa primeira cds view básica está criada e pronta para ser utilizada.
 CDS – Expressões e variáveis de sessão

Vamos agora criar uma CDS view com uma expressão (cálculo).

Para isso alterei a tabela de testes incluindo 2 campos de valor

Crie uma nova CDS view utilizando o passo a passo do manual 01 com nome ZCDS_VIEW_EXP

Será criado o template da view básica

Nosso primeiro passo é preencher o campo sqlViewName com o nome que será exibido na
se11. Preencha com ZSQL_VIEW_EXP

Agora vamos modifica-la para ler nossa tabela. Altere o data_source_name para a tabela que
deseja ler (neste exemplo ZWANDERCDS)
Agora vamos inserir os campos. Coloque o cursor na linha em branco entre as chaves e
pressione ctrl + espaço e depois selecione “insert all elements”

O resultado será parecido com esse aqui

Vamos comentar o campo mandt, pois não trabalharemos com múltiplos mandantes aqui. E
acrescentar a palavra key no campo empresa pois ele será a chave do CDS.
Para adicionar um cálculo basta colocar o nome das colunas envolvidas e um alias que será o
nome da nova coluna com o resultado do cálculo.

Ative a view CDS.

Para visualizar os dados com o cálculo, clique com o botão direito no nome da CDS, e selecione
Open With e depois Data Preview

Uma nova aba será aberta com o resultado

Agora vamos adicionar uma condição WHERE no nosso select para utilizar uma variável de
sessão

Para isso incluí mais um campo na nossa tabela de testes

De forma parecida com o abap o CDS também possui variáveis de sessão similares ao sy-
datum, sy-uzeit...

Para acionar as variáveis de sistema precisamos do comando $Session. Quando esta variável é
inserida no cds você consegue visualizar as opções de variáveis do sistema.

Selecione system_date para comparar a data_inicio com a data do sistema

Pronto. Agora é só ativar e pré-visualizar os dados. Somente as empresas com data menor que
a data do sistema serão selecionadas
 CDS – Consumir CDS no abap (ALV IDA)

Consumir uma view CDS no Abap é muito simples.

Vamos utilizar como modelo a que criamos no manual 02.

Crie um report abap (no sapgui ou no eclipse)

Agora basta fazer um select na view cds normalmente como se fosse uma tabela da se11.
O resultado será exibido na tela

Existe uma classe no abap para fazer ALV, que é o ALV IDA. Ele é executado através da classe
CL_SALV_GUI_TABLE_IDA

Vamos ajustar o programa para exibir dados utilizando o alv ida e a nossa view CDS.

Comente o código acima e adicione a nova instrução para gerar o ALV

Execute o report e veja o resultado

 CDS – Extender uma view CDS

A SAP fornece diversas views CDS standard relacionadas a cada módulo funcional e durante a
implementação de um projeto, você poderá querer criar views CDS customizadas a partir de
views standard.

Uma vez que as views CDS são apenas modelos de dados virtuais, você pode reutilizar a view
criada em um projeto outro projeto.

Vamos supor que você criou uma view CDS com 5 campos da TABELA A e para outro cenário
em um projeto diferente, você precisa de 8 campos da mesma TABELA A. Portanto, em vez de
criar uma nova view CDS do zero, podemos usar o conceito de CDS View Extension e reutilizar
a visão anterior que criamos e estendê-la com 3 novos campos.

Vamos criar uma CDS view extension para a nossa view CDS ZCDS_VIEW_EXP.

Essa é a nossa view original que seleciona campos da tabela ZWANDERCDS

Vou agora adicionar 1 campo na tabela ZWANDERCDS para em seguida criar a Extension View.

Campo Moeda adicionado na tabela

Agora, em vez de modificar a CDS view ZCDS_VIEW_EXP para selecionar mais este campo, nós
vamos criar uma Extension View a partir dessa view que já temos, e na extensão vamos
adicionar o campo MOEDA.

Para criar a Extension View entre no eclipse, na perspectiva abap, clique com o botão direito
no pacote que deseja e selecione New Data Definition

Preencha o nome da Extension view como ZCDS_EXTEND_VIEW, preencha a descrição e clique

em Next

Selecione uma request e clique em Next, no meu caso, como o pacote é local não é necessário
selecionar request.
Na tela abaixo, selecione Extend View e clique em Finish

A nova view será criada

Agora vamos preencher os atributos da view. Primeiro vamos preencher o nome SQL da view.

Preencha com ZSQL_EXTEND_VIEW

Agora vamos citar a view original que será extendida. Troque o campo view_name por
ZCDS_VIEW_EXP

Retire esta linha que veio como modelo

Agora no lugar desta linha, coloque o cursor, pressione ctrl space e selecione o campo MOEDA

View com o novo campo

Ative a view.
Pressione F8 para executar essa view CDS e ver o resultado

Veja que o resultado trouxe os campos da view cds original e o campo da view de extensão

Você pode consumir esta view no abap da mesma forma que vimos a view cds original.

Em resumo, vimos o conceito de reutilização, que é muito importante para reduzir o esforço
de desenvolvimento e também para seguir as Melhores Práticas SAP. Em vez de criar do zero,
é muito importante saber sobre as views CDS standard fornecidas pela SAP para reutilizá-las
em seu projeto para atender a requisitos específicos de negócios.

No caso do produto também é necessário planejar a construção de cada cds para poder
reaproveitar os objetos da melhor forma.
 CDS – Parâmetros de entrada da view CDS

Até agora nós criamos e utilizamos views CDS de forma bem simples. É possível selecionar
estas views no abap e fazer um filtro utilizando a condição where no próprio programa abap,
como se fosse uma tabela normal. Porém pode ser que alguma view CDS tenha que ter
obrigatoriamente um filtro. Um filtro de data por exemplo. Podemos ter uma view CDS onde
se eu fizer um select sem passar um período de data, a seleção ficaria grande demais e
inviabilizaria a execução.

Neste caso, podemos garantir que a view cds seja filtrada pelo período criando um parâmetro
de entrada para ela.

Vamos criar uma nova view cds para a mesma tabela ZWANDERCDS, porém vamos colocar um
parâmetro de entrada do tipo data.

Entre no eclipse, na perspectiva abap, selecione o pacote desejado e clique em new Data
Definition.

Na tela abaixo preencha o nome da view com ZCDS_VIEW_PARAM, preencha a descrição e

clique em Next
Selecione a request e clique em Next

Na tela abaixo selecione Define View with Parameters e clique em Finish

A nova view será criada com a cláusula “with parameters”

Altere o nome da view sql para ZSQL_VIEW_PARAM e troque data_source_name para o nome
da tabela de testes

Coloque o cursor entre as chaves, pressione ctrl espaço e insira os campos que deseja. No meu
caso retirei o mandante e coloquei a empresa como chave.

Até aqui é basicamente o que já fizemos na outra view cds básica.

Agora vamos adicionar o parâmetro de data

A estrutura do parâmetro é nome do parâmetro : tipo do parâmetro

Altere o parameter_name para in_data e o parameter_type para SYDATS

Desta forma estamos dizendo que nossa view tem um parâmetro de entrada chamado
“in_data” e é do tipo data (sydats é um elemento de dados standard que usei como exemplo)
Obs: Se quiser usar declaração de tipos de dados primitivos basta colocar o comando “abap”
da seguinte forma:

Exemplo: abap.char(3), abap.numc(8)....

No meu caso, vou manter o elemento de dados

Agora vamos utilizar o parâmetro de entrada na condição WHERE para filtrar os dados da
tabela.

Para isso basta colocar o comando $parameters seguido do nome do parâmetro

O resultado deve ficar assim

Obs: Uma outra forma reduzida de utilizar os parâmetros de entrada é com dois pontos

Ative a view CDS

Pressione F8 para visualizar os dados da view

Repare que será exibida uma tela para você informar os parâmetros de entrada da view CDS.
Preencha com uma data válida no formato AAAAMMDD (Lembre-se que aqui é o parâmetro de
entrada da view. O usuário não irá digitar a data nesse formato). Clique em OK

O resultado será exibido na tela

Por último vamos ver como selecionar esta view cds de um programa abap e como passar o
parâmetro de entrada.

Crie um report na se38, no sapgui ou eclipse.

Crie um parameter do tipo data na tela do seu report.

Agora vamos fazer o select na view CDS passando o parâmetro de data

Ative e execute o report

O resultado será exibido

 CDS – Encontrar CDS standard

A SAP fornece diversas views CDS standard e estas views podem ser aprimoradas ou
consumidas para atender a necessidades específicas.

A questão é 'Como encontrar estas views standard?' ou 'Como eu saberia que uma view CDS
standard foi fornecida pela SAP com todos os campos que necessito?’ ou ainda ‘Se eu reunir
algumas views standard terei todos os campos para criar um programa sem a necessidade de
criar outra view?’

Existem 2 boas maneiras de procurar o conteúdo standard SAP

1) Sap Help Portal

Através do link abaixo

https://help.sap.com/viewer/product/SAP_S4HANA_ON-PREMISE/2021/en-
US?task=discover_task

Na tela abaixo, clique em Product Assistance (English)

Na janela abaixo, siga o seguinte caminho Cross Components, Virtual Data Modeler
and CDS Views in SAP S/4Hana, CDS Views
Dentro de CDS Views, você encontra todas as views standard organizadas em módulos

Selecione uma qualquer como exemplo

 Copie o nome técnico da view CDS e abra o objeto no eclipse, na perspectiva abap. Use
a tecla de atalho CTRL SHIFT A, para digitar o nome da view CDS

Você pode analisar e verificar o objeto standard

2) Através do Fiori Launchpad

Você deve executar o app “Query Browser” no Fiori Launchpad. Caso não tenha esse
app, você precisa solicitar a role “SAP_BR_EMPLOYEE”. Neste app você conseguirá
pesquisar também por views CDS standard
 CDS – Join e Association

JOINS – Nós podemos usar diferentes tipos de Joins dentro da view CDS:
• Inner Join
• Left Outer join
• Right outer join

Vamos criar uma nova view CDS com um template de Join.

Primeiro criei uma nova tabela (ZWANDERCDS_MOEDA) para fazermos o join com a tabela
anterior (ZWANDERCDS).

Entre no eclipse, escolha o ambiente onde será criado, na perspectiva abap selecione New,
Data Definition.
Preencha o nome da view (ZCDS_VIEW_JOIN), a descrição e clique em Next

Selecione a request e clique em Next, no meu exemplo, como é local não preciso selecionar
request
Selecione o modelo “Define view with join” e clique em Finish

O template será criado

Agora vamos proceder com as alterações no modelo. Criado, primeiro coloque o nome da view
que será criada na se11 (ZSQL_VIEW_JOIN)
Agora vamos trocar a condição do join para inner join e substituir os nomes das tabelas pelas
tabelas de teste.

Em seguida vamos ajustar o ON que é a condição de ligação do join. Neste exemplo estamos
relacionando as 2 tabelas pelo campo moeda

Por fim vamos adicionar os campos que serão selecionados. Coloque o cursor entre as chaves
e pressione ctrl espaço para ver a lista de campos.
Clique para inserir todos os elementos e depois ajuste para ficar somente os campos que farão
parte da saída da view

Neste ponto eu retirei os campos de MANDT, deixei o campo moeda de somente uma das
tabelas, e marquei o campo empresa como KEY.

Note que o último campo vem da segunda tabela.

Ative a view e pressione F8 na view para ver o resultado

Veja que a view trouxe os campos da primeira tabela, mais a descrição da moeda que pertence
à segunda tabela.

Para utilizar esta view em um programa abap, basta utilizar normalmente como vimos em
exemplos anteriores.
Até aqui vimos como uma view CDS busca dados de 2 ou mais tabelas com a ajuda de um Join.
Agora vamos pensar um pouco sobre a criação de JOINs em uma view CDS.

A view CDS é consumida pelos programas ABAP ou aplicativos Fiori.

Imagine que você criou uma view CDS com JOIN de 5 tabelas diferentes, então esse JOIN será
executado toda vez que essa view CDS for chamada.

Agora pense em uma situação onde você tem um programa que quer chamar esta view CDS.
Porém, na primeira tela quer exibir somente os dados de 2 tabelas, e só depois (a partir de um
clique do usuário, por exemplo) irá exibir uma nova tela com o restante dos dados das outras 3
tabelas.

Quando a view CDS for selecionada ela irá executar imediatamente as condições de ligação de
todas as 5 tabelas de uma vez, mesmo você querendo somente 2 tabelas inicialmente.

Este é o conceito de SQL com Joins, que pode resultar em atraso no desempenho para buscar
as informações, pois o usuário pode estar querendo ver apenas a primeira tela (que tem dados
de 2 tabelas) mas a view cds executou e selecionou dados das 5 tabelas de uma vez só.

Para resolver esse problema, a SAP fez uma melhoria na forma de como o SQL obtém dados e
desenvolveu o conceito de ‘ASSOCIATION’. Com associations, os dados serão buscados apenas
quando o usuário quiser vê-los. Por exemplo, no exemplo acima, utilizando association,
poderíamos fazer a view trazer os dados somente das 2 primeiras tabelas, e quando o usuário
clicasse em algum link, aí traríamos o restante dos dados das outras 3 tabelas, ou seja,
somente 2 tabelas seriam lidas inicialmente e 3 tabelas seriam lidas somente sob demanda do
usuário.

ASSOCIATIONS:

ASSOCIATIONS são uma espécie de join para buscar dados de várias tabelas, mas funcionam
como um ‘JOIN SOB DEMANDA’, ou seja, as tabelas da associação só serão lidas quando o
usuário acessar dados que estejam nestas associações. Como citado acima, sua view CDS tem
2 tabelas e mais 3 associações configuradas. Então em um primeiro momento o usuário estará
buscando dados para apenas 2 tabelas, a ASSOCIAÇÃO nas outras 3 tabelas não será disparada
e o sistema retornará os resultados das 2 rapidamente, por isso permite um tempo de
processamento melhor que um join “normal”. Somente quando ele quiser ver dados que estão
nas associações é que elas serão efetivamente lidas.

Associations são definidas usando cardinalidade

O conceito de cardinalidade não é novo e nas view CDS funcionam da mesma forma. Existem 4
tipos de cardinalidade possíveis com base nos dados e relacionamentos das tabelas:

• 0..1
• 0..n or 0..*
• 1..1
• 1..n or 1..*
Vamos agora criar uma view CDS usando o conceito de Association

Entre na perspectiva abap do eclipse, selecione o pacote onde deseja criar a view, e com o
botão direito selecione new Data Definition

Preencha o nome da view CDS, a descrição e clique em Next

Selecione a request e clique em Next. No meu exemplo coloquei pacote local e por isso não há
requests
Selecione a opção Define view with Association e clique em Finish

O template da view será criado

Veja que o tipo de associação criada por default é o tipo [1]. Se você não tem certeza de qual
tipo de associação deve criar, deixe este tipo [1] sem alterações.
Note que por default também é criada uma associação chamada _association_name. Você
pode dar um nome qualquer para a sua association mas a SAP recomenda começar, por
padrão, com um “_” (underscore)

Primeiro vamos alterar o nome da view sql que será criada (ZSQL_VIEW_ASSOCI). Veja que
aqui o nome foi reduzido pois o nome da DDIC-VIEW precisa seguir as mesmas regras de
nomenclaturas de tabelas na se11.

Agora vamos colocar o nome da tabela principal, troque data_source_name pelo nome da sua
tabela e adicione um alias a esta tabela também
Agora vamos colocar o nome da tabela associada. Troque target_data_source_name pela
tabela que será associada à sua tabela principal e modifique o _association_name para um
nome mais amigável

No passo seguinte vamos ajustar as condições de ligação do join. Troque $projection pelo alias
criado para a primeira tabela (w) e _association_name pelo nome da associação que
modificamos acima (_moeda). Troque também o campo elemento_name pelo nome dos
campos de ligação do join

Agora vamos adicionar os campos que serão selecionados neste join. Coloque o cursor na linha
entre o “on” e “_moeda”, pressione ctrl espaço e clique para inserir todos os campos
Os campos da primeira tabela serão inseridos

Vamos ajustar a seleção dos campos retirando o mandt, e colocando o campo empresa como
Key.

Obs: O campo MOEDA, que faz parte da ligação do JOIN, TEM que existir na lista de campos
selecionados.

ATIVE a view CDS

Com o botão direito em qualquer local da view CDS, selecione Show SQL CREATE statement
Veja que, apesar de ser um join de 2 tabelas, no primeiro momento nenhum join é realizado.
Somente a primeira tabela será lida

Agora vamos executar a nossa view para ver o resultado. Para fechar essa janela do CREATE
VIEW basta clicar fora dela. Agora com o cursor dentro da view CDS pressione F8 para ver o
resultado.

Note que ainda não há dados selecionados na tabela de moeda. Agora clique com o botão
direito em qualquer linha preenchida, e selecione Follow Association
Será exibida a lista de todas as associações que existirem para esta tabela. No nosso caso só
temos uma associação criada (_moeda)

Clique na linha dessa associação para ver o resultado

Veja que agora os dados da tabela zwandercds_moeda foram recuperados e o resultado da

associação foi exibido

Resumindo, vimos que primeiro foram exibidos os dados da tabela inicial e só após clicar em
uma das linhas é que os dados da associação foram lidos.

Este tipo de association que acabamos de fazer é chamado de EXPOSED.

O outro tipo de associação que vimos, o primeiro, é chamado de AD-HOC, onde você pode cita
explicitamente os campos de uma determinada association e nesse caso o join com a
association é executado imediatamente.

Exemplo:
Você pode sentir a diferença real após projetar uma view CDS muito complexa com uma
combinação de tabelas e outras views CDS. A view CDS ainda terá um bom desempenho pois
os dados serão lidos sob demanda.
 CDS – Classe local no abap para fazer um ALV IDA

A partir da view CDS criada no passo 07, vamos fazer um ALV para exibir os dados desta view.

Para exibir views CDS em um ALV utilizamos a classe standard CL_SALV_GUI_TABLE_IDA.

Crie um report na se38 ou no eclipse.

Para criar no eclipse siga os passos abaixo:

Vá para a perspectiva abap e clique com o botão direito onde deseja criar o report

Na caixa abaixo, digite program, selecione Abap program e clique em Next

Preencha o nome do programa, a descrição, e clique em Next

Selecione a request e clique em Finish

Pronto. O programa está criado no eclipse.

Agora vamos adicionar uma classe local para fazer nosso alv.

Digite lcl e pressione ctrl espaço para a lista de sugestões. Depois clique em lcl local class para
inserir o modelo de classe local
Ajuste o nome da classe local

Agora vamos definir esta classe como singleton e criar um método para poder instanciá-la.
Coloque o cursor no nome da classe na parte da definition e pressione CTRL + 1. Na tela que
aparecer selecione Generate factory method create

Veja que será criado o método create que será o responsável por instanciar nossa classe local.
Agora vamos criar o método que irá exibir o alv.

Na seção pública coloque o comando abaixo (METHODS exibir_alv_ida). Coloque o cursor no

nome do método e pressione CTRL + 1. Na janela que irá aparecer selecione Add
implementation for exibir_alv_ida

A implementação será criada

Neste método que vamos fazer a chamada do alv ida para exibir os dados da view CDS, mas
antes vamos colocar a chamada do método no nosso report.

Depois da implementação da classe, crie a sessão START-OF-SELECION e adicione o comando

que irá instanciar a classe e exibir o ALV
Agora só falta colocar a chamada da classe que exibe o ALV IDA utilizando nossa CDS view.

Apenas relembrando, o nome da nossa cds view fica em “Define view”

Para executar esta view CDS e exibir os dados no ALV IDA, coloque o comando abaixo dentro
do método exibir_alv_ida, onde ZCDS_VIEW_ASSOCIATION é o nome da view CDS que estamos
executando.

Ative e execute o report. O resultado será exibido no ALV IDA

Repare que algumas colunas estão sem cabeçalho ou com uma denominação ruim. No
próximo documento vamos melhorar este ALV.
 CDS – Annotations na view CDS

Quando executamos nosso ALV IDA, vimos que o cabeçalho das colunas ficou em branco ou
com uma denominação ruim para o usuário.

Para corrigir isso, podemos utilizar o recurso de Annotation no CDS.

Annotations são metadados que ajudam a ampliar as definições de uma view CDS.

Normalmente são iniciadas por @ ou por @<

A sintaxe é definida pelo nome da annotation seguido de 2 pontos e depois o valor da

annotation, por exemplo:

@EndUserText.label: 'Teste'
Nós já vimos algumas annotations no início de cada CDS que foi criada. Vamos agora utilizar
mais algumas para melhorar o nosso ALV IDA. Estas mesmas annotations que vamos utilizar
para o ALV, também servem para passar informações ao Fiori, caso a mesma view CDS seja
utilizada por alguma aplicação escrita em Fiori.

Como já vimos no ALV, as colunas precisam de um título mais apropriado para exibição

Vamos fazer isso então utilizando mais annotations dentro da view CDS

Abra a view cds e coloque o cursor na linha anterior ao campo onde você quer inserir a
annotation. Por exemplo, para a coluna de nome da empresa, coloque o cursor na linha acima
da seleção do campo nome:
Digite uma @ e pressione CTRL ESPAÇO para ver a lista de annotations disponíveis

Se quiser filtrar as annotations você pode digitar um pedaço do nome da annotation e depois
dar o CTRL espaço. Neste exemplo digitei @EndUser e depois pressionei CTRL espaço

Clique em EndUserText.label para selecionar esta annotation

Repare que a assinatura completa da annotation será inserida na posição do cursor

Troque o valor das aspas por uma descrição da coluna (No caso a descrição da coluna “nome”
pois a annotation está em cima do campo nome.

Repita os mesmos passos para inserir um título para as colunas Valor Total, Valor Bloqueado,
Data início e Moeda

Seu CDS deverá ficar parecido com este

Ative a view CDS

Agora vamos voltar no programa que exibe o ALV IDA

Pressione F8 para executar e ver o novo ALV IDA

Agora o ALV é exibido considerando as annotations inseridas no CDS

Vamos inserir mais uma annotation como exemplo. Esta annotation permite exibir um texto
personalizado em uma determinada coluna quando o mouse está sobre esta coluna.

Vamos colocar esta annotation na coluna Data Início

Insira a annotation EndUserText.quickinfo acima da coluna data_inicio

Ative a view CDS

Volte no report que exibe o alv e execute-o novamente. Passe o mouse sobre a coluna data
início e veja a mensagem aparecer
Para finalizar nosso exemplo de annotations vamos incluir mais uma coluna no nosso CDS

A coluna será um cálculo entre o valor total e o valor bloqueado, para exibir como Valor
Disponível

Primeiro vamos inserir a nova coluna no CDS

Agora vamos inserir annotations neste campo para passar informações ao ALV IDA (ou ao Fiori
se for o caso)

Ative a view CDS, volte ao report do ALV e execute-o novamente

A nova coluna foi incluída e formatada através das annotations

Você pode ver todas as annotations que estão ativas na view.

Para isso clique com o botão direito em qualquer lugar da view e selecione Open With, e
Active Annotations

Uma aba será aberta com todas as annotations ativas na view

As demais annotations que não estão explícitas na view são originadas no próprio campo, por
exemplo o campo Empresa, que não tem nenhuma annotation dentro da view.
 CDS – Ler a association de um CDS no ALV IDA

Executando nosso ALV IDA, vimos que ele exibe somente os dados da primeira tabela da nossa
view CDS

Estas colunas vem da primeira tabela (a última é uma coluna calculada), mas nenhuma
informação da tabela que está no Association “_moeda” é exibida

Vamos ver agora como exibir os dados da association “_moeda” quando o usuário clicar 2x em
alguma linha

Primeiro vamos adaptar nosso ALV IDA para permitir o clique duplo nas linhas

Altere o código da geração do ALV para utilizar a variável de referência lo_alv_ida, pois vamos
precisar chamar outros métodos desta classe do ALV
Agora adicione a linha que habilita o clique duplo no alv

Por fim adicione o event handler do clique duplo, o método que será executado quando o
usuário clicar 2x em alguma linha

Crie o método “clique_duplo” na sua classe local seguindo o modelo abaixo

Na seção de definição da classe

Na seção de implementação da classe

Dentro do método clique_duplo o que precisamos fazer é recuperar a linha que foi clicada pelo
usuário e em seguida buscar os dados da Association referentes à linha.
Primeiro vamos recuperar a linha onde o usuário clicou 2x

Agora vamos buscar os dados da Association, a partir da linha encontrada

Note que para acessar a Association “_moeda” temos que colocar uma barra invertida,
seguido do nome da Association e por fim o nome do campo daquela association.

Por último, com os dados da association já recuperados basta exibir a informação da forma
que for necessário. Aqui chamei apenas a classe cl_demo_output para termos uma saída em
tela desses dados.

Ative o programa e execute

Primeiro será exibida a tela inicial

Clique 2x em qualquer linha

Serão exibidos os dados da association

 CDS – Publicar CDS como serviço OData

Vamos agora criar uma view CDS e publicá-la como um serviço. Posteriormente este serviço
poderá ser consumido por uma aplicação Fiori.

Primeiro passo, vamos copiar uma view CDS já existente e fazer algumas modificações

Na perspectiva abap, selecione a view que deseja copiar, clique com o botão direito e
selecione Duplicate

Digite o nome da nova CDS e clique em Next

Selecione a request e clique em Finish (No meu caso utilizei o pacote local e por isso não há
request).

A nova view CDS será criada

A primeira coisa que temos que fazer é ajustar o nome do objeto DDIC da view pois como
copiamos, ele vem com o nome SQL da view original. Além disso vamos trocar o texto da view
também.
Agora vamos adicionar uma nova Annotation para informar que esta view CDS pode ser
publicada.

Adicione a annotation @OData.publish: true na view

ATIVE a view CDS.

Esta anotação irá criar um serviço OData que teremos que registrá-lo posteriormente. Assim
que registrarmos o serviço ele estará pronto para ser consumido por qualquer aplicação
externa ao sap, como por exemplo, uma aplicação Fiori.

Após ativar a view, note que será exibido um aviso ao lado da annotation que acabamos de
incluir. Passe o mouse sobre o ícone para ver o detalhe do aviso

Este aviso exibe o nome do serviço que foi criado para esta view e avisa que o serviço ainda
não está ativo (temos que registrá-lo ainda). É o último passo para que a view fique disponível
para ser consumida externamente.

Repare que o nome do serviço criado é o próprio nome da view CDS acrescido de “_CDS” no
final.
Para registrar o serviço teremos que ir no SAPGUI, na transação /n/IWFND/MAINT_SERVICE.

Execute a transação /n/IWFND/MAINT_SERVICE você verá uma tela parecida com esta
listando o catálogo de serviços

Clique no botão Inserir serviço

Na tela abaixo, preencha o campo Alias do sistema com LOCAL e no campo Nome do serviço
externo digite o nome do serviço criado para a sua view CDS (Aquele nome que aparece na
janela amarela de avisos, dentro da sua view). Pressione ENTER.
O serviço será listado logo abaixo

Selecione o serviço e clique em Inserir serviços selecionados

Na tela abaixo, selecione o pacote desejado e clique em OK

O serviço será criado, clique em OK na mensagem

Clique no botão de voltar, para retornar à tela de catálogo de serviços.

Você pode rolar a tela até localizar o serviço criado, ou pode usar o botão de Filtro para filtrar
o catálogo e exibir somente o seu serviço
Clique no nome do serviço técnico e depois clique em chamar Browser para testar o serviço

OBS: Pode ser que nesse momento, da abertura do browser sejam solicitadas algumas
confirmações de segurança, basta confirmar. Aqui também, na primeira vez, pode ser
solicitado seu usuário e senha de conexão ao ambiente SAP onde você criou o serviço. Como já
rodei antes, o browser foi aberto sem nenhuma confirmação.

O XML referente ao serviço é exibido no browser

No meu exemplo, este foi o link gerado para o serviço

http://dtcappphan02.engdb.infra:8000/sap/opu/odata/sap/ZCDS_VIEW_ODATA_CDS/?$forma
t=xml
Para visualizar os dados da view CDS no browser, através deste serviço, basta retirar os últimos
parâmetros do link e acrescentar o nome da view CDS.

Em vez de usar o link desta forma

http://dtcappphan02.engdb.infra:8000/sap/opu/odata/sap/ZCDS_VIEW_ODATA_CDS/?$forma
t=xml

Você pode retirar o que está em vermelho, e adicionar o nome da view CDS no final (obs:
nome da view CDS e não do serviço CDS, o serviço já está no link).

O link ficaria dessa forma

http://dtcappphan02.engdb.infra:8000/sap/opu/odata/sap/ZCDS_VIEW_ODATA_CDS/ZCDS_VI
EW_ODATA

Alterne o seu link para a sua view CDS e pressione ENTER. Os dados da view serão exibidos no
browser no formato XML
Veja que acima de cada “registro” há um link para consultar aquela empresa específica.

Copie o link de algum registro específico e cole no browser para ver uma única empresa

Exemplo:
http://dtcappphan02.engdb.infra:8000/sap/opu/odata/sap/ZCDS_VIEW_ODATA_CDS/ZCDS_VI
EW_ODATA('1')

Resultado

Para visualizar os dados da Association existente na view CDS basta utilizar o link acima (para
ver um registro) acrescido de “/to” e o nome da association

Exemplo:

http://dtcappphan02.engdb.infra:8000/sap/opu/odata/sap/ZCDS_VIEW_ODATA_CDS/ZCDS_VI
EW_ODATA('1')/to_moeda

Neste caso o serviço irá navegar para a association _moeda e irá exibir os dados dessa
associação, correspondentes à empresa 1 selecionada

Agora o serviço está pronto e pode ser consumido por qualquer aplicação externa ao SAP.
 CDS – VDM annotations

Antes de começarmos a desenvolver qualquer view CDS, é muito importante entender o

propósito dela. Por que está sendo criada? Onde essa view CDS será consumida? É para o
FIORI? É apenas para ser consumida por outras views CDS?

Uma vez que entendemos esses elementos, isso ajuda a padronizar o desenvolvimento da
view e a partir daí podemos definir algumas anotações específicas dentro da view.

Devemos colocar as anotações que fazem sentido para a view CDS.

Embora adicionar anotações que não são necessárias possa não impactar em nada,
certamente tornará confuso para outros desenvolvedores.

Alguns tipos de annotations que são utilizadas quando estamos criando uma view CDS

@OData e @UI – Utilizadas para aplicações FIORI

@Analytics – Utilizada para consumir uma view CDS em ferramentas analíticas como BEX,
Lumira, Webi, Analysis for Office.

@ObjectModel – Utilizado em aplicações transacionais que utilizam BOPF

@Semantics – Utilizado em S4Hana Embedded Analytics

@VDM – Para padronizar o desenvolvimento técnico da view CDS, a SAP criou a anotação
@VDM. Ela serve para padronizar o processo de desenvolvimento e ajuda a manter esses
artefatos técnicos organizados. Olhando para essas anotações, pode-se descobrir tudo sobre a
view. Esta anotação NÃO tem absolutamente nenhum impacto no comportamento ou saída da
view, apenas mostra os recursos abaixo:

• Que tipo de dados a view CDS expõe.

• Qual é a categoria da view CDS.

Como já vimos antes, uma view CDS pode ser de 4 tipos

• BASIC
• COMPOSITE
• COMSUMPTION
• PRIVATE

Através desta anotação VDM informamos qual o tipo e objetivo da view CDS
 CDS – Table Function

Uma CDS Table Function define uma função que é implementada nativamente no banco de
dados e pode ser chamada em outras views CDS. Ela também utiliza a técnica de code
pushdown, ou seja, apesar de ser criada na perspectiva abap, a função é executada
diretamente no hana.

De forma diferente da view CDS, uma table function implementa SQL nativo do hana através
de um método AMDP dentro de uma classe abap.

Dentro deste método AMDP é possível codificar SQL nativo do hana para acessar tanto tabelas
criadas diretamente na SE11 como também calculations views e procedures.

Vamos então criar uma CDS Table Function que, através de uma classe abap, irá implementar
um método AMDP para acessar a calculation view NF_DOCUMENTO que existe no hana.

Vamos ver então, no hana, a definição da view NF_DOCUMENTO. Esta view existe no TDF e
contém informações sobre o cabeçalho da nota fiscal. O objetivo deste exemplo é fazer a
leitura das notas fiscais desta view que estejam dentro de um período de data. A idéia é a
seguinte:

1) A CDS Table Function recebe 2 parametros de data (data inicio e data fim)
2) A CDS Table Function chama o método AMDP da classe e passa as duas datas como
parâmetro
3) O método AMDP recebe os 2 parametros e faz um select na view standard
NF_DOCUMENTO para selecionar as notas emitidas nesse período
4) O método AMDP retorna as notas selecionadas para a CDS Table Function
5) A CDS Table Function coloca estas notas na saída do CDS

O caminho da view NF_DOCUMENTO é

"_SYS_BIC"."sap.glo.tmflocbr.ctr/NF_DOCUMENTO"
Esta é a definição da view
Nós vamos fitrar a data DT_E_S de acordo com a data início e fim e retornar apenas alguns
campos para teste:

NF_ID, EMPRESA, FILIAL, DT_E_S e VL_TOTAL_DOCUMENTO

Vamos então começar a criar os objetos

Primeiro vamos criar nossa tabela function.

Entre no eclipse na perspectiva abap.

Com o botão direito no pacote desejado, selecione New Data Definition

Preencha o nome da CDS Table Function, a descrição e clique em Next

Selecione a request e clique em Next, no meu caso é pacote local e não preciso informar
request.

Selecione Define Table Function with Parameters e clique em Finish

A CDS Table Function será criada

Vamos definir os parâmetros de entrada da nossa table function. Substitua o template
parameter_name pelos parâmetros de entrada que deseja. No nosso caso vamos utilizar a
data início e data fim, além do mandante.

Obs: Aqui temos uma annotation Environment.systemField que colocamos acima do campo
mandante. Essa anotação permite que o parâmetro seja preenchido automaticamente com a
variável de sistema.

Para informar tipos de dados nativos do abap, usamos a sintaxe “abap.” e o tipo desejado. É
possível utilizar elementos de dados também, para definir os parâmetros.

Agora entre as chaves, vamos colocar os campos que serão retornado na table function.

Vamos acrescentar os campos MANDT, NF_ID, EMPRESA, FILIAL, DT_E_S e

VL_TOTAL_DOCUMENTO

OBS: Como a annotation foi utilizada para definir o campo mandt, é obrigatório selecionar este
campo.
Por último vamos definir a classe e o método AMDP que serão chamados. Altere o template
class_name=>method_name e coloque o nome da classe/método

A CDS Table Function está pronta.

ATIVE a table function.

Nosso próximo passo é criar uma classe com um método AMDP para selecionar os dados da
view NF_DOCUMENTO.

Entre no eclipse na perspectiva abap (classes com métodos AMDP não podem ser editadas no
SAPGUI)

Clique com o botão direito no pacote desejado e selecione New e Abap Class
No meu caso escolhi o pacote local, para não ter que criar requests.

Preencha o nome da classe (com o mesmo nome informado na Table Function), a descrição e
clique em Next

Selecione a request (no meu exemplo não tem por ser pacote local) e clique em Finish

A classe será criada

Agora temos que informar que esta classe será uma classe que implementará um método
AMDP. Fazemos isso adicionando a interface IF_AMDP_MARKER_HDB. Vá até a seção pública
da classe e implemente esta interface

Agora vamos criar o método AMDP. Na seção pública da classe defina um método estático
com o mesmo nome que utilizou na table funcion e relacione este método à sua CDS Table
Function

Obs: Note que na definição do método não existem parâmetros de entrada ou de saída. Os
parâmetros virão da CDS Table Function onde o método está relacionado.

Vamos criar a implementação do método AMDP.

Dentro do IMPLEMENTATION da classe, crie o método selecionar_nf_documento utilizando a

sintaxe que define o método como método AMDP
Agora vamos codificar a seleção da view NF_DOCUMENTO diretamente dentro do método.
Aqui é possível também chamar procedures armazenadas no Hana. Neste exemplo faremos
apenas um select simples na view.

Lembre-se que neste método utilizamos o SQL nativo do Hana.

Repare que dentro do método AMDP estamos utilizando os parâmetros de entrada definidos
na CDS Table Function

Podemos fazer diversas seleções assim como é feito em calculations views e procedures no
hana. Mas ao final, temos que devolver o resultado para o CDS Table Function.

Fazemos isso através do comando RETURN.

Neste caso estamos retornando todas as informações existentes em NF_DOCUMENTO.

ATIVE a sua classe.

Por fim vamos testar nossa CDS Table Function.

Volte para a table function que foi criada.

Pressione F8 para testar a table function.

Será exibido um popup solicitando os parâmetros de entrada

Preencha os parâmetros e clique em OK

O resultado será exibido

Pronto, a table function está pronta para utilizada.

 Open SQL, CDS ou AMDP? Qual técnica utilizar?

Views CDS, métodos AMDP e o Open SQL não competem entre si. São ferramentas diferentes
e cada uma deve ser utilizada de acordo com seu propósito

Todas as técnicas tem por objetivo ler informações no banco de dados mas você optar por
escolher uma ou outra baseado em algumas informações básicas

1) View CDS
a. Somente uma tabela de resultados pode retornar como saída da view
b. É um artefato construído baseado na idéia de ser consumido em vários
objetos/aplicações.
c. Para um ALV com a classe ALV IDA a execução será muito mais rápida

2) AMDP
a. SQLs independentes que não são frequentemente usados em outros objetos
b. Várias tabelas de resultado como saída

3) Open SQL
a. Se uma seleção é específica de um programa e não precisa ser reutilizada

4) SQL ADBC / Proxy objects

a. Evitar

Não podemos criar um guia oficial pra determinar a ordem de preferência para fazer o “code
push down” mas praticamente temos a seguinte ordem:

1) Open SQL / CDS views

2) AMDP
3) SQL ADBC / Proxy Objects

Sobre utilizar Open SQl ou CDS views, temos que lembrar que, se a idéia é reutilizar o objeto,
temos que pensar em CDS, se for um select específico para um programa, pode ser feito via
Open SQL

Se não existe uma view CDS e você precisa de um SQL somente para um programa, não é
necessário criar um CDS somente para isso.

Segue uma imagem que pode orientar na hora de decidir qual objeto utilizar