<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>dicas on Abapinho</title><link>https://abapinho.com/categories/dicas/</link><description>Recent content in dicas on Abapinho</description><generator>Hugo -- gohugo.io</generator><language>pt</language><copyright>&amp;copy;2009-2026 Nuno Godinho</copyright><lastBuildDate>Mon, 22 Jun 2026 09:00:00 +0100</lastBuildDate><atom:link href="https://abapinho.com/categories/dicas/index.xml" rel="self" type="application/rss+xml"/><item><title>Quem lançou a excepção?</title><link>https://abapinho.com/2026/06/quem-lancou-a-excepcao/</link><pubDate>Mon, 22 Jun 2026 09:00:00 +0100</pubDate><guid>https://abapinho.com/2026/06/quem-lancou-a-excepcao/</guid><description>&lt;p>As excepções podem ir sendo passadas para trás, de método em método, e serem apanhadas por um método que não tem nada a ver com o método que a lançou. E como o descobres?&lt;/p></description></item><item><title>Atributos que são variáveis globais disfarçadas</title><link>https://abapinho.com/2026/06/atributos-variaveis-globais/</link><pubDate>Mon, 08 Jun 2026 09:00:00 +0000</pubDate><guid>https://abapinho.com/2026/06/atributos-variaveis-globais/</guid><description>&lt;p>Não há coisa pior do que ver código a abusar das variáveis. São tão delicadas e no entanto tão mal tratadas, coitadas. E a quem as tem de ler. A pior forma de tratar uma variável é fazê-la global. Parece mentira mas em 2025 este crime continua a flagelar os nossos sistemas. Ora aqui está uma forma de lhes mostrar amor.&lt;/p></description></item><item><title>VALUE #( ) mais nada</title><link>https://abapinho.com/2026/04/value-cardinal-mais-nada/</link><pubDate>Mon, 20 Apr 2026 09:00:00 +0000</pubDate><guid>https://abapinho.com/2026/04/value-cardinal-mais-nada/</guid><description>&lt;p>Uma vez queria testar uma classe cujo construtor recebia vários parâmetros em que cada um pedia uma instância de um interface diferente. Essas instâncias não eram fáceis de criar e não eram relevantes para o teste. Depois de alguma experimentação descobri uma forma de contornar o problema.&lt;/p></description></item><item><title>Testa implicitamente os métodos booleanos</title><link>https://abapinho.com/2026/04/if-metodo-booleano-implicito/</link><pubDate>Mon, 13 Apr 2026 09:00:00 +0100</pubDate><guid>https://abapinho.com/2026/04/if-metodo-booleano-implicito/</guid><description>&lt;p>Lembrete singelo. Pensei que já fosse óbvio mas continuo a ver muitos IFs que testam explicitamente o resultado de um método booleano contra ABAP_TRUE ou INITIAL. Não é preciso! O ABAP neste caso é esperto.&lt;/p></description></item><item><title>Executa código após um COMMIT</title><link>https://abapinho.com/2026/02/evento-transaction-finished/</link><pubDate>Mon, 16 Feb 2026 09:00:00 +0100</pubDate><guid>https://abapinho.com/2026/02/evento-transaction-finished/</guid><description>&lt;p>Lembras-te como o &lt;code>CALL FUNCTION IN UPDATE TASK&lt;/code> permitia adiar algumas acções até ao momento do COMMIT?&lt;/p></description></item><item><title>Tech Radar</title><link>https://abapinho.com/2026/01/tech-radar/</link><pubDate>Mon, 19 Jan 2026 09:00:00 +0000</pubDate><guid>https://abapinho.com/2026/01/tech-radar/</guid><description>&lt;p>Encontrei este fantástico gráfico das tecnologias SAP.&lt;/p></description></item><item><title>FILTER</title><link>https://abapinho.com/2025/11/filter/</link><pubDate>Mon, 03 Nov 2025 09:00:00 +0000</pubDate><guid>https://abapinho.com/2025/11/filter/</guid><description>&lt;p>A função FILTER é nova e ainda pouco conhecida. Vou dar-te um exemplo de como pode ser usada.&lt;/p></description></item><item><title>Tudo em Todo o Lado ao Mesmo Tempo</title><link>https://abapinho.com/2025/06/eclipse-adt-split-editor/</link><pubDate>Mon, 02 Jun 2025 09:00:00 +0100</pubDate><guid>https://abapinho.com/2025/06/eclipse-adt-split-editor/</guid><description>&lt;p>Por vezes dá jeito poder olhar para duas zonas do código em simultâneo. Se as zonas forem em classes diferentes é só abrir as duas. Mas, e se forem na mesma classe? Por exemplo, se quiseres fazer um método inspirado ou relacionado com outro.&lt;/p></description></item><item><title>SELECTs insensível a maiúsculas e minúsculas</title><link>https://abapinho.com/2025/05/select-case-insensitive/</link><pubDate>Mon, 26 May 2025 09:00:00 +0100</pubDate><guid>https://abapinho.com/2025/05/select-case-insensitive/</guid><description>&lt;p>No SAP é normal ter tabelas na base de dados com um campo &lt;code>NAME&lt;/code> e outro &lt;code>NAME_SEARCH&lt;/code> que é preenchido com exactamente a mesma coisa que o &lt;code>NAME&lt;/code> mas em maiúsculas.&lt;/p>
&lt;p>Depois quando queres fazer pesquisas sem ligar a maiúsculas e minúsculas usas o &lt;code>NAME_SEARCH&lt;/code>. Já não é preciso fazer isso.&lt;/p></description></item><item><title>Reconstantes</title><link>https://abapinho.com/2025/02/reconstantes/</link><pubDate>Mon, 17 Feb 2025 09:00:00 +0000</pubDate><guid>https://abapinho.com/2025/02/reconstantes/</guid><description>&lt;p>O meu projecto tem constantes espalhadas por todo o lado, com nomes confusos ou errados. Uma salgalhada. Encontrei uma forma de reorganizar e rearrumar as constantes para que o código novo possa usar constantes bonitas sem espatifar o código antigo que pode continuar a usar as confusas.&lt;/p></description></item><item><title>Finalmente temos FINAL</title><link>https://abapinho.com/2025/02/final/</link><pubDate>Mon, 03 Feb 2025 09:00:00 +0000</pubDate><guid>https://abapinho.com/2025/02/final/</guid><description>&lt;p>Não há coisa pior do que ver gente a abusar das variáveis. São tão delicadas e no entanto tão mal tratadas, coitadas. Ora aqui está uma forma de lhes mostrar algum amor.&lt;/p></description></item><item><title>Como gostas tu das linhas em branco?</title><link>https://abapinho.com/2024/12/linhas-em-branco/</link><pubDate>Mon, 30 Dec 2024 09:00:00 +0000</pubDate><guid>https://abapinho.com/2024/12/linhas-em-branco/</guid><description>&lt;p>Toda a gente usa linhas em branco para melhor organizar o código. Mas onde usar e quantas usar? Falemos disso.&lt;/p></description></item><item><title>O Eclipse converte dados em VALUE</title><link>https://abapinho.com/2024/11/eclipse-adt-abap-value/</link><pubDate>Mon, 18 Nov 2024 09:00:00 +0000</pubDate><guid>https://abapinho.com/2024/11/eclipse-adt-abap-value/</guid><description>&lt;p>Às vezes é preciso pegar em dados da base de dados e replicá-los declarativamente em ABAP utilizando o comando VALUE. Para, por exemplo, construir testes unitários ABAP Unit.&lt;/p></description></item><item><title>No Eclipse ADT abres o mesmo objecto noutro cliente</title><link>https://abapinho.com/2024/10/eclipse-adt-open-in-project/</link><pubDate>Mon, 07 Oct 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/10/eclipse-adt-open-in-project/</guid><description>&lt;p>Historicamente foi sempre impossível saltar de um sistema SAP para o outro sem perder o contexto. Agora já dá.&lt;/p></description></item><item><title>O Data browser do Eclipse ADT é bem melhor que a SE16N</title><link>https://abapinho.com/2024/09/eclipse-adt-data-browser/</link><pubDate>Mon, 30 Sep 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/09/eclipse-adt-data-browser/</guid><description>&lt;p>As ferramentas que o SAP disponibiliza para ver o conteúdo de tabelas da base de dados sempre foram muito ranhosas.&lt;/p></description></item><item><title>O Eclipse ADT extrai métodos automaticamente</title><link>https://abapinho.com/2024/07/eclipse-adt-extract-method/</link><pubDate>Mon, 01 Jul 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/07/eclipse-adt-extract-method/</guid><description>&lt;p>Quando tens um método muito grande, deves subdividi-lo em vários mais pequenos.&lt;/p></description></item><item><title>No Eclipse ADT podes sempre fazer undo</title><link>https://abapinho.com/2024/06/eclipse-adt-undo/</link><pubDate>Mon, 17 Jun 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/06/eclipse-adt-undo/</guid><description>&lt;p>Diz-se: Não voltes onde foste feliz. Mas a verdade é que, em muitos casos, se pudesses voltar atrás, voltavas.&lt;/p></description></item><item><title>No Eclipse ADT não faltam atalhos de teclado</title><link>https://abapinho.com/2024/06/eclipse-adt-keyboard-shortcuts/</link><pubDate>Mon, 10 Jun 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/06/eclipse-adt-keyboard-shortcuts/</guid><description>&lt;p>Gosto de atalhos de teclado. Se eu conseguisse fazer o meu trabalho sem tirar as mãos do meu teclado seria um programador ainda mais feliz.&lt;/p></description></item><item><title>No Eclipse ADT podes partilhar links para o teu código</title><link>https://abapinho.com/2024/05/eclipse-adt-share-link/</link><pubDate>Mon, 20 May 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/05/eclipse-adt-share-link/</guid><description>&lt;p>Até recentemente o ABAP nunca foi muito dado a grandes colaborações.&lt;/p></description></item><item><title>No Eclipse ADT renomeias automaticamente</title><link>https://abapinho.com/2024/05/eclipse-adt-rename/</link><pubDate>Mon, 06 May 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/05/eclipse-adt-rename/</guid><description>&lt;p>Quem ainda programa de forma monolítica não sente tanta necessidade disto. Mas, quem usa múltiplas classes com múltiplos métodos sabe que é normal (e até desejável) mudar de ideias em relação ao nome destas coisas. As ideias não nascem já acabadas na nossa cabeça. Idealmente, o código é moldável e dá para ir moldando até encontrarmos a forma desejada.&lt;/p></description></item><item><title>O Eclipse ADT dá bom uso aos ABAP Doc</title><link>https://abapinho.com/2024/04/eclipse-adt-abap-doc/</link><pubDate>Mon, 29 Apr 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/04/eclipse-adt-abap-doc/</guid><description>&lt;p>ABAP Doc é uma forma excelente de integrar a documentação no código.&lt;/p></description></item><item><title>A magia do F2 no Eclipse ADT</title><link>https://abapinho.com/2024/04/eclipse-adt-f2/</link><pubDate>Mon, 22 Apr 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/04/eclipse-adt-f2/</guid><description>&lt;p>O Eclipse ADT chama-lhe &lt;em>Code element information&lt;/em>.&lt;/p></description></item><item><title>No Eclipse ADT continuas onde paraste</title><link>https://abapinho.com/2024/04/eclipse-adt-continuas-onde-paraste/</link><pubDate>Mon, 08 Apr 2024 09:00:00 +0100</pubDate><guid>https://abapinho.com/2024/04/eclipse-adt-continuas-onde-paraste/</guid><description>&lt;p>Sabias que no Eclipse ADT podes trabalhar mesmo sem ligação ao servidor?&lt;/p></description></item><item><title>Usa BASE para não estragares o que já tens</title><link>https://abapinho.com/2023/11/base/</link><pubDate>Mon, 06 Nov 2023 09:00:00 +0000</pubDate><guid>https://abapinho.com/2023/11/base/</guid><description>&lt;p>Dantes usava-se o comands &lt;code>APPEND&lt;/code> e &lt;code>INSERT&lt;/code> para adicionar linhas a tabelas internas. Mas agora que o ABAP cresceu, podemos usar &lt;code>VALUE&lt;/code>, &lt;code>REDUCE&lt;/code>, &lt;code>CORRESPONDING&lt;/code>, etc. Mas, e se a tabela interna já tiver linhas e não as quisermos perder?&lt;/p></description></item><item><title>INNER JOIN em vez de FOR ALL ENTRIES</title><link>https://abapinho.com/2023/10/inner-join-itbl/</link><pubDate>Mon, 30 Oct 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/10/inner-join-itbl/</guid><description>&lt;p>Há uns tempos &lt;a href="https://abapinho.com/2023/08/select-itbl/">mostrei-te&lt;/a> que podias fazer SELECT a uma tabela interna. E no outro dia perguntei-me: se isso é possível, não será então também possível fazer INNER JOINs?&lt;/p></description></item><item><title>Copia do SAPGUI para o clipboard</title><link>https://abapinho.com/2023/09/copy-to-clipboard/</link><pubDate>Mon, 25 Sep 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/09/copy-to-clipboard/</guid><description>&lt;p>Sabias que o teu programa ABAP pode copiar conteúdo para o clipboard do teu sistema operativo?&lt;/p></description></item><item><title>SELECT a tabela interna</title><link>https://abapinho.com/2023/08/select-itbl/</link><pubDate>Mon, 28 Aug 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/08/select-itbl/</guid><description>&lt;p>Agora dá para fazer SELECT a tabelas internas.&lt;/p></description></item><item><title>SELECT SINGLE vs SELECT UP TO 1 ROWS</title><link>https://abapinho.com/2023/06/select-single-vs-select-up-to-1-rows/</link><pubDate>Mon, 12 Jun 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/06/select-single-vs-select-up-to-1-rows/</guid><description>&lt;p>É pá, esta é uma daquelas discussões infinitas que nunca chegarão a lado nenhum. Igual a tentar decidir se mereces continuar a viver se meteres ananás na pizza ou queijo Filadélfia no sushi.&lt;/p></description></item><item><title>Chama a SM30 ou a SM34 a partir de uma função</title><link>https://abapinho.com/2023/06/funcoes-para-sm30/</link><pubDate>Mon, 05 Jun 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/06/funcoes-para-sm30/</guid><description>&lt;p>Se quiseres chamar a SM30 a partir de um programa podes fazer um &lt;code>CALL TRANSACTION&lt;/code> mas há uma forma mais simples.&lt;/p></description></item><item><title>Usa um diccionário em vez de IF ou CASE</title><link>https://abapinho.com/2023/05/diccionario-vs-if-ou-case/</link><pubDate>Mon, 29 May 2023 09:00:00 +0100</pubDate><guid>https://abapinho.com/2023/05/diccionario-vs-if-ou-case/</guid><description>&lt;p>Quanto menos IFs e CASEs melhor, certo? Cada ramo de um IF ou de um CASE é uma excepção. E nós gostamos mais de regras do que de excepções. Aqui está mais uma técnica para o conseguir.&lt;/p></description></item><item><title>O ponto de exclamação!</title><link>https://abapinho.com/2023/03/exclamation-point/</link><pubDate>Mon, 27 Mar 2023 09:00:00 +0000</pubDate><guid>https://abapinho.com/2023/03/exclamation-point/</guid><description>&lt;p>Quando se olha para o código fonte ABAP, a declaração dos métodos prefixa sempre os parâmetros de entrada com um ponto de exclamação. Isto sempre me intrigou. Finalmente sei o porquê.&lt;/p></description></item><item><title>Coleccionador de mensagens</title><link>https://abapinho.com/2023/01/message-collector/</link><pubDate>Mon, 16 Jan 2023 09:00:00 +0000</pubDate><guid>https://abapinho.com/2023/01/message-collector/</guid><description>&lt;p>As mensagens SAP são todas geridas de forma centralizada através da transacção &lt;code>SE91&lt;/code>, mas podem aparecer a um programa nos mais diversos formatos.&lt;/p></description></item><item><title>SELECT de registo único com chave incompleta</title><link>https://abapinho.com/2022/11/up-to-1-rows/</link><pubDate>Mon, 28 Nov 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/11/up-to-1-rows/</guid><description>&lt;p>Durante anos explicaram-me que se deve usar &lt;code>UP TO 1 ROWS&lt;/code> quando a chave não é completa. A minha professora primária disse que devemos sempre perguntar porquê: porquê? Ninguém explica.&lt;/p></description></item><item><title>Usar &amp; em textos de SAPScript</title><link>https://abapinho.com/2022/11/sapscript-ampersand/</link><pubDate>Mon, 14 Nov 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/11/sapscript-ampersand/</guid><description>&lt;p>Imagina que queres mostrar um &lt;em>url&lt;/em> num formulário. Colocas o &lt;em>url&lt;/em> no texto do formulário e partes do princípio que tudo correrá bem. Porque, de facto, geralmente tudo corre bem. Só que às vezes&amp;hellip;&lt;/p></description></item><item><title>Declarações de dados limpas</title><link>https://abapinho.com/2022/11/clean-data-declarations/</link><pubDate>Mon, 07 Nov 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/11/clean-data-declarations/</guid><description>&lt;p>Quando escreveres código deves estar sempre preocupado com quão fácil será mantê-lo. Isso é particularmente importante nas declarações de variáveis. E é tão simples de aplicar.&lt;/p></description></item><item><title>SELECT FOR UPDATE</title><link>https://abapinho.com/2022/05/select-for-update/</link><pubDate>Mon, 23 May 2022 09:09:09 +0100</pubDate><guid>https://abapinho.com/2022/05/select-for-update/</guid><description>&lt;p>Quando vais modificar registos na base de dados é comum fazeres primeiro um &lt;code>SELECT&lt;/code> para ver como as coisas são e depois então fazeres &lt;code>UPDATE&lt;/code> como as coisas serão.&lt;/p></description></item><item><title>Tabela com chaves de desenvolvimento</title><link>https://abapinho.com/2022/05/chaves-de-desenvolvimento/</link><pubDate>Mon, 16 May 2022 09:00:00 +0100</pubDate><guid>https://abapinho.com/2022/05/chaves-de-desenvolvimento/</guid><description>&lt;p>Quando chego a um projecto novo atribuem-me uma chave de desenvolvimento para cada sistema de desenvolvimento associado. Normalmente esta é-me enviada por e-mail. Normalmente perco-lhes o rasto.&lt;/p></description></item><item><title>Modifica facilmente uma tabela interna</title><link>https://abapinho.com/2022/05/modifica-tabela-interna/</link><pubDate>Mon, 09 May 2022 09:00:00 +0100</pubDate><guid>https://abapinho.com/2022/05/modifica-tabela-interna/</guid><description>&lt;p>A nova forma de ler de tabelas internas é também a nova forma de escrever em tabelas internas.&lt;/p></description></item><item><title>Os galhos dos IFs devem ser curtos</title><link>https://abapinho.com/2022/05/ifs-curtos/</link><pubDate>Mon, 02 May 2022 09:00:00 +0100</pubDate><guid>https://abapinho.com/2022/05/ifs-curtos/</guid><description>&lt;p>Imagina que és um macaco pendurado no galho de uma árvore. Queres saltar para outro galho mas ele está tão longe que não o consegues ver. Se saltares arriscas-te a cair ao chão. É mau.&lt;/p></description></item><item><title>Debug a trote</title><link>https://abapinho.com/2022/04/debug-step/</link><pubDate>Mon, 11 Apr 2022 09:00:00 +0100</pubDate><guid>https://abapinho.com/2022/04/debug-step/</guid><description>&lt;p>Há várias desculpas para não usar a nova sintaxe funcional do ABAP 7.4. Uma delas é dizer que é impossível fazer &lt;em>debug&lt;/em>.&lt;/p>
&lt;p>Só que não é.&lt;/p></description></item><item><title>Escapa aos hackers</title><link>https://abapinho.com/2022/03/escape/</link><pubDate>Mon, 28 Mar 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/03/escape/</guid><description>&lt;p>Um dos principais pontos fracos de um programa são os dados introduzidos pelos utilizadores.&lt;/p></description></item><item><title>Evita o ABAP obsoleto</title><link>https://abapinho.com/2022/03/obsoletos/</link><pubDate>Mon, 07 Mar 2022 09:00:00 +0000</pubDate><guid>https://abapinho.com/2022/03/obsoletos/</guid><description>&lt;p>O ABAP evolui (embora durante muitos anos não parecesse). E à medida que evolui vai deixando para trás alguns comandos ou formas de fazer as coisas porque disponibiliza outras melhores.&lt;/p>
&lt;p>Para além de aprender a usar as novidades é também importante aprender a deixar de usar o que vai ficando obsoleto.&lt;/p></description></item><item><title>ABAP no meio de comandos SQL</title><link>https://abapinho.com/2022/01/host-expressions/</link><pubDate>Mon, 31 Jan 2022 09:01:01 +0000</pubDate><guid>https://abapinho.com/2022/01/host-expressions/</guid><description>&lt;p>Sabias que, se o teu SAP for minimamente actual, podes usar expressões complexas em ABAP no meio de comandos SQL?&lt;/p></description></item><item><title>Não sejas do contra</title><link>https://abapinho.com/2021/11/nao-sejas-do-contra/</link><pubDate>Tue, 30 Nov 2021 09:00:14 +0000</pubDate><guid>https://abapinho.com/2021/11/nao-sejas-do-contra/</guid><description>&lt;p>A legibilidade é muito importante em todo o texto escrito. Talvez com a excepção da &lt;a href="https://cdn.culturagenial.com/imagens/aranha.jpg">poesia concreta&lt;/a>.&lt;/p>
&lt;p>Na sequência do &lt;a href="https://abapinho.com/2021/11/as-condicoes-if-devem-ser-simples-de-entender/">post anterior&lt;/a>, aqui fica um par de regras que minimizam o esforço que alguém tem de fazer para compreender expressões booleanas.&lt;/p></description></item><item><title>As condições IF devem ser simples de entender</title><link>https://abapinho.com/2021/11/as-condicoes-if-devem-ser-simples-de-entender/</link><pubDate>Mon, 01 Nov 2021 09:00:45 +0000</pubDate><guid>https://abapinho.com/2021/11/as-condicoes-if-devem-ser-simples-de-entender/</guid><description>&lt;p>Porque haveria de ser difícil lê-las? Só tornaria mais difícil a vida de quem vier a precisar de a entender.&lt;/p>
&lt;p>Lá porque uma condição IF é complexa não é por isso que tem de ser complicada.&lt;/p></description></item><item><title>SELECT com CASE</title><link>https://abapinho.com/2021/10/select-com-case/</link><pubDate>Mon, 25 Oct 2021 13:20:22 +0000</pubDate><guid>https://abapinho.com/2021/10/select-com-case/</guid><description>&lt;p>O ABAP está a permitir fazer coisas cada vez mais interessantes em SQL. A última que descobri foi que agora se pode usar CASEs.&lt;/p></description></item><item><title>Insere sem excepções em tabelas internas com chave única</title><link>https://abapinho.com/2021/07/insert-into-table/</link><pubDate>Mon, 05 Jul 2021 09:00:51 +0000</pubDate><guid>https://abapinho.com/2021/07/insert-into-table/</guid><description>&lt;p>Quantas vezes na tua vida de consultor tiveste de lidar com dumps que aconteceram em consequência de um programa tentar inserir duas linhas com a mesma chave numa tabela interna definida com UNIQUE KEY?&lt;/p>
&lt;p>Chega.&lt;/p></description></item><item><title>Popula manulamente uma LISTBOX</title><link>https://abapinho.com/2021/06/popula-manulamente-listbox/</link><pubDate>Mon, 14 Jun 2021 12:47:10 +0000</pubDate><guid>https://abapinho.com/2021/06/popula-manulamente-listbox/</guid><description>&lt;p>Em 2012 &lt;a href="https://abapinho.com/2012/10/ninguemligaaolistbox/">lamentei que a LISTBOX fosse tão pouco usada&lt;/a>. Ensinei a usá-la com elementos de dado standard, que a populam automaticamente. Hoje vou-te ensinar como a podes popular tu próprio se quiseres listar opções que não venham de um elemento de dados.&lt;/p></description></item><item><title>SELECTION-SCREEN FUNCTION KEY N</title><link>https://abapinho.com/2021/06/selection-screen-function-key-n/</link><pubDate>Mon, 07 Jun 2021 09:00:33 +0000</pubDate><guid>https://abapinho.com/2021/06/selection-screen-function-key-n/</guid><description>&lt;p>Há tantas coisas que se podem fazer nos ecrãs de selecção. Aqui está mais uma: cinco botões na barra de ferramentas.&lt;/p></description></item><item><title>Envia emails para uma lista de distribuição</title><link>https://abapinho.com/2021/05/lista-de-distribuicao/</link><pubDate>Mon, 31 May 2021 09:00:56 +0000</pubDate><guid>https://abapinho.com/2021/05/lista-de-distribuicao/</guid><description>&lt;p>Quando tens de enviar o mesmo email para mais do que um endereço, o mais comum é guardar a lista de endereços numa tabela qualquer e depois adicionar todos os endereços como recipientes.&lt;/p>
&lt;p>Mas aprendi recentemente uma forma muito mais bonita para conseguir o mesmo resultado.&lt;/p></description></item><item><title>Manipula textos de selecção sem os fixar no programa</title><link>https://abapinho.com/2021/05/manipula-textos-de-seleccao/</link><pubDate>Mon, 24 May 2021 09:00:11 +0000</pubDate><guid>https://abapinho.com/2021/05/manipula-textos-de-seleccao/</guid><description>&lt;p>Embora muitos ABAPers ainda se esqueçam disto, quanto menos textos forem fixados no programa mais fácil será traduzi-lo.&lt;/p>
&lt;p>Aqui está uma forma simples mas relativamente obscura de alterar os textos para, por exemplo, adicionar-lhes ícones, mantendo-os traduzíveis.&lt;/p></description></item><item><title>Chama função remotas AS SEPARATE UNIT</title><link>https://abapinho.com/2021/05/as-separate-unit/</link><pubDate>Mon, 17 May 2021 09:00:43 +0000</pubDate><guid>https://abapinho.com/2021/05/as-separate-unit/</guid><description>Imagina que chamas um módulo de função por RFC várias vezes seguidas. Se calhar julgas que cada chamada é completamente independente. Mas não é. O grupo de funções fica carregado em memória no sistema remoto e os mesmos dados globais serão reutilizados em todas as chamadas.
Isto não deverá constituir um problema na maior parte dos casos. Mas haverá cenários em que, por uma razão ou outra, o módulo de funções chamado guarda dados em variáveis globais que podem interferir negativamente com as chamadas subsequentes.</description></item><item><title>Funções manequins</title><link>https://abapinho.com/2021/05/funcoes-manequins/</link><pubDate>Mon, 10 May 2021 09:00:54 +0000</pubDate><guid>https://abapinho.com/2021/05/funcoes-manequins/</guid><description>Como é que se há-de traduzir dummy? Fica manequim.
Comecei a trabalhar recentemente num cliente novo e reparei que fazem aqui uma coisa que me agradou. Quando precisam de invocar por RFC módulos de função em outros sistemas SAP, criam localmente um módulo de função com o mesmo nome mas sem código, apenas com um comentário explicando que é uma função remota noutro sistema.
A virtude disto é que assim pode usar-se a ferramenta where-used para descobrir todos os sítios onde é invocada.</description></item><item><title>Desfazer implementação de nota SAP</title><link>https://abapinho.com/2020/08/desfazer-implementacao-de-nota-sap/</link><pubDate>Thu, 13 Aug 2020 09:00:32 +0000</pubDate><guid>https://abapinho.com/2020/08/desfazer-implementacao-de-nota-sap/</guid><description>&lt;p>Sou do tempo em que as notas da SAP se introduziam à mão. Copy paste e rezar para não errar. Granda maluquice.&lt;/p>
&lt;p>Lembro-me de um projecto que, por alguma razão que nunca ficou clara, em vez de se fazer upgrade, decidiu-se implementar várias centenas de notas à mão. Imprimiram as notas todas, fizeram num monte gigante com elas e uns 10 consultores passaram um fim-de-semana inteiro a tentar acabar com o monte. Conseguímos. Não faço ideia do que aconteceu a seguir mas de certeza que criámos montes de bugs.&lt;/p></description></item><item><title>Lookup em tabela sem ter de lidar com a excepção CX_SY_ITAB_LINE_NOT_FOUND</title><link>https://abapinho.com/2020/06/lookup-em-tabela-sem-ter-de-lidar-com-a-excepcao-cx_sy_itab_line_not_found/</link><pubDate>Mon, 15 Jun 2020 09:00:08 +0000</pubDate><guid>https://abapinho.com/2020/06/lookup-em-tabela-sem-ter-de-lidar-com-a-excepcao-cx_sy_itab_line_not_found/</guid><description>&lt;p>Antes do 7.40 ter modernizado o ABAP, um lookup a uma tabela obrigava a declarar uma variável auxiliar e a pelo menos 4 linhas de código.&lt;/p></description></item><item><title>Converter montante para formato externo numérico</title><link>https://abapinho.com/2020/06/converter-montante-para-formato-externo-numerico/</link><pubDate>Tue, 02 Jun 2020 09:09:10 +0000</pubDate><guid>https://abapinho.com/2020/06/converter-montante-para-formato-externo-numerico/</guid><description>&lt;p>Como é conhecido, o SAP guarda internamente os montantes e variáveis com 2 casas decimais. Quando queremos convertê-los no formato externo costumamos usar o WRITE com a opção CURRENCY. Mas o WRITE escreve numa variável alfa-numérica. E se quisermos escrever numa variável numérica?&lt;/p></description></item><item><title>Cortar e inserir rapidamente</title><link>https://abapinho.com/2020/05/cortar-e-inserir-rapidamente/</link><pubDate>Tue, 26 May 2020 09:00:36 +0000</pubDate><guid>https://abapinho.com/2020/05/cortar-e-inserir-rapidamente/</guid><description>&lt;p>Lá aprendi mais uma pequena funcionalidade obscura do SAPGui. Como acelerar o corte e costura.&lt;/p></description></item><item><title>Clean ABAP</title><link>https://abapinho.com/2020/05/clean-abap/</link><pubDate>Wed, 13 May 2020 12:54:21 +0000</pubDate><guid>https://abapinho.com/2020/05/clean-abap/</guid><description>&lt;p>Durante muitos anos, quando entrava em discussões sobre ABAP OO ser melhor do que FORMs, INCLUDEs e CALL FUNCTIONs, o mais comum é a pessoa do lado de lá continuar convencida de que OO é bom nas outras linguagens mas não traz vantagens para o ABAP. Logo a começar pelo atroz código standard SAP que parece ter sido escrito para provar que é possível fazer algo que viola todas as boas prácticas de programação e mesmo assim funciona.&lt;/p></description></item><item><title>NÃO</title><link>https://abapinho.com/2020/04/nao/</link><pubDate>Tue, 28 Apr 2020 12:08:03 +0000</pubDate><guid>https://abapinho.com/2020/04/nao/</guid><description>&lt;p>Não,
o ABAP
&lt;a href="https://blogs.sap.com/2014/09/29/abap-news-for-740-sp08-logical-expressions/#comment-82607">nunca vai ter&lt;/a>
o operador NOT.&lt;/p></description></item><item><title>MOVE-CORRESPONDING entre duas tabelas respeitando a chave</title><link>https://abapinho.com/2020/03/move-corresponding-entre-duas-tabelas-respeitando-a-chave/</link><pubDate>Mon, 23 Mar 2020 09:00:04 +0000</pubDate><guid>https://abapinho.com/2020/03/move-corresponding-entre-duas-tabelas-respeitando-a-chave/</guid><description>&lt;p>O Abapinho não tem falado muito sobre o 7.40 porque as suas novidades têm já sido amplamente descritas em vários sites. Tentamos não inventar a roda.&lt;/p>
&lt;p>Mas há pequenas pérolas úteis que ainda são pouco conhecidas. Esta é sobre uma delas.&lt;/p></description></item><item><title>Obtém valores únicos de campo de tabela interna</title><link>https://abapinho.com/2020/03/obtem-valores-unicos-de-campo-de-tabela-interna/</link><pubDate>Mon, 16 Mar 2020 09:00:08 +0000</pubDate><guid>https://abapinho.com/2020/03/obtem-valores-unicos-de-campo-de-tabela-interna/</guid><description>&lt;p>Em SQL consegue-se obter os valores únicos de um campo recorrendo ao DISTINCT. Quando os dados já estão numa tabela interna, antes do ABAP 7.40 tinha de se fazer um LOOP e um COLLECT.&lt;/p>
&lt;p>Mas agora que vivemos em tempos mais modernos, há uma forma simples e elegante que consegue o mesmo com um único comando.&lt;/p></description></item><item><title>Como correr uma CL_GUI_ALV_GRID em background</title><link>https://abapinho.com/2020/03/como-correr-uma-cl_gui_alv_grid-em-background/</link><pubDate>Mon, 09 Mar 2020 09:00:48 +0000</pubDate><guid>https://abapinho.com/2020/03/como-correr-uma-cl_gui_alv_grid-em-background/</guid><description>&lt;p>Alguém decidiu correr em background uma ALV editável. Deu dump. A solução é simples mas pouco óbvia.&lt;/p></description></item><item><title>Usa CL_GUI_ALV_GRID sem ter de criar um ecrã</title><link>https://abapinho.com/2020/03/usa-cl_gui_alv_grid-sem-ter-de-criar-um-ecra/</link><pubDate>Mon, 02 Mar 2020 09:00:14 +0000</pubDate><guid>https://abapinho.com/2020/03/usa-cl_gui_alv_grid-sem-ter-de-criar-um-ecra/</guid><description>&lt;p>Hoje em dia é raro usar o CL_GUI_ALV_GRID porque uso quase sempre a SALV. Mas quando é preciso fazer ALVs editáveis continuo a recorrer à CL_GUI_ALV_GRID. Durante muito tempo julguei que, para a usar, tinha de criar um ecrã com um container, o que é uma chatice. E como eu uso ABAP OO, precisava de criar um function group para alojar o ecrã e um function module para o chamar, o que era outra chatice.&lt;/p></description></item><item><title>Como fazer uma ALV grid ocupar a janela inteira</title><link>https://abapinho.com/2020/02/como-fazer-uma-alv-grid-ocupar-a-janela-inteira/</link><pubDate>Mon, 10 Feb 2020 13:22:15 +0000</pubDate><guid>https://abapinho.com/2020/02/como-fazer-uma-alv-grid-ocupar-a-janela-inteira/</guid><description>&lt;p>Às vezes é nas coisas mais básicas que se perde mais tempo. Por exemplo, recentemente foi preciso que uma ALV grid ocupasse automaticamente a janela inteira. Mas como? Mas como? Mas como?&lt;/p></description></item><item><title>Código demo da SAP todo junto</title><link>https://abapinho.com/2020/01/demos-da-sap-todos-juntos/</link><pubDate>Thu, 23 Jan 2020 09:00:03 +0000</pubDate><guid>https://abapinho.com/2020/01/demos-da-sap-todos-juntos/</guid><description>&lt;p>Nos anos 80, quando eu era pequenino, tinha de fazer &lt;code>LOAD &amp;quot;&amp;quot;&lt;/code> e depois esperar vários minutos a olhar para riscas numa TV e a ouvir ruído antes que um jogo do ZX Spectrum ficasse pronto a jogar. Muito anos mais tarde, quando já tinha um PC, descobri um emulador que tinha um menu com centenas de jogos do ZX Spectrum. Só tinha de escolher um da lista e começar a jogar instantaneamente.&lt;/p></description></item><item><title>Passei a comentar com " em vez de *</title><link>https://abapinho.com/2020/01/passei-a-comentar-com-aspas/</link><pubDate>Wed, 15 Jan 2020 09:00:18 +0000</pubDate><guid>https://abapinho.com/2020/01/passei-a-comentar-com-aspas/</guid><description>&lt;p>Sempre usei * para comentar o código. Só usava &amp;quot; quando precisava de usar pseudo-comentários ou adicionar um pequeno comentário no final da linha.&lt;/p>
&lt;p>Mas há pouco tempo aprendi que faz muito mais sentido usar &amp;ldquo;.&lt;/p></description></item><item><title>É tão simples converter uma MESSAGE numa EXCEPTION</title><link>https://abapinho.com/2019/11/converter-message-em-exception/</link><pubDate>Mon, 04 Nov 2019 10:30:44 +0000</pubDate><guid>https://abapinho.com/2019/11/converter-message-em-exception/</guid><description>&lt;p>Há alguns anos atrás &lt;a href="https://abapinho.com/2015/06/converter-excepcao-em-classe-de-excepcao/">mostrei como se podia converter uma MESSAGE normal numa excepção tipificada&lt;/a>. Entretanto o ABAP evoluiu um bocadinho e agora, na versão 7.40, aquela solução complexa já não é necessária.&lt;/p></description></item><item><title>Conteúdo de tabela interna numa ALV</title><link>https://abapinho.com/2019/09/alv-tabela-interna/</link><pubDate>Mon, 30 Sep 2019 09:00:54 +0000</pubDate><guid>https://abapinho.com/2019/09/alv-tabela-interna/</guid><description>&lt;p>Não sei há quanto tempo é que isto está disponível mas só agora descobri que é muito fácil ver numa ALV o conteúdo de uma tabela interna durante debug.&lt;/p></description></item><item><title>Atalhos mágicos para menus</title><link>https://abapinho.com/2019/09/atalhos-magicos-para-menus/</link><pubDate>Tue, 10 Sep 2019 09:00:02 +0000</pubDate><guid>https://abapinho.com/2019/09/atalhos-magicos-para-menus/</guid><description>&lt;p>Se tu que estás a ler isto achares que tudo o que está escrito no Abapinho é literalmente verdade, o que te vou dizer a seguir vai desiludir: quando disse mágico não quis dizer que era sobrenatural. É só uma forma mais abrilhantada de dizer que é surpreendente e inesperado. Tomei esta liberdade um bocado como quando dizes &lt;em>estou morto de sede&lt;/em> e no entanto ainda estás vivo. Tendo clarificado isto, podemos continuar.&lt;/p></description></item><item><title>Atalho para gravar lista em ficheiro local</title><link>https://abapinho.com/2019/09/atalho-para-gravar-lista-em-ficheiro-local/</link><pubDate>Wed, 04 Sep 2019 09:00:54 +0000</pubDate><guid>https://abapinho.com/2019/09/atalho-para-gravar-lista-em-ficheiro-local/</guid><description>&lt;p>O SAP está replecto de recantos refundidos e rebuscados raramente reconhecidos que o Abapinho se regozija por revelar.&lt;/p>
&lt;p>O comando %pc é equivalente à opção de menu Sistema/Lista/Gravar/File local:&lt;/p></description></item><item><title>IF sem IS INITIAL em métodos booleanos</title><link>https://abapinho.com/2019/08/if-sem-is-initial-em-metodos-booleanos/</link><pubDate>Tue, 27 Aug 2019 09:00:07 +0000</pubDate><guid>https://abapinho.com/2019/08/if-sem-is-initial-em-metodos-booleanos/</guid><description>&lt;p>O sistema do cliente onde trabalho actualmente foi finalmente actualizado para o 7.50 e, depois de tantos anos preso ao ABAP convencional, posso desfrutar as maravilhas introduzidas no 7.40.&lt;/p>
&lt;p>São às dúzias essas maravilhas, e não vou começar aqui a fazer artigos sobre cada uma porque já existem artigos espalhados pela net sobre quase todas elas o Abapinho faz sempre o possível por ensinar algo novo ou, pelo menos, pouco conhecido.&lt;/p>
&lt;p>Mas há uma singela funcionalidade que, não sendo nada de extraordinário, me agrada: já não é preciso fazer IS INITIAL no comando IF quando a condição é um método que retorna um booleano.&lt;/p></description></item><item><title>Variantes de activação da SAAB</title><link>https://abapinho.com/2019/07/saab-variantes/</link><pubDate>Thu, 25 Jul 2019 09:00:00 +0000</pubDate><guid>https://abapinho.com/2019/07/saab-variantes/</guid><description>&lt;p>Em tempos falámos na SAAB e nas vantagens de a utilizar para melhor conseguir analisar e descobrir problemas no nosso código. Nesse artigo não expliquei uma coisa que é realmente importante: variantes de activação.&lt;/p></description></item><item><title>Enhancements implícitos em estruturas de dados</title><link>https://abapinho.com/2019/05/enhancements-implicitos-em-estruturas-de-dados/</link><pubDate>Mon, 13 May 2019 09:00:00 +0000</pubDate><guid>https://abapinho.com/2019/05/enhancements-implicitos-em-estruturas-de-dados/</guid><description>&lt;p>Já todos usámos &lt;em>enhancements&lt;/em> implícitos para adicionar código ao início ou final de funções, forms ou métodos standard. Mas é menos conhecido o facto de que também podemos adicionar campos a estruturas de dados, estejam elas declaradas como TYPES ou ou directamente como DATA.&lt;/p></description></item><item><title>Comentário sobre comentários</title><link>https://abapinho.com/2018/11/comentario-sobre-comentarios/</link><pubDate>Mon, 26 Nov 2018 09:00:19 +0000</pubDate><guid>https://abapinho.com/2018/11/comentario-sobre-comentarios/</guid><description>&lt;p>Na escola aprende-se que o código deve ter sempre comentários. Depois, na vida real, descobrimos que nem toda a gente prestou atenção na escola.&lt;/p>
&lt;p>Sempre tive o cuidado de comentar os vários passos do meu código, especialmente as partes mais obscuras ou que não são auto-explicativas.&lt;/p>
&lt;p>Mas depois de ler o livro &lt;em>&lt;a href="https://www.goodreads.com/book/show/3735293-clean-code">Clean Code&lt;/a>&lt;/em> do &lt;a href="https://en.wikipedia.org/wiki/Robert_C._Martin">Uncle Bob&lt;/a>, a minha opinião mudou. Hoje acredito que quanto menos comentários melhor. E no entanto não acho que esta mudança seja contraditória.&lt;/p></description></item><item><title>Os vários relógios do teu sistema SAP</title><link>https://abapinho.com/2018/10/os-varios-relogios-do-teu-sistema-sap/</link><pubDate>Mon, 22 Oct 2018 09:00:08 +0000</pubDate><guid>https://abapinho.com/2018/10/os-varios-relogios-do-teu-sistema-sap/</guid><description>&lt;p>Ainda que o SAP nos apareça como um todo, este é constituído por várias partes independentes interligadas. Há um pequeno programa standard que verifica se os relógios de cada uma destas partes estão correctos e sincronizados.&lt;/p>
&lt;p>Provavelmente não será de grande utilidade no dia-a-dia. Mas não deixa de ser uma curiosidade engraçada.&lt;/p></description></item><item><title>Injectar comandos ABAP num sistema produtivo</title><link>https://abapinho.com/2018/10/injectar-comandos-abap-num-sistema-produtivo/</link><pubDate>Mon, 08 Oct 2018 09:00:50 +0000</pubDate><guid>https://abapinho.com/2018/10/injectar-comandos-abap-num-sistema-produtivo/</guid><description>O vídeo abaixo demonstra como é simples criar condições para facilmente injectar comandos ABAP em programas em produtivo.
Ponderei sobre partilhar este vídeo pois o seu conteúdo pode ser usado para fins menos nobres. Mas, como já aconteceu no passado, acredito que é preferivel que isto seja divulgado pois é fundamental que os administradores de sistema estejam conscientes desta possibilidade e protejam os seus sistemas dela. Pois é algo verdadeiramente perigoso.</description></item><item><title>Transporta uma tabela local com os ecrãs de manutenção</title><link>https://abapinho.com/2018/10/transporta-ecras-de-manutencao-de-tabela/</link><pubDate>Mon, 01 Oct 2018 12:47:47 +0000</pubDate><guid>https://abapinho.com/2018/10/transporta-ecras-de-manutencao-de-tabela/</guid><description>&lt;p>Criaste uma tabela e os seus ecrãs de manutenção como objectos locais.&lt;/p>
&lt;p>Quando mais tarde te arrependeres e decidires transportar a tabela, como fazes para os transportar também os ecrãs de manutenção?&lt;/p>
&lt;p>Transportar só o grupo de funções não chega, vai dar erro.&lt;/p></description></item><item><title>Testa uma sequência de funções na SE37</title><link>https://abapinho.com/2018/07/testa-uma-sequencia-de-funcoes-na-se37/</link><pubDate>Mon, 09 Jul 2018 09:00:17 +0000</pubDate><guid>https://abapinho.com/2018/07/testa-uma-sequencia-de-funcoes-na-se37/</guid><description>&lt;p>Podia jurar que já tinha feito um post sobre isto mas não consigo encontrá-lo por isso aqui vai.&lt;/p>
&lt;p>Há funções que guardam dados globais que serão depois usados por outra função do mesmo grupo. Ora se quiseres testar as duas juntas é fundamental que corram sequencialmente dentro da mesma transacção.&lt;/p>
&lt;p>Toda a gente sabe que a transacção SE37 permite testar uma função. O que pouca gente sabe é que a transacção SE37 permite testar uma sequência de funções dentro da mesma transacção. Quem não sabe isto normalmente acaba por criar um pequeno programa de testes para chamar as várias funções em sequência. Fica agora a saber como o pode evitar.&lt;/p></description></item><item><title>Controla mais o teu ecrã de selecção</title><link>https://abapinho.com/2018/03/controla-ecra-seleccao/</link><pubDate>Mon, 12 Mar 2018 09:00:08 +0000</pubDate><guid>https://abapinho.com/2018/03/controla-ecra-seleccao/</guid><description>&lt;p>Os PARAMETERS e os SELECT-OPTIONS até têm algumas opções de configuração. Mas muitas vezes dava jeito conseguir configurá-los ainda mais. E curiosamente, ainda que não seja assim tão simples, é possível fazê-lo, através de uma função standard.&lt;/p></description></item><item><title>Debug em utilizador sem permissões para debug</title><link>https://abapinho.com/2018/03/debug-sem-permissoes/</link><pubDate>Mon, 05 Mar 2018 09:00:48 +0000</pubDate><guid>https://abapinho.com/2018/03/debug-sem-permissoes/</guid><description>&lt;p>Num sistema bem protegido, os utilizadores não têm permissões para debug. Mas muitas vezes isso complica a vida dos ABAPers que, ao quererem resolver um problema desse utilizador, não podem fazer debug à sua sessão.&lt;/p>
&lt;p>Mas há uma forma legítima, ainda que pouco óbvia, de contornar o problema.&lt;/p></description></item><item><title>Altera programas standard sem precisar de chave</title><link>https://abapinho.com/2018/02/editar-objectos-standard/</link><pubDate>Mon, 12 Feb 2018 09:00:22 +0000</pubDate><guid>https://abapinho.com/2018/02/editar-objectos-standard/</guid><description>&lt;p>Estamos perante mais um daquelas dilemas: esconder porque é perigoso e alguém pode fazer o mal usando esta informação ou ensinar porque não o fazer é paternalista porque presume que os leitores não são responsáveis. O regimes de ditadura costumam optar pela primeira: queimam livros e censuram. O Abapinho gosta de acreditar que os seus leitores são pessoas responsáveis que merecem ter acesso ao conhecimento.&lt;/p>
&lt;p>E, por isso, aqui está. Não, não é um manual de como criar urânio enriquecido nem uma fórmula para nitroglicerina caseira. Mas anda perto: é um truque para conseguir alterar objectos standard sem precisar de chave.&lt;/p></description></item><item><title>Altera ordens de transporte mesmo que não te deixem</title><link>https://abapinho.com/2018/01/altera-ordens-de-transporte/</link><pubDate>Mon, 22 Jan 2018 09:00:15 +0000</pubDate><guid>https://abapinho.com/2018/01/altera-ordens-de-transporte/</guid><description>&lt;p>Como todos nós sabemos os administradores de sistemas são pessoas más, insensíveis e crueis. A prová-lo está o incontornável &lt;a href="http://bofharchive.com/">BOFH&lt;/a>.&lt;/p>
&lt;p>Nós, programadores ABAP, somos vítimas indefesas nas mãos destas criaturas maléficas.&lt;/p>
&lt;p>Mas nem sempre somos obrigados a deixar-nos esmagar pelos dedos peludos dos seus caprichos.&lt;/p></description></item><item><title>Mostra valores não convertidos na SE16N</title><link>https://abapinho.com/2017/12/mostra-valores-nao-convertidos-na-se16n/</link><pubDate>Mon, 11 Dec 2017 09:00:35 +0000</pubDate><guid>https://abapinho.com/2017/12/mostra-valores-nao-convertidos-na-se16n/</guid><description>&lt;p>A SE16N mostra-te os valores dos campos no formato externo. Até há pouco tempo eu usava a arcaica SE17 para ver os valores no formato interno. Mas o Rui Nunes explicou que há uma forma de o conseguir fazer na SE16N.&lt;/p></description></item><item><title>Abracadabra revela parâmetro secreto</title><link>https://abapinho.com/2017/10/parametro-secreto/</link><pubDate>Mon, 23 Oct 2017 09:00:29 +0000</pubDate><guid>https://abapinho.com/2017/10/parametro-secreto/</guid><description>Aqui está uma forma pouco ortodoxa de lidar com o ecrã de selecção de um programa.
Se tiveres um parâmetro que pretendes manter escondido dos olhos dos utilizadores e mesmo assim poder ter acesso a ele (ex.: um pisco para entrar em modo de debug) podes usar a palavra mágica ABRACADABRA para lhe aceder.
Funciona assim:
DATA: unhide_parameters TYPE flag. PARAMETERS: p_debug AS CHECKBOX. AT SELECTION-SCREEN. CASE sy-ucomm. WHEN &amp;#39;ABRACADABRA&amp;#39;. unhide_parameters = abap_true.</description></item><item><title>Classe para garantir segurança em programação dinâmica</title><link>https://abapinho.com/2017/07/classe-garantir-seguranca-programacao-dinamica/</link><pubDate>Wed, 26 Jul 2017 09:00:33 +0000</pubDate><guid>https://abapinho.com/2017/07/classe-garantir-seguranca-programacao-dinamica/</guid><description>&lt;p>No outro dia encontrei um programa que gerava um comando SQL com base em várias variáveis fixadas no código. Mas, por distracção ou ignorância, a alminha que fez aquilo achou que fazia sentido associar essas variáveis a símbolos de texto. Algo assim:&lt;/p></description></item><item><title>Relatório de consistência da SALV</title><link>https://abapinho.com/2017/07/relatorio-consistencia-salv/</link><pubDate>Tue, 18 Jul 2017 09:00:08 +0000</pubDate><guid>https://abapinho.com/2017/07/relatorio-consistencia-salv/</guid><description>&lt;p>Às vezes uma SALV pode ter inconsistências que passam despercebidas a quem as programa. Um exemplo é uma estrutura com um campo WRBTR sem um campo de moeda associado:&lt;/p></description></item><item><title>Entra numa transacção sem passar pelo ecrã de selecção</title><link>https://abapinho.com/2017/07/transaccao-sem-ecra-de-seleccao/</link><pubDate>Wed, 12 Jul 2017 09:00:53 +0000</pubDate><guid>https://abapinho.com/2017/07/transaccao-sem-ecra-de-seleccao/</guid><description>Mais uma vez o SAPGui me surpreende com mais um atalho obscuro que desconhecia.
Usemos a transacção de visualização de clientes XD03 como exemplo:
Entras no ecrã de selecção da transacção escrevendo lá em cima /NXD03
Introduzes o número do cliente que queres visualizar e carregas em ENTER
Fazes lá o que tens a fazer e depois sais da transacção
Mas&amp;hellip; de repente&amp;hellip; precisas de ver mais qualquer coisa desse cliente</description></item><item><title>Copiar variante do Code Inspector para outro sistema</title><link>https://abapinho.com/2017/05/copiar-variante-do-code-inspector/</link><pubDate>Mon, 08 May 2017 09:00:09 +0000</pubDate><guid>https://abapinho.com/2017/05/copiar-variante-do-code-inspector/</guid><description>No meu cliente tenho três ambientes de desenvolvimento. Dantes tinha só um. E foi nesse que configurei a variante do Code Inspector que uso para correr o Abap Test Cockpit.
Quando apareceram os outros dois, antes de me decidir a replicar a variante à mão em cada um deles, decidi investigar um pouco. Para minha surpresa encontrei no GitHub o projecto upDOWNci que faz exactamente o que eu precisava: exportar e importar variantes do Code Inspector.</description></item><item><title>Pasta física vs pasta lógica</title><link>https://abapinho.com/2017/03/pasta-fisica-vs-pasta-logica/</link><pubDate>Mon, 20 Mar 2017 09:00:30 +0000</pubDate><guid>https://abapinho.com/2017/03/pasta-fisica-vs-pasta-logica/</guid><description>&lt;p>Se num relatório chamado APP1 precisares de gravar um ficheiro numa determinada pasta do servidor (ex.: /export/app1/) e não quiseres que esta pasta seja um parâmetro, como fazes?&lt;/p></description></item><item><title>Fechar automaticamente as portas que tu abres</title><link>https://abapinho.com/2017/03/close-doors-automatically/</link><pubDate>Mon, 13 Mar 2017 09:00:21 +0000</pubDate><guid>https://abapinho.com/2017/03/close-doors-automatically/</guid><description>Estas no editor. Introduzes um ( ou [ ou { ou &amp;rsquo; e o SAP é mongo e não o fecha certo?
Ora bem,
Clica no ícone em baixo à direita que acede às opções do SAPGui onde adicionamos template.
Na opção formatting , activas o Enable Auto Brackets e voilá, o SAP começa a fechar automaticamente as portas que tu abres.
Mais valia que isto viesse activado de raiz.</description></item><item><title>ASSERT vs Excepção</title><link>https://abapinho.com/2017/01/excepcao-vs-assert/</link><pubDate>Mon, 23 Jan 2017 09:00:56 +0000</pubDate><guid>https://abapinho.com/2017/01/excepcao-vs-assert/</guid><description>&lt;p>Quem lê o Abapinho sabe quanto gosto de classes de excepções. No entanto, este não é o único mecanismo que o ABAP disponibiliza para controlo de erros.&lt;/p>
&lt;p>Há outro, chamado ASSERT, que devia ser mais usado, e que hoje trago à baila.&lt;/p></description></item><item><title>O estranho caso da estrutura parcialmente protegida</title><link>https://abapinho.com/2016/12/o-estranho-caso-da-estrutura-parcialmente-protegida/</link><pubDate>Mon, 26 Dec 2016 09:00:10 +0000</pubDate><guid>https://abapinho.com/2016/12/o-estranho-caso-da-estrutura-parcialmente-protegida/</guid><description>&lt;p>Estava a tentar actualizar uma linha de uma SORTED TABLE e não estava a conseguir.&lt;/p></description></item><item><title>Passei-me ao passar o SY-TABIX por parâmetro</title><link>https://abapinho.com/2016/12/sy-tabix-por-parametro/</link><pubDate>Mon, 19 Dec 2016 09:00:47 +0000</pubDate><guid>https://abapinho.com/2016/12/sy-tabix-por-parametro/</guid><description>&lt;p>No outro dia aconteceu-me uma coisa muito estranha. Estava eu a passar o SY-TABIX como parâmetro para dentro de um método quando reparei que cá fora era 1 mas quando lá chegava dentro era 0.&lt;/p>
&lt;p>Muitíssimo bizarro.&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#000">o_coisificador&lt;/span>-&amp;gt;&lt;span style="color:#000">que_coisa_bizarra&lt;/span>( &lt;span style="color:#000">sy&lt;/span>-&lt;span style="color:#000">tabix&lt;/span> ).&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div></description></item><item><title>Converte classe de excepção numa BAPIRET2</title><link>https://abapinho.com/2016/12/converte-classe-excepcao-numa-bapiret2/</link><pubDate>Mon, 12 Dec 2016 09:00:06 +0000</pubDate><guid>https://abapinho.com/2016/12/converte-classe-excepcao-numa-bapiret2/</guid><description>&lt;p>Há uns tempos escrevi um artigo a explicar uma forma de &lt;a href="https://abapinho.com/2015/06/converter-excepcao-em-classe-de-excepcao/">converter automaticamente excepções clássicas em classes de excepção&lt;/a>. Hoje uso esta técnica em quase todas as classes de excepção que crio (e até já melhorei a coisa mas noutro dia falo disso).&lt;/p>
&lt;p>Esta dica explica exactamente o contrário.&lt;/p></description></item><item><title>Comparar versões ignorando as indentações</title><link>https://abapinho.com/2016/12/comparar-versoes-ignorando-as-indentacoes/</link><pubDate>Mon, 05 Dec 2016 09:00:31 +0000</pubDate><guid>https://abapinho.com/2016/12/comparar-versoes-ignorando-as-indentacoes/</guid><description>Quando se compara versões por vezes aparecem várias diferenças mesmo quando não fizemos alterações ao código. Essas diferenças podem ser simplesmente consequência de um Pretty Printer que altera as indentações do código. Isto torna a comparação muito difícil e confusa.
Mas o ABAP Workbench prevê isso e permite configurar o comparador de versões para ignorar indentações e até comentários.
Basta carregares em F5 ou ires ao menu “Display Format &amp;gt; Settings” e adaptá-lo às tuas necessidades:</description></item><item><title>Usa o GUI Status Standard sem o copiares</title><link>https://abapinho.com/2016/11/gui-status-standard/</link><pubDate>Mon, 28 Nov 2016 09:00:02 +0000</pubDate><guid>https://abapinho.com/2016/11/gui-status-standard/</guid><description>&lt;p>Quando queres usar a CL_GUI_ALV_GRID num CONTAINER tens de copiar um GUI Status standard de outro programa. Por exemplo o GUI Status “STANDARD&amp;quot; do grupo de funções SALV. E depois no PAI do ecrã chamas:&lt;/p>
&lt;p>SET PF-STATUS ‘STANDARD’.&lt;/p>
&lt;p>E lá aparecem os butõezinhos.&lt;/p></description></item><item><title>Cria modelos na SE80 arrastando coisas para o código</title><link>https://abapinho.com/2016/11/modelos-na-se80-arrastando-para-o-codigo/</link><pubDate>Mon, 14 Nov 2016 09:00:26 +0000</pubDate><guid>https://abapinho.com/2016/11/modelos-na-se80-arrastando-para-o-codigo/</guid><description>&lt;p>Quando estamos a programar é sempre bom ter formas de acelerar o que estamos a fazer. Uma delas é a geração automática de de padrões de chamadas de métodos e afins.&lt;/p>
&lt;p>Conheço 3 formas de o fazer.&lt;/p></description></item><item><title>Campos chave de estrutura DDIC</title><link>https://abapinho.com/2016/11/definir-a-chave-de-uma-estrutura-do-ddic/</link><pubDate>Wed, 02 Nov 2016 09:00:39 +0000</pubDate><guid>https://abapinho.com/2016/11/definir-a-chave-de-uma-estrutura-do-ddic/</guid><description>&lt;p>Hoje em dia quando quero criar uma SALV defino sempre a estrutura dos dados no DDIC já com os elementos de dados com as descrições desejadas em vez de os forçar no código.&lt;/p></description></item><item><title>Encontra tudo de uma só vez</title><link>https://abapinho.com/2016/10/find-everything-at-once/</link><pubDate>Mon, 24 Oct 2016 09:00:11 +0000</pubDate><guid>https://abapinho.com/2016/10/find-everything-at-once/</guid><description>&lt;p>O editor de ABAP tem sempre coisas novas para descobrir.&lt;/p>
&lt;p>Quando faço CTRL-F para pesquisar texto a opção que costumo usar é a Continuar proc.&lt;/p></description></item><item><title>As APPEND STRUCTUREs fazem mais do que eu pensava</title><link>https://abapinho.com/2016/10/append-structures-do-more-stuff-than-i-thought/</link><pubDate>Mon, 17 Oct 2016 09:00:06 +0000</pubDate><guid>https://abapinho.com/2016/10/append-structures-do-more-stuff-than-i-thought/</guid><description>&lt;p>Toda a minha vida ABAPiana usei APPEND STRUCTURES para adicionar campos extra a tabelas standard.&lt;/p>
&lt;p>Mas aprendi recentemente que afinal servem para mais duas coisas:&lt;/p></description></item><item><title>Pesquisa métodos, atributos, tipos, eventos, etc</title><link>https://abapinho.com/2016/08/pesquisa-metodos-atributos-tipos-eventos-etc/</link><pubDate>Wed, 24 Aug 2016 09:00:51 +0000</pubDate><guid>https://abapinho.com/2016/08/pesquisa-metodos-atributos-tipos-eventos-etc/</guid><description>Sabes que há uns anos atrás fizeste um método qualquer cujo nome tinha a palavra MALMEQUER. Mas, e agora? Como é que o encontras?
Poderias usar a transacção SE24 para pesquisar uma a uma todas as classes alteradas por ti. Mas eras capaz de demorar algum tempo. Não faças isso.
Experimenta antes usar a transacção SE84:</description></item><item><title>Mais uma forma de ver os parâmetros de um método</title><link>https://abapinho.com/2016/08/ver-parametros-metodo/</link><pubDate>Mon, 01 Aug 2016 09:00:26 +0000</pubDate><guid>https://abapinho.com/2016/08/ver-parametros-metodo/</guid><description>&lt;p>Imagina que queres chamar um método mas não sabem quais os seus parâmetros. O que fazes?&lt;/p>
&lt;p>Dantes tinhas de usar o &lt;em>pattern&lt;/em> ou então abrir a classe numa janela ao lado para ver os parametros do método. Depois apareceu o &lt;em>&lt;a href="https://abapinho.com/2014/09/modelo-automatico-so-com-ctrl-space/">auto-complete&lt;/a>&lt;/em> e tornou tudo mais simples.&lt;/p>
&lt;p>Mas há ainda outra forma.&lt;/p></description></item><item><title>Pesquisa incremental</title><link>https://abapinho.com/2016/07/pesquisa-incremental/</link><pubDate>Mon, 18 Jul 2016 09:00:21 +0000</pubDate><guid>https://abapinho.com/2016/07/pesquisa-incremental/</guid><description>&lt;p>Quando quero procurar uma determinada palavra num programa ABAP normalmente uso a função de pesquisa carregando em CTRL-F. E depois vou carregando em NEXT para ir encontrando as várias ocorrências da palavra que procuro.&lt;/p>
&lt;p>Mas há outra forma. E não é melhor nem pior. É simplesmente diferente: a pesquisa incremental.&lt;/p></description></item><item><title>Passar tabelas internas por valor é bom</title><link>https://abapinho.com/2016/07/passar-tabelas-internas-valor-bom/</link><pubDate>Mon, 11 Jul 2016 09:00:21 +0000</pubDate><guid>https://abapinho.com/2016/07/passar-tabelas-internas-valor-bom/</guid><description>&lt;p>Quando um método devolve um valor como RETURNING este é sempre passado por valor e não por referência. Muitas vezes faço métodos que devolvem tabelas internas, algumas bastante grandes. Mas sempre me preocupou a ideia de que, como está a ser devolvida por valor, o ABAP devolva uma cópia da tabela interna, algo que pode ter impacto na performance e na memória que o programa gasta.&lt;/p>
&lt;p>Felizmente fiquei recentemente a saber que não é assim.&lt;/p></description></item><item><title>INSERT dbtab ACCEPTING DUPLICATE KEYS</title><link>https://abapinho.com/2016/07/insert-dbtab-accepting-duplicate-keys/</link><pubDate>Thu, 07 Jul 2016 09:00:10 +0000</pubDate><guid>https://abapinho.com/2016/07/insert-dbtab-accepting-duplicate-keys/</guid><description>Quando tentas inserir um registo numa tabela que já tenha outro registo com a mesma chave primária o programa faz dump. O que em alguns casos é uma chatice porque, mesmo que te estejas nas tintas, te obriga a verificar antecipadamente se aqueles chaves já existem na tabela.
Mas o ABAP prevê esses casos e dá-te uma solução:
INSERT dbtab FROM TABLE itab [ACCEPTING DUPLICATE KEYS]. Não te preocupes que quando acrescentas o ACCEPTING DUPLICATE KEYS não violas a primeira lei da termodinâmica: os registos não são inseridos.</description></item><item><title>Exporta e importa as configurações do ABAP Workbench</title><link>https://abapinho.com/2016/06/export-and-import-the-abap-workbench-settings/</link><pubDate>Mon, 13 Jun 2016 09:00:16 +0000</pubDate><guid>https://abapinho.com/2016/06/export-and-import-the-abap-workbench-settings/</guid><description>&lt;p>Às vezes as coisas estão mesmo debaixo do nosso nariz e não as vimos.&lt;/p>
&lt;p>No meu cliente actual trabalho com um montes de sistemas diferentes. Quando altero a configuração num deles muitas vezes, por preguiça ou esquecimento, acabo por não o fazer nos restantes.&lt;/p>
&lt;p>Mas há uma forma simples de copiar de uma só vez todas as configurações do ABAP Workbench de um sistema para outro.&lt;/p></description></item><item><title>Usa o Editor de Tela Dividida na comparação de versões</title><link>https://abapinho.com/2016/06/usa-editor-tela-dividida-na-comparacao-versoes/</link><pubDate>Mon, 06 Jun 2016 09:00:57 +0000</pubDate><guid>https://abapinho.com/2016/06/usa-editor-tela-dividida-na-comparacao-versoes/</guid><description>&lt;p>Por defeito a comparação de versões é horrível. Mostra as duas versões numa única coluna, com as diferenças destacadas, o que resulta numa grande confusão. É a coisa menos práctica de sempre.&lt;/p>
&lt;p>Mas não tem de ser assim.&lt;/p></description></item><item><title>Descobre as diferenças com a SE39</title><link>https://abapinho.com/2016/05/descobre-as-diferencas-se39/</link><pubDate>Mon, 30 May 2016 09:00:21 +0000</pubDate><guid>https://abapinho.com/2016/05/descobre-as-diferencas-se39/</guid><description>&lt;p>Estava há pouco a fazer QC a um programa que criaram chamado ZSDFAKSPE com quase 1000 linhas e nenhum comentário. Uma óbvia cópia de um programa standard chamado SDFAKSPE.&lt;/p>
&lt;p>Decidi então usar o Editor ABAP de tela dividida (Split screen editor) que está na transacção SE39. Introduzi o nome do Z e do standard e depois pude compará-los lado a lado.&lt;/p></description></item><item><title>Programar classes baseado em texto fonte</title><link>https://abapinho.com/2016/05/programar-classes-baseado-texto-fonte/</link><pubDate>Mon, 23 May 2016 11:08:44 +0000</pubDate><guid>https://abapinho.com/2016/05/programar-classes-baseado-texto-fonte/</guid><description>&lt;p>Estando habituado a programar em Java e C++, a forma como a SE24 obriga a navegar entre as várias partes de uma classe e o facto de cada método estar isolado no seu próprio include ao início fez-me muita confusão. Mas porque é que a SAP complica sempre tudo? Acabei por habituar-me.&lt;/p>
&lt;p>A dado momento a SE24 passou a permitir a opção &lt;em>Basedo em texto fonte&lt;/em> que mostra a classe e os métodos todos ligados em texto corrido. Mas por alguma razão que nunca atinei com aquilo.&lt;/p></description></item><item><title>Saltar para a tua última alteração</title><link>https://abapinho.com/2016/05/jump-to-your-last-change/</link><pubDate>Wed, 18 May 2016 15:03:12 +0000</pubDate><guid>https://abapinho.com/2016/05/jump-to-your-last-change/</guid><description>&lt;p>Imagina que estás a mexer num programa daqueles antigos que têm milhares de linhas (sim porque hoje em dia sabes que não modularizar é errado (pecado mesmo) e os teus métodos (sim porque hoje tu já só usas métodos) nunca passam das 200 linhas).&lt;/p></description></item><item><title>Eu chamo-te e tu chamas-me</title><link>https://abapinho.com/2016/05/i-call-you-and-you-call-me/</link><pubDate>Mon, 09 May 2016 18:36:30 +0000</pubDate><guid>https://abapinho.com/2016/05/i-call-you-and-you-call-me/</guid><description>&lt;p>Quando chamas uma função por RFC tens de lhe dar a RFC DESTINATION do sistema remoto:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">CALL FUNCTION&lt;/span> &lt;span style="color:#f00">‘&lt;/span>&lt;span style="color:#000">ZESPIRREI&lt;/span>&lt;span style="color:#f00">’&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#000">DESTINATION&lt;/span> &lt;span style="color:#f00">’&lt;/span>&lt;span style="color:#000">sistema_longe_daqui&lt;/span>&lt;span style="color:#f00">’&lt;/span>.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>E se, por alguma razão, precisares que a função que corre no sistema remoto chame uma função no sistema original. Sabes fazê-lo?&lt;/p></description></item><item><title>Desfazer alterações no ecrã do depurador</title><link>https://abapinho.com/2016/05/debugger-layout-undo/</link><pubDate>Mon, 02 May 2016 09:00:56 +0000</pubDate><guid>https://abapinho.com/2016/05/debugger-layout-undo/</guid><description>&lt;p>Embora uma parte substancial do trabalho de um ABAPador seja depurar código, a maior parte dos ABAPadores que eu conheço investem muito pouco em explorar a ferramenta que o permite, o depurador. Talvez por terem passado anos a aturar um depurador arcaico e limitado. Mas o novo pode fazer muito mais do que lhe costuma ser pedido. E o Abapinho vai tentar ensinar como.&lt;/p>
&lt;p>Hoje ensina-te apenas uma pequena tecla.&lt;/p></description></item><item><title>Dar passos de bebé no debug</title><link>https://abapinho.com/2016/04/debugging-with-baby-steps/</link><pubDate>Mon, 25 Apr 2016 09:00:50 +0000</pubDate><guid>https://abapinho.com/2016/04/debugging-with-baby-steps/</guid><description>&lt;p>Quando fazes &lt;em>debug&lt;/em> usas a tecla F5 para avançar para a próxima instrução (ou entrar para dentro de uma sub-rotina). Mas imagina um IF com várias condições:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">IF&lt;/span> &lt;span style="color:#000">A&lt;/span> = &lt;span style="color:#3af">1&lt;/span> &lt;span style="color:#00f">AND&lt;/span> &lt;span style="color:#000">B&lt;/span> = &lt;span style="color:#3af">2&lt;/span> &lt;span style="color:#00f">AND&lt;/span> &lt;span style="color:#000">C&lt;/span> = &lt;span style="color:#3af">3&lt;/span>.
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#00f">WRITE&lt;/span> &lt;span style="color:#5a2">&amp;#39;Gosto da palavra glauco&amp;#39;&lt;/span>.
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">ENDIF&lt;/span>.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>Ao fazeres &lt;em>debug&lt;/em> àquele IF com F5 e alguma das expressões for falsa saltas logo para fora do IF e ficas sem saber qual delas falhou.&lt;/p>
&lt;p>Mas o novo &lt;em>debugger&lt;/em> tem uma nova funcionalidade muito catita que te pode ajudar a entender melhor o que aconteceu ali.&lt;/p></description></item><item><title>O SAP ajuda-te a traduzir para qualquer lingua</title><link>https://abapinho.com/2016/04/sap-ajuda-te-traduzir-lingua/</link><pubDate>Mon, 18 Apr 2016 09:00:16 +0000</pubDate><guid>https://abapinho.com/2016/04/sap-ajuda-te-traduzir-lingua/</guid><description>Volta não volta encontro mais uma virtude escondida do SAP. Então não é que fiquei a saber que existe uma transacção em que podemos introduzir uma determinada palavra numa determinada lingua e o SAP ajuda-nos a traduzi-la para outra lingua qualquer mostrando-nos noutras traduções que já existam para essa mesma palavra.
Não é fixe? Ok, não é o Google Translate, mas é uma bela ajuda.
Ah, já me esquecia, a transacção chama-se STERM.</description></item><item><title>SQL nativo</title><link>https://abapinho.com/2016/03/native-sql/</link><pubDate>Mon, 28 Mar 2016 09:00:01 +0000</pubDate><guid>https://abapinho.com/2016/03/native-sql/</guid><description>&lt;p>Por vezes o SQL do ABAP não te permite fazer coisas que conseguirias fazer usando SQL nativo da base de dados. É possível fazê-lo.&lt;/p></description></item><item><title>Corrigir erro em código standard com enhancement implícito</title><link>https://abapinho.com/2016/03/corrigir-erro-em-codigo-standard-com-enhancement-implicito/</link><pubDate>Mon, 14 Mar 2016 09:00:57 +0000</pubDate><guid>https://abapinho.com/2016/03/corrigir-erro-em-codigo-standard-com-enhancement-implicito/</guid><description>Descobriste um bug num FORM (ou Função ou método) standard:
FORM EQUAL_VALUE CHANGING W_DATE TYPE SYDATUM. W_DATE = SY-DATUM - 1. ENDFORM. Reportaste o erro à SAP mas eles ainda devem demorar a responder e tu precisas da correcção urgentemente.
Tens de agir.
Sem demora usas o enhancement implícito do início do código para substituir o código original pelo teu (até a correcção chegar, claro):
FORM EQUAL_VALUE CHANGING W_DATE TYPE SYDATUM.</description></item><item><title>Inibe o histórico de valores para um só campo</title><link>https://abapinho.com/2016/02/inibe-o-historico-de-valores-para-um-so-campo/</link><pubDate>Mon, 08 Feb 2016 09:00:08 +0000</pubDate><guid>https://abapinho.com/2016/02/inibe-o-historico-de-valores-para-um-so-campo/</guid><description>&lt;p>Normalmente o SapGUI memoriza os últimos valores introduzidos em cada campo. E isso costuma ser bom. Mas podes muito bem não querer que isto aconteça. (ex: no caso, improvável eu sei, de quereres introduzir valores pornográficos num determinado campo). Uma hipótese é desligar globalmente esta funcionalidade nas configurações do SapGUI.&lt;/p>
&lt;p>Mas e se quiseres desligar apenas num campo? O Abapinho ensina-te.&lt;/p></description></item><item><title>Acrescenta parâmetros a métodos e funções standard</title><link>https://abapinho.com/2016/02/acrescenta-parametros-a-metodos-e-funcoes-standard/</link><pubDate>Mon, 01 Feb 2016 09:00:50 +0000</pubDate><guid>https://abapinho.com/2016/02/acrescenta-parametros-a-metodos-e-funcoes-standard/</guid><description>&lt;p>Todos conhecemos as ampliações implícitas da SAP, que permitem adicionar código no início ou final qualquer blocos de código standard (funções, métodos, etc.). Já todos as usámos para alterar uma BAPI ou outro código standard qualquer.&lt;/p>
&lt;p>Mas só há pouco tempo é que descobri que também é possível usar ampliações implícitas para acrescentar parâmetros a funções e métodos ABAP standard.&lt;/p></description></item><item><title>ZTOAD - Editor de SQL</title><link>https://abapinho.com/2016/02/ztoad-editor-de-sql/</link><pubDate>Mon, 01 Feb 2016 09:00:10 +0000</pubDate><guid>https://abapinho.com/2016/02/ztoad-editor-de-sql/</guid><description>O Toad é uma ferramenta muito famosa no mundo SQL que permite construir e executar queries SQL de forma fácil e interactiva. E agora, graças ao senhor Sébastien HERMANN, o SAP tem uma versão simplificada desta ferramenta maravilha.
Ele explica.
Obrigado Sérgio Fraga por descobrires isto.
O Abapinho saúda-vos.</description></item><item><title>Programa a programação dos programas</title><link>https://abapinho.com/2016/01/programa-a-programacao-dos-programas/</link><pubDate>Mon, 18 Jan 2016 09:00:47 +0000</pubDate><guid>https://abapinho.com/2016/01/programa-a-programacao-dos-programas/</guid><description>&lt;p>Uma das coisas que distingue o homem dos restantes animais é o facto de ser capaz de pensar o pensamento.&lt;/p>
&lt;p>Um pardal pode pensar &lt;em>estou assustado, vou dizer piu piu piu&lt;/em> e, como consequência, quem estiver ao pé dele ouve &lt;em>piu piu piu&lt;/em>.&lt;/p></description></item><item><title>Utilizar a lista de utilizações programaticamente</title><link>https://abapinho.com/2016/01/utilizar-a-lista-de-utilizacoes-programaticamente/</link><pubDate>Mon, 11 Jan 2016 09:00:11 +0000</pubDate><guid>https://abapinho.com/2016/01/utilizar-a-lista-de-utilizacoes-programaticamente/</guid><description>&lt;p>A ferramenta &amp;ldquo;lista de utilizações&amp;rdquo; é uma das mais queridas de um programador ABAP. Através dela conseguimos saber onde é que um objecto é utilizado. Parece pouco mas sabemos que é muito.&lt;/p></description></item><item><title>A classe CL_GUI_FRONTEND_SERVICES</title><link>https://abapinho.com/2016/01/a-classe-cl_gui_frontend_services/</link><pubDate>Mon, 04 Jan 2016 09:00:43 +0000</pubDate><guid>https://abapinho.com/2016/01/a-classe-cl_gui_frontend_services/</guid><description>&lt;p>A classe CL_GUI_FRONTEND_SERVICES é frequentemente usada para fazer &lt;em>upload&lt;/em> e &lt;em>download&lt;/em> de ficheiros de e para o computador local. Mas ela consegue fazer muitos mais coisas boas. Por exemplo:&lt;/p></description></item><item><title>O SAP sabe tirar &lt;i>selfies&lt;/i>!</title><link>https://abapinho.com/2015/12/o-sap-sabe-tirar-selfies/</link><pubDate>Mon, 28 Dec 2015 09:00:35 +0000</pubDate><guid>https://abapinho.com/2015/12/o-sap-sabe-tirar-selfies/</guid><description>&lt;p>Acabei de descobrir que o SAP consegue tirar selfies. Ainda não estou a ver para que é que isto possa servir. Mas não é grave porque na verdade também nunca vi para que é que servem as selfies tiradas por nós os humanos.&lt;/p>
&lt;p>Faz-se assim:&lt;/p></description></item><item><title>Nunca te lembras do código ASCII do CR_LF e seus amigos?</title><link>https://abapinho.com/2015/12/nunca-te-lembras-do-codigo-ascii-do-cr_lf-e-seus-amigos/</link><pubDate>Mon, 21 Dec 2015 09:00:56 +0000</pubDate><guid>https://abapinho.com/2015/12/nunca-te-lembras-do-codigo-ascii-do-cr_lf-e-seus-amigos/</guid><description>&lt;p>Eu também não.&lt;/p>
&lt;p>Nem quero lembrar-me. Para quê gastar memória com códigos obtusos?&lt;/p>
&lt;p>E não é preciso porque o ABAP tem uma classe que ajuda.&lt;/p></description></item><item><title>SELECT de um conjunto de valores conhecidos</title><link>https://abapinho.com/2015/12/select-de-um-conjunto-de-valores-conhecidos/</link><pubDate>Mon, 14 Dec 2015 09:00:36 +0000</pubDate><guid>https://abapinho.com/2015/12/select-de-um-conjunto-de-valores-conhecidos/</guid><description>&lt;p>Pedem-te para seleccionares registos cujo critério é um conjunto de meia dúzia de códigos que são conhecidos e nunca vão mudar. Sabias que podes fazer tudo logo no SELECT?&lt;/p></description></item><item><title>Podes gravar variantes na SE16N</title><link>https://abapinho.com/2015/12/podes-gravar-variantes-na-se16n/</link><pubDate>Mon, 07 Dec 2015 09:00:18 +0000</pubDate><guid>https://abapinho.com/2015/12/podes-gravar-variantes-na-se16n/</guid><description>E pronto, está dada a dica. Esteve sempre debaixo do teu nariz mas provavelmente nunca pensaste nisso: é possível gravar variantes na SE16N. E até podem ser específicas por utilizador. Algo tão práctico e no entanto tão pouco conhecido.
Obrigado Sérgio Fraga pela dica. Obrigado Cloudtail pela foto.
O Abapinho saúda-vos.</description></item><item><title>Limitar execução em background ou foreground</title><link>https://abapinho.com/2015/11/limitar-execucao-em-background-ou-foreground/</link><pubDate>Mon, 30 Nov 2015 09:00:36 +0000</pubDate><guid>https://abapinho.com/2015/11/limitar-execucao-em-background-ou-foreground/</guid><description>&lt;p>Desenvolveste um report que sabes que demora 12 horas a correr. Por isso não queres que ninguém tente corrê-lo em &lt;em>foreground&lt;/em>. Vou mostrar-te uma forma de garantires que isso não acontece.&lt;/p></description></item><item><title>Formata as variáveis ao concatenar strings com &lt;i>pipes&lt;/i></title><link>https://abapinho.com/2015/11/formata-as-variaveis-ao-concatenar-strings-com-pipes/</link><pubDate>Mon, 16 Nov 2015 09:00:22 +0000</pubDate><guid>https://abapinho.com/2015/11/formata-as-variaveis-ao-concatenar-strings-com-pipes/</guid><description>&lt;p>A nova moda em &lt;em>strings&lt;/em> é usar &lt;em>pipes&lt;/em>. Tipo:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#000">str&lt;/span> = |&lt;span style="color:#5a2">Olá &lt;/span>{ &lt;span style="color:#000">sy&lt;/span>-&lt;span style="color:#000">uname&lt;/span> }&lt;span style="color:#5a2">, &lt;/span>| &amp;amp;
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> |&lt;span style="color:#5a2">a data de hoje é &lt;/span>{ &lt;span style="color:#000">sy&lt;/span>-&lt;span style="color:#000">datum&lt;/span> }&lt;span style="color:#5a2">.&lt;/span>|.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>Além de ter pinta é muito mais práctico do que usar o CONCATENATE que é horrível.&lt;/p>
&lt;p>Mas o que eu só descobri recentemente é que é possível aplicar formatação às variáveis:&lt;/p></description></item><item><title>O GUI está disponível?</title><link>https://abapinho.com/2015/11/o-gui-esta-disponivel/</link><pubDate>Mon, 09 Nov 2015 09:00:41 +0000</pubDate><guid>https://abapinho.com/2015/11/o-gui-esta-disponivel/</guid><description>&lt;p>Para verificar se um programa está em &lt;em>background&lt;/em> é costume espreitar a variável de sistema SY-BATCH. A SY-BINPT também pode ser usada para verificar se o que está a correr em &lt;em>background&lt;/em> é uma sessão de BDC. Normalmente usa-se uma destas duas.&lt;/p>
&lt;p>Mas há uma pergunta parecida e no entanto diferente. Como fazes para saber se o GUI está disponível? É certo que na maior parte dos casos o resultado é semelhante, mas não o será em todos.&lt;/p>
&lt;p>É como dizer que de dia há o sol e de noite há a lua. Se o ceu estiver nublado não há nem sol de dia nem lua de noite.&lt;/p></description></item><item><title>Como evitar &lt;i>timeout&lt;/i> ao correr um programa</title><link>https://abapinho.com/2015/11/como-evitar-timeout-ao-correr-um-programa/</link><pubDate>Mon, 02 Nov 2015 09:00:52 +0000</pubDate><guid>https://abapinho.com/2015/11/como-evitar-timeout-ao-correr-um-programa/</guid><description>&lt;p>Normalmente os sistemas SAP têm definido um tempo limite para que um programa possa correr interactivamente. Se o programa demorar mais ocorre um erro de execução (vulgo &lt;em>dump&lt;/em> ).&lt;/p></description></item><item><title>Atalhos para fazer letras grandes e pequenas</title><link>https://abapinho.com/2015/10/letras-grandes-e-letras-pequeninas/</link><pubDate>Mon, 19 Oct 2015 09:00:05 +0000</pubDate><guid>https://abapinho.com/2015/10/letras-grandes-e-letras-pequeninas/</guid><description>Podes nem sequer saber programar mas se souberes datilografar rápido e conheceres muitos atalhos de teclado vais parecer super profissional.
No editor escreve a seguinte palavra: chichisbéu
Agora experimenta nos seguintes atalhos:
CTRL+U: CHICHISBÉU LETRAS GRANDES! MAIÚSCULAS! CTRL+L: chichisbéu letras minúsculas! minúsculas! CTRL+J: Chichisbéu A Primeira Letra De CaDa PaLaVrA É mAiÚsCuLa! CTRL+K: cHICHISBÉU O gRaNdE fIcOu PeQuEnO e ViCe-VeRsA!
Obrigado José Vília pela dica.
Obrigado Chris pela foto.
O Abapinho saúda-vos.</description></item><item><title>SE16H - Agrega dados sem precisares do Excel</title><link>https://abapinho.com/2015/10/se16h-agrega-dados-sem-precisares-do-excel/</link><pubDate>Mon, 12 Oct 2015 09:00:57 +0000</pubDate><guid>https://abapinho.com/2015/10/se16h-agrega-dados-sem-precisares-do-excel/</guid><description>&lt;p>No início dos tempos usava-se a transacção SE17 para ver o conteúdo de tabelas.
Rapidamente sentiram vergonha e decidiram fazer uma coisa melhorzinha a que chamaram SE16.
Depois inventaram a ALV e surgiu a SE16N (e muita gente continuou até hoje a usar a SE16, algo que me ultrapassa).&lt;/p>
&lt;p>Hoje apresento-vos a SE16H.&lt;/p></description></item><item><title>CONCATENATE LINES OF itbl</title><link>https://abapinho.com/2015/10/concatenate-lines-of-itbl/</link><pubDate>Mon, 05 Oct 2015 09:00:50 +0000</pubDate><guid>https://abapinho.com/2015/10/concatenate-lines-of-itbl/</guid><description>&lt;p>Se queres serializar um conjunto de &lt;em>strings&lt;/em> que tens guardadas numa tabela interna tens duas formas de o fazer. Uma ranhosa e outra cheia de estilo.&lt;/p></description></item><item><title>Modificar uma campo em todas as linhas de tabela interna</title><link>https://abapinho.com/2015/08/modificar-uma-campo-em-todas-as-linhas-de-uma-tabela-interna/</link><pubDate>Mon, 31 Aug 2015 09:00:25 +0000</pubDate><guid>https://abapinho.com/2015/08/modificar-uma-campo-em-todas-as-linhas-de-uma-tabela-interna/</guid><description>&lt;p>O que vos vou mostrar não é propriamente uma novidade. Até &lt;a href="https://abapinho.com/2011/07/range-instantaneo/">já foi usado antes&lt;/a> no Abapinho. Mas como se continua a ver por aí muita gente a fazer LOOPs a tabelas internas para alterar um campo, achei que valia a pena recordar.&lt;/p></description></item><item><title>O READ TABLE vai desaparecer!</title><link>https://abapinho.com/2015/08/o-read-table-vai-desaparecer/</link><pubDate>Mon, 24 Aug 2015 09:00:20 +0000</pubDate><guid>https://abapinho.com/2015/08/o-read-table-vai-desaparecer/</guid><description>Pré 7.4:
DATA l_idade type i. READ TABLE lt_gente INTO ls_gente WITH KEY nome = l_nome. l_idade = ls_gente-idade. Pós 7.4:
data(l_idade) = lt_gente[ nome = l_nome ]-idade. Obrigado Sérgio Fraga pela dica.
O Abapinho saúda-vos.</description></item><item><title>Tanta coisa nova no 7.4 que não sei por onde começar</title><link>https://abapinho.com/2015/08/tanta-coisa-nova-no-7-4-que-nao-sei-por-onde-comecar/</link><pubDate>Wed, 19 Aug 2015 09:00:19 +0000</pubDate><guid>https://abapinho.com/2015/08/tanta-coisa-nova-no-7-4-que-nao-sei-por-onde-comecar/</guid><description>O Abapinho vai lentamente começar a dar dicas específicas para o AS ABAP 7.4. Lentamente porque ainda são poucas as pessoas com acesso a esse sistema. Mas são tantas as novidades que dá vontade de começar a fazê-lo rapidamente.
O ABAP era um gajo de meia idade com barriga e todo flácido. Fizeram-lhe uma operação plástica e agora parece ter 20 anos e montes de músculos, capaz de ir sair à noite até às 9 da manhã, beber 7 gins tónicos e a seguir, antes de se ir deitar, fazer 100 burpees só para adormecer melhor.</description></item><item><title>Breakpoint em mensagem a partir do depurador</title><link>https://abapinho.com/2015/08/breakpoint-em-mensagem-a-partir-do-depurador/</link><pubDate>Mon, 10 Aug 2015 09:00:09 +0000</pubDate><guid>https://abapinho.com/2015/08/breakpoint-em-mensagem-a-partir-do-depurador/</guid><description>&lt;p>Já estás a meio de um debug e queres que a execução pare numa determinada mensagem.&lt;/p>
&lt;p>O que fazer?&lt;/p></description></item><item><title>Múltiplas selecções OR na SE16N</title><link>https://abapinho.com/2015/08/multiplas-seleccoes-or-na-se16n/</link><pubDate>Mon, 03 Aug 2015 09:00:15 +0000</pubDate><guid>https://abapinho.com/2015/08/multiplas-seleccoes-or-na-se16n/</guid><description>&lt;p>Se tu és daquelas pessoas que ainda usa a SE16, este artigo não é para ti. Se continuares a ler corres o risco de encontrar ainda mais uma razão para finalmente passares a usar a SE16N (como se todas as outras não fossem já suficientes).&lt;/p>
&lt;p>Imagina que queres seleccionar todos os materiais que tenham “PREGO&amp;quot; no nome e que sejam do tipo FERRAGENS e além disso todos os materiais que tenham “GUARDANAPO&amp;quot; no nome e que sejam do tipo COMIDA. Ou seja, não deverá aparecer o “PREGO_NO_PAO” nem o “GARDANAPO_PAPEL”. O que tu queres é isto (faz de conta):&lt;/p>
&lt;p>(MATNR = “PREGO%” AND MTART = “FERR” ) OR (MATNR = “GUARDANAPO%” AND MAKT = “COMI” )&lt;/p>
&lt;p>Como bem sabes, numa utilização normal (sem recorrer a isto que te vou mostrar) da SE16N terias de a executar duas vezes e cruzar manualmente a informação porque o ecrã de selecção não dá para fazer ORs.&lt;/p>
&lt;p>Ou dá?&lt;/p></description></item><item><title>CASE dentro de SELECT (brevemente em todos os SAPs)</title><link>https://abapinho.com/2015/07/case-dentro-de-select-brevemente-em-todos-os-saps/</link><pubDate>Mon, 20 Jul 2015 09:00:42 +0000</pubDate><guid>https://abapinho.com/2015/07/case-dentro-de-select-brevemente-em-todos-os-saps/</guid><description>Prepara-te porque em breve terás muitas surpresas. É que o ABAP está a aprender troques novos. Repara neste:
CONSTANTS: lc_menina TYPE STRING VALUE ‘MENINA&amp;#39;, lc_menino TYPE STRING VALUE ‘MENINO’, lc_senhor TYPE STRING VALUE ’SENHOR’, lc_senhora TYPE STRING VALUE ‘SENHORA’. SELECT nome, CASE WHEN sexo_id = ‘M&amp;#39; AND idade &amp;lt; 18 THEN @lc_menino WHEN sexo_id = ‘F’ AND idade &amp;lt; 18 THEN @lc_menina WHEN sexo_id = ‘M&amp;#39; AND idade &amp;gt;=18 THEN @lc_senhor WHEN sexo_id = ‘F’ AND idade &amp;gt;=18 THEN @lc_senhora END AS titulo FROM zpessoa WHERE pessoa_id = @pessoa_id INTO CORRESPONDING FIELDS OF @lt_pessoas.</description></item><item><title>Procura notas directamente no Google Chrome</title><link>https://abapinho.com/2015/07/procura-notas-directamente-no-google-chrome/</link><pubDate>Mon, 13 Jul 2015 09:00:20 +0000</pubDate><guid>https://abapinho.com/2015/07/procura-notas-directamente-no-google-chrome/</guid><description>O Google Chrome tem uma app para pesquisar notas SAP de forma integrada. Chama-se SAP Notes finder.
Instala-se aqui.
Obrigado Fernanda Mirabile e Talita Polanczyk pela dica.
O Abapinho saúda-vos.</description></item><item><title>CALL FUNCTION com DESTINATION ‘NONE' cria nova LUW</title><link>https://abapinho.com/2015/06/call-function-com-destination-none-cria-nova-luw/</link><pubDate>Mon, 22 Jun 2015 09:00:57 +0000</pubDate><guid>https://abapinho.com/2015/06/call-function-com-destination-none-cria-nova-luw/</guid><description>Sabias que quando invocas uma função com a opção DESTINATION ‘NONE’ estás a iniciar uma nova LUW?
Isto pode parecer apenas uma curiosidade, mas há um caso em que pode fazer toda a diferença: sabes aqueles módulos de função que ao serem chamados uma segunda vez têm um comportamento diferente da primeira vez? Isto acontece porque eles hão-de ter alterado alguma variável global ao grupo de funções. Ora se iniciares uma nova LUW quando chamares a função, o seu grupo de funções é automaticamente inicializado e assim garantes que o comportamento da função é o esperado.</description></item><item><title>Debug de um job</title><link>https://abapinho.com/2015/06/debug-de-um-job/</link><pubDate>Mon, 15 Jun 2015 09:00:40 +0000</pubDate><guid>https://abapinho.com/2015/06/debug-de-um-job/</guid><description>&lt;p>Para fazeres &lt;em>debug&lt;/em> a um programa que faça parte de um &lt;em>job&lt;/em> faz o seguinte:&lt;/p></description></item><item><title>Como perguntar se a linha existe sem parecer antiquado</title><link>https://abapinho.com/2015/04/como-perguntar-se-a-linha-existe-sem-parecer-antiquado/</link><pubDate>Mon, 06 Apr 2015 14:08:12 +0000</pubDate><guid>https://abapinho.com/2015/04/como-perguntar-se-a-linha-existe-sem-parecer-antiquado/</guid><description>&lt;p>Há muito tempo atrás dizias &amp;ldquo;porreiro pá&amp;rdquo;. Depois começaste a dizer &amp;ldquo;baril&amp;rdquo;. Depois era &amp;ldquo;fixe&amp;rdquo;. Hoje dizes &amp;ldquo;altamente&amp;rdquo;. É importante não te baralhares para não dares mau aspecto.&lt;/p>
&lt;p>E como perguntas a uma tabela interna se a linha existe?&lt;/p></description></item><item><title>Calem-se as mensagens das funções</title><link>https://abapinho.com/2015/03/calem-se-as-mensagens-das-funcoes/</link><pubDate>Mon, 30 Mar 2015 09:00:30 +0000</pubDate><guid>https://abapinho.com/2015/03/calem-se-as-mensagens-das-funcoes/</guid><description>&lt;p>Há módulos de função standard que lançam mensagens e não deviam. Não deviam porque depois queremos usá-las em programas não interactivos e, em vez de devolverem o erro, atiram com uma mensagem para o ecrã que dá cabo do processo.&lt;/p>
&lt;p>Mas, provavelmente por ter tomado consciência deste problema, a SAP disponibilizou uma forma elegante (mas muito mal documentada) de resolver o problema.&lt;/p></description></item><item><title>Fazer debug a um ciclo infinito já em execução</title><link>https://abapinho.com/2015/03/fazer-debug-a-um-ciclo-infinito-ja-em-execucao/</link><pubDate>Mon, 02 Mar 2015 09:00:22 +0000</pubDate><guid>https://abapinho.com/2015/03/fazer-debug-a-um-ciclo-infinito-ja-em-execucao/</guid><description>&lt;p>Imagina que tens um programa a executar um ciclo infinito ou, pelo menos, um ciclo com 70x7 iterações. Nunca mais acaba e tu queres saber o que lá se passa.&lt;/p>
&lt;p>No passado tinhas de ir à SM50, seleccionar o processo e escolher no menu &amp;ldquo;Administração | Programa | Depuração&amp;rdquo;.&lt;/p>
&lt;p>Mas agora há uma forma muito mais simples.&lt;/p></description></item><item><title>De quantos includes é feita uma classe?</title><link>https://abapinho.com/2015/02/de-quantos-includes-e-feita-uma-classe/</link><pubDate>Mon, 23 Feb 2015 09:00:55 +0000</pubDate><guid>https://abapinho.com/2015/02/de-quantos-includes-e-feita-uma-classe/</guid><description>&lt;p>Por muitas voltas que eles dêem no ABAP, acaba tudo por ir dar à SE38. Até os métodos das classes ABAP são guardados em includes.&lt;/p>
&lt;p>Às vezes quando há um dump diz que o problema está, por exemplo, aqui: CL_MESSAGE_HELPER=============CM001.&lt;/p></description></item><item><title>Tornar a prender uma ordem de transporte liberada</title><link>https://abapinho.com/2015/02/tornar-a-prender-uma-ordem-de-transporte-liberada/</link><pubDate>Mon, 16 Feb 2015 09:00:51 +0000</pubDate><guid>https://abapinho.com/2015/02/tornar-a-prender-uma-ordem-de-transporte-liberada/</guid><description>&lt;p>Liberaste uma ordem de transporte porque achavas que estava tudo pronto. Mas afinal ainda faltava fazer mais uma pequena modificação. E agora vais ter de criar uma nova ordem e transportar as duas. Que grande chatice.&lt;/p>
&lt;p>Calma.&lt;/p></description></item><item><title>Pré-definir SELECT-OPTIONs</title><link>https://abapinho.com/2015/02/pre-definir-select-options/</link><pubDate>Mon, 09 Feb 2015 09:00:23 +0000</pubDate><guid>https://abapinho.com/2015/02/pre-definir-select-options/</guid><description>&lt;p>O Abapinho recebeu uma carta.&lt;/p>
&lt;p>Sr Abapinho,&lt;/p>
&lt;p>Todos sabemos como colocar valores por defeito em select options usando o comando DEFAULT. O que nem toda a gente sabe é que podemos também definir por defeito a opção e o sinal e mesmo o botão para restingir o select options.&lt;/p></description></item><item><title>Ignorar excepções de um módulo de função</title><link>https://abapinho.com/2015/01/ignorar-excepcoes-de-um-modulo-de-funcao/</link><pubDate>Mon, 26 Jan 2015 09:00:25 +0000</pubDate><guid>https://abapinho.com/2015/01/ignorar-excepcoes-de-um-modulo-de-funcao/</guid><description>&lt;p>Quando chamas um módulo de função que devolve excepções normalmente dás-lhes números sequenciais tipo isto:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">CALL FUNCTION&lt;/span> &lt;span style="color:#5a2">&amp;#39;VAI_ALI_MAS_VOLTA&amp;#39;&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#00f">EXPORTING&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#000">ali&lt;/span> = &lt;span style="color:#5a2">&amp;#39;Barreiro&amp;#39;&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#00f">EXCEPTIONS&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#000">NOT_FOUND&lt;/span> = &lt;span style="color:#3af">1&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#000">GOT_LOST&lt;/span> = &lt;span style="color:#3af">2&lt;/span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span> &lt;span style="color:#00f">OTHERS&lt;/span> = &lt;span style="color:#3af">3&lt;/span>.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>Mas se a seguir não tiveres o cuidado de ter um IF ou um CASE a olharem para o SY-SUBRC o Code Inspector pode devolve-te um erro caso esteja configurado para tal.&lt;/p></description></item><item><title>Concatenemos</title><link>https://abapinho.com/2015/01/concatenemos/</link><pubDate>Mon, 05 Jan 2015 09:00:35 +0000</pubDate><guid>https://abapinho.com/2015/01/concatenemos/</guid><description>&lt;p>Temos duas variáveis:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">DATA&lt;/span> &lt;span style="color:#000">palavra1&lt;/span> &lt;span style="color:#00f">TYPE &lt;/span>&lt;span style="color:#000">string&lt;/span>.
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">DATA&lt;/span> &lt;span style="color:#000">palavra2&lt;/span> &lt;span style="color:#00f">TYPE &lt;/span>&lt;span style="color:#000">string&lt;/span>.
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">DATA&lt;/span>: &lt;span style="color:#000">frase&lt;/span> &lt;span style="color:#00f">TYPE &lt;/span>&lt;span style="color:#000">string&lt;/span>.
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#000">palavra1&lt;/span> = &lt;span style="color:#f00">‘&lt;/span>&lt;span style="color:#000">isto&lt;/span>&lt;span style="color:#f00">’&lt;/span>.
&lt;/span>&lt;/span>&lt;span style="display:flex;">&lt;span>&lt;span style="color:#000">palavra2&lt;/span> = &lt;span style="color:#f00">‘&lt;/span>&lt;span style="color:#000">aquilo&lt;/span>&lt;span style="color:#f00">’&lt;/span>.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>
&lt;p>E queremos concatená-las metendo entre elas a palavra ‘mais’ e, claro, separando-as por espaços.&lt;/p></description></item><item><title>Escrever em muitas linhas ao mesmo tempo</title><link>https://abapinho.com/2014/12/escrever-em-muitas-linhas-ao-mesmo-tempo/</link><pubDate>Mon, 15 Dec 2014 09:00:42 +0000</pubDate><guid>https://abapinho.com/2014/12/escrever-em-muitas-linhas-ao-mesmo-tempo/</guid><description>&lt;p>O editor de ABAP tem coisas que não lembram ao diabo.
Até dá para escrever ao mesmo tempo em várias linhas.&lt;/p></description></item><item><title>Onde está o booleano?</title><link>https://abapinho.com/2014/12/onde-esta-o-booleano/</link><pubDate>Wed, 10 Dec 2014 18:12:58 +0000</pubDate><guid>https://abapinho.com/2014/12/onde-esta-o-booleano/</guid><description>&lt;p>Não está.&lt;/p>
&lt;p>Mas eles - os senhores que fazem e refazem o ABAP propriamente dito - vão tentando remediar a situação.&lt;/p>
&lt;p>Olha por exemplo esta nova funcionalidade.&lt;/p></description></item><item><title>LOOP at tbl ASSIGNING &amp;lt;linha&amp;gt; CASTING</title><link>https://abapinho.com/2014/12/loop-at-tbl-into-linha-casting/</link><pubDate>Mon, 01 Dec 2014 09:50:19 +0000</pubDate><guid>https://abapinho.com/2014/12/loop-at-tbl-into-linha-casting/</guid><description>&lt;p>Sabias que podes fazer LOOP de uma tabela interna com uma estrutura A para dentro de uma estrutura do tipo B?&lt;/p></description></item><item><title>Indentar em bloco</title><link>https://abapinho.com/2014/11/indentar-em-bloco/</link><pubDate>Mon, 03 Nov 2014 09:00:21 +0000</pubDate><guid>https://abapinho.com/2014/11/indentar-em-bloco/</guid><description>&lt;p>Para indentares um bloco de linhas só com teclas faz assim:&lt;/p></description></item><item><title>Limpar os buffers de uma sessão SAP</title><link>https://abapinho.com/2014/10/limpar-os-buffers-de-uma-sessao-sap/</link><pubDate>Mon, 13 Oct 2014 09:00:25 +0000</pubDate><guid>https://abapinho.com/2014/10/limpar-os-buffers-de-uma-sessao-sap/</guid><description>&lt;p>Todos os dias aprendo novos comandos para introduzir no campo da transacção. Hoje aprendi uns que resolvem um problema que, ainda que raramente, já me aconteceu no passado.&lt;/p>
&lt;p>Vê lá se isto já te aconteceu: fazes uma alteração a um texto de um elemento usado numa tabela que editas a partir da SM30. Mas quando vais à SM30 o texto antigo continua lá. Activas vezes sem conta, sais e entras da transacção e nada.&lt;/p></description></item><item><title>Modelo automático só com CTRL-SPACE</title><link>https://abapinho.com/2014/09/modelo-automatico-so-com-ctrl-space/</link><pubDate>Mon, 22 Sep 2014 09:00:04 +0000</pubDate><guid>https://abapinho.com/2014/09/modelo-automatico-so-com-ctrl-space/</guid><description>&lt;p>Claro que já conheces o botão “Modelo” no editor de ABAP que permite introduzir automaticamente modelos para módulos de função, chamadas a métodos e outros.&lt;/p>
&lt;p>Mas o novo editor agora cresceu um bocadinho (já só está 10 anos atrasado em relação ao Eclipse em vez de 20) e já permite completar automaticamente alguns comandos através do atalho CTRL-SPACE.&lt;/p></description></item><item><title>Desbloquear objectos numa ordem de transporte</title><link>https://abapinho.com/2014/08/desbloquear-objectos-numa-ordem-de-transporte/</link><pubDate>Mon, 25 Aug 2014 09:00:26 +0000</pubDate><guid>https://abapinho.com/2014/08/desbloquear-objectos-numa-ordem-de-transporte/</guid><description>&lt;p>Quando alteras um objecto e o guardas numa ordem de transporte ele normalmente fica bloqueado. Dentro da ordem de transporte é podes bloquear objectos que não estejam já bloqueados que não estão já bloqueados noutra ordem. Mas, uma vez bloqueados, como é que se desbloqueiam?&lt;/p></description></item><item><title>Mete-o entre parêntesis</title><link>https://abapinho.com/2014/08/mete-o-entre-parentesis/</link><pubDate>Mon, 18 Aug 2014 09:00:09 +0000</pubDate><guid>https://abapinho.com/2014/08/mete-o-entre-parentesis/</guid><description>Truquezito catita: quando na SE38 quiseres meter uma palavra ou expressão entre parêntesis ou aspas, basta seleccioná-la e carregar em ( ou [ ou &amp;lsquo;. E imediatamente isto fica (isto) ou [isto] ou &amp;lsquo;isto&amp;rsquo;.
Obrigado Sérgio Fraga pela dica.</description></item><item><title>Contemplar o pacote</title><link>https://abapinho.com/2014/07/contemplar-o-pacote/</link><pubDate>Mon, 14 Jul 2014 08:00:25 +0000</pubDate><guid>https://abapinho.com/2014/07/contemplar-o-pacote/</guid><description>&lt;p>Estás a contemplar uma classe na SE24, uma tabela na SE11 ou um programa na SE80. Agora queres ver o pacote desse objecto bem como o seu conteúdo. Até há pouco tempo eu faria assim: primeiro via nas características do objecto qual é o seu pacote, depois abria uma sessão nova, ia à SE80 e escrevia lá o pacote.&lt;/p>
&lt;p>Agora aprendi uma forma muito mais simples.&lt;/p></description></item><item><title>Descobre quem transportou uma ordem</title><link>https://abapinho.com/2014/07/descobre-quem-transportou-uma-ordem/</link><pubDate>Mon, 07 Jul 2014 08:30:15 +0000</pubDate><guid>https://abapinho.com/2014/07/descobre-quem-transportou-uma-ordem/</guid><description>&lt;p>No outro dia apareceram uma série de coisas espatifadas na nossa máquina de testes. De repente ninguém podia trabalhar na máquina. Na STMS encontrámos uma série de ordens de transporte indevidamente transportadas para lá. O utilizador que aparece associado a cada uma dessas ordens é o dono dela. Mas será que a culpa é dele? Não terá sido outra pessoa a fazer o transporte?&lt;/p>
&lt;p>Como saber?&lt;/p></description></item><item><title>Vista técnica da SE16N</title><link>https://abapinho.com/2014/06/vista-tecnica-se16n/</link><pubDate>Mon, 30 Jun 2014 09:00:43 +0000</pubDate><guid>https://abapinho.com/2014/06/vista-tecnica-se16n/</guid><description>Olá. Tudo bem? A vida? Flui? Esta dica é tão simples que mais vale conversarmos um bocado antes de eu a dizer senão nem dá para aquecer. Está sol. Choveu de manhã mas agora escampou.
Siga.
Sempre que vejo alguém a usar a SE16 pergunto-me porque é que o continua a fazer quando a SE16N é tão melhor e já existe há tanto tempo. Mas a dica não é isto.</description></item><item><title>Apagar pacotes que não querem ser apagados</title><link>https://abapinho.com/2014/06/apagar-pacotes-que-nao-querem-ser-apagados/</link><pubDate>Mon, 23 Jun 2014 08:30:48 +0000</pubDate><guid>https://abapinho.com/2014/06/apagar-pacotes-que-nao-querem-ser-apagados/</guid><description>&lt;p>Quando tentas apagar um pacote no qual já criaste objectos que entretanto apagaste e o pacote aparente estar vazio quando visto na SE80, quando o tentas apagar não dá porque diz que o pacote ainda contém objectos.&lt;/p>
&lt;p>Por alguma razão parva, a SE80 não mostra todo o tipo de objectos associados aos pacotes. Além disso, muitas vezes ao apagar um objecto a entrada desse objecto não é correctamente apagada. O SAP está cheio de falhas. Mas é o que temos, é ele que nos dá o pão, não vamos dizer muito mal dele.&lt;/p>
&lt;p>O Abapinho dá-te a solução.&lt;/p></description></item><item><title>0 é Private, 1 é Protected, 2 é Public</title><link>https://abapinho.com/2014/06/0-e-private-1-e-protected-2-e-public/</link><pubDate>Mon, 16 Jun 2014 08:30:50 +0000</pubDate><guid>https://abapinho.com/2014/06/0-e-private-1-e-protected-2-e-public/</guid><description>&lt;p>Pequeno truque para acelerar a introdução de (alguns) dados.&lt;/p></description></item><item><title>Lê os textos de um programa</title><link>https://abapinho.com/2014/06/le-os-textos-de-um-programa/</link><pubDate>Mon, 09 Jun 2014 08:30:00 +0000</pubDate><guid>https://abapinho.com/2014/06/le-os-textos-de-um-programa/</guid><description>Aqui está uma forma simples de programaticamente ter acesso aos textos de um programa qualquer.
DATA: t_textos TYPE TABLE OF textpool. READ TEXTPOOL sy-repid INTO t_textos LANGUAGE sy-langu STATE &amp;#39;A’. Agora tens os textos todos disponíveis na tabela interna T_TEXTOS.
Como se isto não bastasse, podes também alterar os textos programaticamente. Com os seguintes comandos:
INSERT TEXTPOOL sy-repid FROM t_textos LANGUAGE sy-langu. DELETE TEXTPOOL PROGRAM LANGUAGE &amp;#39;E’. A SAP diz que estes dois últimos comandos são só para uso interno.</description></item><item><title>SELECT dentro de SELECT</title><link>https://abapinho.com/2014/05/select-dentro-de-select/</link><pubDate>Mon, 26 May 2014 09:00:03 +0000</pubDate><guid>https://abapinho.com/2014/05/select-dentro-de-select/</guid><description>&lt;p>Provavelmente por razões históricas, os programadores ABAP não exploram as possibilidades do SQL. Muitos há que em vez de usarem INNER JOINs, ainda julgam que é mais rápido fazer vários SELECTs para tabelas internas e depois trabalhar os dados em ABAP. Mas a verdade é que, mesmo que se haja excepções, a regra é: quanto menos acessos à base de dados, melhor a performance. E faz sentido porque, afinal, porque foram escritas explicitamente para isso, as bases de dados relacionais são muito mais peritas em processar dados relacionais do que um programa ABAP.&lt;/p>
&lt;p>Mas claro que há coisas que, pela sua complexidade, não podem ser feitas com um simples INNER JOIN. Ainda assim, algumas dessas coisas podem ser feitas num único SELECT.&lt;/p></description></item><item><title>Obter informação sobre um sistema remoto por RFC</title><link>https://abapinho.com/2014/05/obter-informacao-sobre-um-sistema-remoto-por-rfc/</link><pubDate>Mon, 19 May 2014 09:00:16 +0000</pubDate><guid>https://abapinho.com/2014/05/obter-informacao-sobre-um-sistema-remoto-por-rfc/</guid><description>Aqui está uma funçãozinha fixe para obter alguns detalhes de um sistema remoto acessível por RFC:
RFC_SYSTEM_INFO
Não posso dar aqui nenhum exemplo porque estaria a revelar informação segreda importantíssima sobre o meu cliente que depois seria certamente utilizada pelos maus para fazerem espionagem industrial. Mas é fácil de testar na SE37.
Obrigado kingofthebigmacs pela foto.
O Abapinho saúda-vos.</description></item><item><title>Classe com montes de métodos para lidar com datas</title><link>https://abapinho.com/2014/05/classe-com-montes-de-metodos-para-lidar-com-datas/</link><pubDate>Mon, 05 May 2014 09:00:16 +0000</pubDate><guid>https://abapinho.com/2014/05/classe-com-montes-de-metodos-para-lidar-com-datas/</guid><description>&lt;p>Há inúmeras funções standard para fazer cálculos com datas. São muitas, são demais, são redundantes e, em muitos casos, são obscuras ou impossíveis de compreender. Andava há que tempos para fazer um artigo aqui com uma lista das mais úteis. Mas agora já não é preciso.&lt;/p></description></item><item><title>Faz debug a um job</title><link>https://abapinho.com/2014/04/faz-debug-a-um-job/</link><pubDate>Mon, 21 Apr 2014 09:00:23 +0000</pubDate><guid>https://abapinho.com/2014/04/faz-debug-a-um-job/</guid><description>Toma lá uma forma simples de começares a fazer debug a um job:
Vai à transacção SM37;
Clica no job a que queres fazer debug;
escreve JDBG na linha de comando (sem /) e carrega em ENTER;
e&amp;hellip; zás! estás a fazer debug ao job.
Obrigado Ricardo Monteiro pela dica. E obrigado Ingolf pela foto.
O Abapinho saúda-vos.</description></item><item><title>Atalho para viajar no tempo</title><link>https://abapinho.com/2014/04/atalho-para-viajar-no-tempo/</link><pubDate>Mon, 07 Apr 2014 09:00:35 +0000</pubDate><guid>https://abapinho.com/2014/04/atalho-para-viajar-no-tempo/</guid><description>Há uns meses atrás mostrei como transformar o debugger numa máquina do tempo.
Hoje a dica é singela mas escorreita: há um atalho de teclado para tornar ainda mais simples este viajar enviesado:
shift + F12
Pões o cursor na linha para onde queres viajar e depois&amp;hellip; shift+F12.
Obrigado Maxsuel Maia pela dica.
O Abapinho saúda-vos.</description></item><item><title>Usa um gestor de passwords na tua vida</title><link>https://abapinho.com/2014/03/gestor-de-passwords/</link><pubDate>Mon, 24 Mar 2014 09:00:52 +0000</pubDate><guid>https://abapinho.com/2014/03/gestor-de-passwords/</guid><description>&lt;p>E pronto, se leste o título, a dica está dada.&lt;/p>
&lt;p>Agora umas dicas sobre a dica:&lt;/p></description></item><item><title>Fecha a janela encalhada</title><link>https://abapinho.com/2014/03/fecha-a-janela-encalhada/</link><pubDate>Mon, 03 Mar 2014 17:30:56 +0000</pubDate><guid>https://abapinho.com/2014/03/fecha-a-janela-encalhada/</guid><description>&lt;p>Quantas vezes te aconteceu ficar com uma janela &amp;ldquo;pendurada&amp;rdquo; quando terminas um debug?&lt;/p></description></item><item><title>Exemplar exemplo de SALV</title><link>https://abapinho.com/2014/02/exemplar-exemplo-de-salv/</link><pubDate>Mon, 10 Feb 2014 09:00:25 +0000</pubDate><guid>https://abapinho.com/2014/02/exemplar-exemplo-de-salv/</guid><description>&lt;p>A não ser que queiras fazer edição dos dados, a única forma digna de usar ALVs nos dias que correm é através das classes SALV. São mais modernas, mais elegantes e permitem a quem as usa alcançar um estatuto social até aqui apenas ao alcance daqueles que são donos de uma &lt;a href="https://www.youtube.com/watch?v=JtN35OUIu0g">matrícula de carro&lt;/a>.&lt;/p></description></item><item><title>Pára lá mas não já</title><link>https://abapinho.com/2014/02/para-la-mas-nao-ja/</link><pubDate>Mon, 03 Feb 2014 09:00:56 +0000</pubDate><guid>https://abapinho.com/2014/02/para-la-mas-nao-ja/</guid><description>&lt;p>Estás a fazer um LOOP AT a uma tabela com 1000 linhas e sabes que a linha que te interessa é a 853. Até há pouco tempo tinhas duas hipóteses: ou carregavas 852 vezes na tecla F8, arriscando-te a carregar 853 e teres de começar tudo de novo ou então criavas um &lt;em>watchpoint&lt;/em> com a condição SY-TABIX = 852 ou lá perto e rezavas para que funcionasse.&lt;/p>
&lt;p>Agora tens uma terceira alternativa.&lt;/p></description></item><item><title>APPEND LINES OF classe->metodo() TO itbl</title><link>https://abapinho.com/2014/01/append-lines-of-classe-metodo-to-itbl/</link><pubDate>Mon, 27 Jan 2014 22:33:25 +0000</pubDate><guid>https://abapinho.com/2014/01/append-lines-of-classe-metodo-to-itbl/</guid><description>&lt;p>O ABAP anda cada vez mais esperto. Ainda sou do tempo em que não se fazia nada dele. E agora, lentamente, com mais de um quinto de século de atraso, lá vai tentado imitar o C e o Java e ficando mais flexível.&lt;/p>
&lt;p>Eu ia fazer algo deste tipo:&lt;/p></description></item><item><title>Teclado automático</title><link>https://abapinho.com/2014/01/teclado-automatico/</link><pubDate>Mon, 20 Jan 2014 09:00:00 +0000</pubDate><guid>https://abapinho.com/2014/01/teclado-automatico/</guid><description>&lt;p>Todos os programadores conhecem a relação íntima que há entre batch-inputs e pisa-papéis, agrafadores e outros objectos pesados do tipo. São ajudantes preciosíssimos que evitam passarmos por vezes 8 horas a empurrar uma tecla chamada ENTER com um dedo.&lt;/p>
&lt;p>Ainda que esse tipo de objectos tenha algum encanto, por vezes a lei da gravidade - a mesma que os torna úteis - fá-los cair para o lado e pararem assim de pressionar a tal tecla chamada ENTER.&lt;/p></description></item><item><title>Adicionar valor a domínio standard</title><link>https://abapinho.com/2014/01/adicionar-valor-a-dominio-standard/</link><pubDate>Mon, 13 Jan 2014 09:00:58 +0000</pubDate><guid>https://abapinho.com/2014/01/adicionar-valor-a-dominio-standard/</guid><description>&lt;p>Se julgas que não é possível acrescentar valores a um domínio SAP standard sem pedir uma chave de activação, estás enganado.&lt;/p></description></item><item><title>Usa sempre classes de mensagens nas classe de excepção</title><link>https://abapinho.com/2013/12/classes-de-mensagens-nas-classe-de-excepcao/</link><pubDate>Mon, 16 Dec 2013 09:00:49 +0000</pubDate><guid>https://abapinho.com/2013/12/classes-de-mensagens-nas-classe-de-excepcao/</guid><description>&lt;p>As classes de excepção permitem declarar múltiplos textos que descrevem os diferentes erros possíveis que elas podem representar.&lt;/p>
&lt;p>Há no entanto uma opção para a associar a uma classe de mensagens (SE91). Isto permite que, em vez de os textos serem definidos directamente ali na classe de excepção, sejam antes definidos como clássicas mensagens da SE91. E tem vantagens.&lt;/p></description></item><item><title>O editor de ABAP tem boa memória</title><link>https://abapinho.com/2013/12/o-editor-de-abap-tem-boa-memoria/</link><pubDate>Mon, 02 Dec 2013 09:00:55 +0000</pubDate><guid>https://abapinho.com/2013/12/o-editor-de-abap-tem-boa-memoria/</guid><description>&lt;p>No editor ABAP selecciona uma palavra e faz CTRL-C. Depois selecciona outra palavra e faz novamente CTRL-C. Depois outra e outra. Copiaste várias vezes palavras para o &lt;em>clipboard&lt;/em>. Diz a experiência e o senso comum que agora, se fizeres CTRL-V só vais poder usar a última palavra que para lá copiaste.&lt;/p>
&lt;p>Mas não é bem assim. Talvez não saibas mas o editor de ABAP tem boa memória.&lt;/p></description></item><item><title>Compara uma tabela entre dois sistemas</title><link>https://abapinho.com/2013/11/compara-uma-tabela-entre-dois-sistemas/</link><pubDate>Mon, 25 Nov 2013 09:00:45 +0000</pubDate><guid>https://abapinho.com/2013/11/compara-uma-tabela-entre-dois-sistemas/</guid><description>A transacção SCMP permite comparar o conteúdo de uma tabela entre dois sistemas. Muito útil, principalmente para tabelas de parameterização.
É muito simples de usar. Permite fazer uma pré-selecção dos registos bem como dos campos a comparar. Permite também mostrar apenas as diferenças, o que é conveniente para tabelas com muitos dados. E acho que não é preciso explicar mais. Ite et videte.
Esta dica apareceu recentemente no ex-blog SAPtricks e é tão útil que vo-la ofereço aqui também, caso não a tenham lá visto já.</description></item><item><title>SELECT... ORDER BY PRIMARY KEY</title><link>https://abapinho.com/2013/11/select-order-by-primary-key/</link><pubDate>Mon, 18 Nov 2013 09:00:43 +0000</pubDate><guid>https://abapinho.com/2013/11/select-order-by-primary-key/</guid><description>Embora já use ABAP desde 1998, todas as semanas aprendo novas funcionalidades ou opções ou mesmo novos comandos. Parece mentira.
Hoje partilho uma pequena opção do SQL que descobri recentemente:
SELECT * FROM T001 INTO TABLE T_T001 ORDER BY PRIMARY KEY. O SELECT e o FROM e o INTO e o TABLE e mesmo o ORDER BY já os conheço há muito tempo. Só não conhecia é o PRIMARY KEY.</description></item><item><title>Função para gerar bonecada</title><link>https://abapinho.com/2013/11/funcao-para-gerar-bonecada/</link><pubDate>Mon, 11 Nov 2013 09:00:47 +0000</pubDate><guid>https://abapinho.com/2013/11/funcao-para-gerar-bonecada/</guid><description>&lt;p>Bonecada fica sempre bem num relatório. Num SAPGui que é um tédio azulado, quanto mais cores e bonecos melhor. O Luís Rocha mostrou-me uma função muito conveniente para atafulhar um relatório com ícones.&lt;/p></description></item><item><title>SELECT comparando 2 campos da própria tabela</title><link>https://abapinho.com/2013/11/select-propria-tabela/</link><pubDate>Mon, 04 Nov 2013 09:00:00 +0000</pubDate><guid>https://abapinho.com/2013/11/select-propria-tabela/</guid><description>&lt;p>Esta dica é simples e rápida mas aposto 200$482 em como poucos a sabem.&lt;/p></description></item><item><title>Erro de sintaxe ao retornar tabela num método</title><link>https://abapinho.com/2013/10/erro-ao-retornar-tabela-num-metodo/</link><pubDate>Mon, 21 Oct 2013 09:00:37 +0000</pubDate><guid>https://abapinho.com/2013/10/erro-ao-retornar-tabela-num-metodo/</guid><description>&lt;p>Quando, num método de uma classe, crias um parâmetro de retorno que é um TABLE TYPE baseado num tipo declarado na própria classe, às vezes aparece um erro que diz:&lt;/p>
&lt;p>&amp;ldquo;Os parâmetros RETURNING devem ser completamente tipificados.&amp;rdquo;&lt;/p></description></item><item><title>Comando /HS</title><link>https://abapinho.com/2013/07/comando-hs/</link><pubDate>Mon, 22 Jul 2013 09:00:36 +0000</pubDate><guid>https://abapinho.com/2013/07/comando-hs/</guid><description>&lt;p>Todo os funcional, até o mais funcional dos funcionais, sabe que para começar a depurar (vá, a fazer &lt;em>debug&lt;/em> a) um programa ABAP se usa o comando /H. Mas raro será o programador, mesmo o mais programador dos programadores, que saberá para que serve o comando /HS.&lt;/p></description></item><item><title>Chama dinamicamente classes e métodos</title><link>https://abapinho.com/2013/07/chamada-dinamicamente-classes-e-metodos/</link><pubDate>Mon, 08 Jul 2013 09:00:12 +0000</pubDate><guid>https://abapinho.com/2013/07/chamada-dinamicamente-classes-e-metodos/</guid><description>&lt;p>Ora aprende lá como invocar dinamicamente um método.&lt;/p>
&lt;p>Vamos a isso.&lt;/p></description></item><item><title>Funções Z misturadas com vistas de manutenção, não!</title><link>https://abapinho.com/2013/06/funcoes-z-com-vistas-de-manutencao-nao/</link><pubDate>Mon, 24 Jun 2013 09:00:02 +0000</pubDate><guid>https://abapinho.com/2013/06/funcoes-z-com-vistas-de-manutencao-nao/</guid><description>&lt;p>A dica de hoje não é uma dica. É um conselho.&lt;/p>
&lt;p>Criada uma tabela, depois crias as suas vistas de manutenção. As vistas de manutenção vivem dentro de um grupo de funções. Grupo de funções esse que te é pedido aquando da criação delas. Porque afinal aquilo não passa de um conjunto de código gerado, sendo que a maior parte são ainda assim includes standard. Montes deles.&lt;/p>
&lt;p>Apresento-te o problema: há quem crie funções Z suas e as coloque em grupos de função que contêm vistas de manutenção. É verdade. Há quem o faça.&lt;/p></description></item><item><title>Gosto do LIKE</title><link>https://abapinho.com/2013/06/gosto-do-like/</link><pubDate>Mon, 17 Jun 2013 09:00:16 +0000</pubDate><guid>https://abapinho.com/2013/06/gosto-do-like/</guid><description>&lt;p>Nos maus velhos tempos em que o ABAP era ainda mais antiquado do que é hoje, as declarações de variáveis eram quase todas feitas com LIKE e referenciadas a campos de tabelas:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" style="background-color:#fff;-moz-tab-size:2;-o-tab-size:2;tab-size:2;">&lt;code class="language-ABAP" data-lang="ABAP">&lt;span style="display:flex;">&lt;span>&lt;span style="color:#00f">DATA&lt;/span>: &lt;span style="color:#000">V_KUNNR&lt;/span> &lt;span style="color:#00f">LIKE &lt;/span>&lt;span style="color:#000">KNA1&lt;/span>-&lt;span style="color:#000">KUNNR&lt;/span>.&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div></description></item><item><title>QUICKINFO: dica sobre como dar dicas</title><link>https://abapinho.com/2013/06/quickinfo/</link><pubDate>Mon, 03 Jun 2013 09:00:46 +0000</pubDate><guid>https://abapinho.com/2013/06/quickinfo/</guid><description>Esta dica vem, no meu entender, uns anos tarde demais, visto ser já raro usar o comando WRITE para escrever directamente coisas para o ecrã. É, portanto, digamos assim, uma dica retro. Uma dica vintage. Mas vamos supor que estamos ainda no século XX a debater-nos com o comando mais barroco do ABAP, o WRITE.
Imagina-te então, sentado à frente do SAP, a ouvir Pearl Jam, com uns auscultadores de cor preta, e a escrever WRITEs de uma série de valores no ecrã sobre os quais gostavas que o utilizador pudesse ter mais informação.</description></item><item><title>Aquele sistema RFC está vivo?</title><link>https://abapinho.com/2013/05/aquele-sistema-rfc-esta-vivo/</link><pubDate>Mon, 27 May 2013 09:00:03 +0000</pubDate><guid>https://abapinho.com/2013/05/aquele-sistema-rfc-esta-vivo/</guid><description>Queres invocar uma função RFC noutro sistema mas, porque não és necrófago, só o queres fazer se ele estiver vivo.
Precisas então de uma forma de saber se esse determinado sistema destino RFC está vivo.
Como fazes?
O Charles Santana faz assim:
DATA: rfcdest TYPE rfcdest, ping_status TYPE /sdf/e2e_traffic_light_numeric. CALL FUNCTION &amp;#39;/SDF/RFC_CHECK&amp;#39; EXPORTING iv_destination = rfcdest iv_ping = &amp;#39;X&amp;#39; iv_logon = &amp;#39;X&amp;#39; iv_latency = &amp;#39;X&amp;#39; IMPORTING ev_ping_status = ping_status. if lv_ping_status &amp;lt;&amp;gt; 1.</description></item><item><title>A função existe?</title><link>https://abapinho.com/2013/05/a-funcao-existe/</link><pubDate>Mon, 20 May 2013 09:00:07 +0000</pubDate><guid>https://abapinho.com/2013/05/a-funcao-existe/</guid><description>&lt;p>Chamas uma função.
Imagina que ela não responde.
Pode ser por ter ficado calada.
Ou por ser tímida.
Ou muda.
Ou, ai tragédia!, por não existir.&lt;/p>
&lt;p>Para teres a certeza e ficares descansado fazes assim:&lt;/p></description></item><item><title>Escrever dinheiro sem preocupações decimais</title><link>https://abapinho.com/2013/05/escrever-dinheiro-sem-preocupacoes-decimais/</link><pubDate>Mon, 13 May 2013 09:00:50 +0000</pubDate><guid>https://abapinho.com/2013/05/escrever-dinheiro-sem-preocupacoes-decimais/</guid><description>&lt;p>Há quem leia a TCURX para descobrir o número de casas decimais de uma MOEDA quando precisa de escrever um campo endinheirado para uma variável ALFANUMERICA.&lt;/p>
&lt;p>És assim? Não sejas.&lt;/p></description></item><item><title>Finalmente encadeiam-se expressões</title><link>https://abapinho.com/2013/04/expressoes-encadeadas/</link><pubDate>Mon, 15 Apr 2013 09:00:33 +0000</pubDate><guid>https://abapinho.com/2013/04/expressoes-encadeadas/</guid><description>&lt;p>Finalmente, com o &lt;em>SAP NetWeaver 7.0 Enhancement Package 2&lt;/em> o ABAP começa a parecer-se com uma linguagem de programação normal.&lt;/p>
&lt;p>Até já dá para encadear expressões, vê lá tu!&lt;/p></description></item><item><title>Decimais para alfa-numéricos sem depender do utilizador</title><link>https://abapinho.com/2013/04/decimais-para-alfa-numericos-sem-depender-do-utilizador/</link><pubDate>Mon, 08 Apr 2013 09:00:46 +0000</pubDate><guid>https://abapinho.com/2013/04/decimais-para-alfa-numericos-sem-depender-do-utilizador/</guid><description>&lt;p>Ao ler um ficheiro com valores numéricos para uma tabela interna ou vice-versa, o sucesso da conversão destes depende de o utilizador tem definido o ponto ou a vírgula como separador decimal. É costume ir então ler a configuração do utilizador e depois, adaptar os valores vindos do ficheiro com ponto ou vírgula conforme.&lt;/p>
&lt;p>Mas isto é lamentável e pouco elegante. Devia haver uma forma de não fazer a coisa depender do utilizador.&lt;/p>
&lt;p>E há.&lt;/p></description></item><item><title>SORTED em vez de STANDARD nas tabelas de cache</title><link>https://abapinho.com/2013/04/sorted-em-vez-de-standard/</link><pubDate>Mon, 01 Apr 2013 16:11:22 +0000</pubDate><guid>https://abapinho.com/2013/04/sorted-em-vez-de-standard/</guid><description>Há bastante tempo atrás escrevi aqui um artigo demonstrando as vantagens de usar tabelas internas com índices definidos em vez de simples tabelas STANDARD.
Confissão: é tal o hábito instalado que desde então, quase todas as tabelas internas que criei continuaram a ser STANDARD TABLE.
É muito frequente criar tabelas internas para fazer cache de dados que sei que vou utilizar amiúde dentro de LOOPs para evitar fazer SELECT SINGLEs lá pelo meio.</description></item><item><title>Partilhar constantes entre várias classes</title><link>https://abapinho.com/2013/03/partilhar-constantes-entre-varias-classes/</link><pubDate>Mon, 25 Mar 2013 09:00:35 +0000</pubDate><guid>https://abapinho.com/2013/03/partilhar-constantes-entre-varias-classes/</guid><description>&lt;p>Imagina que tens uma manada de classes relacionadas as quais partilham entre elas uma manada de constantes. Dizendo a mesma coisa de outra forma, gostavas que todas as classes da manada tivessem acesso de forma simples à manada de constantes.&lt;/p>
&lt;p>(Se estás baralhado, fica sabendo que a manada era só para baralhar)&lt;/p>
&lt;p>Continuando.&lt;/p></description></item><item><title>SAP de aluguer</title><link>https://abapinho.com/2013/03/sap-de-aluguer/</link><pubDate>Mon, 18 Mar 2013 09:00:21 +0000</pubDate><guid>https://abapinho.com/2013/03/sap-de-aluguer/</guid><description>&lt;p>Se precisas mesmo de aceder a um SAP e ninguém te deixa e não tens um computador onde o possas instalar ou não tens ciência ou paciência para o fazer, podes sempre alugar.&lt;/p></description></item><item><title>Alucinação às cores</title><link>https://abapinho.com/2013/03/alucinacao-as-cores/</link><pubDate>Mon, 11 Mar 2013 09:00:56 +0000</pubDate><guid>https://abapinho.com/2013/03/alucinacao-as-cores/</guid><description>&lt;p>Isto não é um artigo. Isto quase nem é uma dica. Isto aproxima-se mais de um desabafo em tom de arco-iris.&lt;/p></description></item><item><title>Criar RANGEs no DDIC sem ficar com os dentes a ranger</title><link>https://abapinho.com/2013/03/ranges-no-ddic/</link><pubDate>Mon, 04 Mar 2013 18:26:40 +0000</pubDate><guid>https://abapinho.com/2013/03/ranges-no-ddic/</guid><description>&lt;p>Cada vez uso mais RANGEs. Uso-os ao pequeno-almoço, ao almoço, ao jantar e fora das refeições. É como o molho de soja. Umas colheradas daquilo e fica logo tudo mais saboroso.&lt;/p></description></item><item><title>Bloquear dados em tabelas Z sem objecto de bloqueio</title><link>https://abapinho.com/2013/01/bloquear-dados-em-tabelas-z-sem-objecto-de-bloqueio/</link><pubDate>Mon, 28 Jan 2013 09:00:54 +0000</pubDate><guid>https://abapinho.com/2013/01/bloquear-dados-em-tabelas-z-sem-objecto-de-bloqueio/</guid><description>&lt;p>Até há dois dias atrás, se eu precisasse de criar entradas de bloqueio numa tabela ZCOISO criada por mim iria à SE11 criar um objecto de bloqueio para a tabela ZCOISO para depois poder usar os módulos de função gerados pelo objecto de bloqueio para bloquear os dados.&lt;/p>
&lt;p>Mas agora já não.&lt;/p></description></item><item><title>Nome do system SAP no título da janela</title><link>https://abapinho.com/2013/01/titulo-da-janela/</link><pubDate>Mon, 21 Jan 2013 09:00:20 +0000</pubDate><guid>https://abapinho.com/2013/01/titulo-da-janela/</guid><description>&lt;p>O cliente onde estou a trabalhar tem mais sistemas SAP do que há vulcões no Chile. E, claro, é inevitável que eu tenha sempre montes de sessões abertas para vários destes sistemas. Ora, quando estão minimizados, não é possível saber a que sistema corresponde cada sessão. Quer dizer, não era, porque agora já é:&lt;/p></description></item><item><title>Executa comandos no computador do utilizador</title><link>https://abapinho.com/2012/12/comandos-no-computador-do-utilizador/</link><pubDate>Mon, 10 Dec 2012 09:00:41 +0000</pubDate><guid>https://abapinho.com/2012/12/comandos-no-computador-do-utilizador/</guid><description>Já há uns tempos que o Abapinho não mexia com o fogo. Hoje mexerá.
Porque hoje mostrará como executar comandos DOS na máquina local do utilizador. Quando tiveres terminado de ler este artigo estarás apto a formatar o disco rígido de todos os teus utilizadores. Lidar com o perigo ajuda-nos a tomar consciência do poder que temos e da responsabilidade que vem junto com ele. Querido leitor, segue a tua consciência.</description></item><item><title>Vantagens do LIKE LINE OF</title><link>https://abapinho.com/2012/11/vantagens-do-like-line-of/</link><pubDate>Mon, 26 Nov 2012 09:00:40 +0000</pubDate><guid>https://abapinho.com/2012/11/vantagens-do-like-line-of/</guid><description>&lt;p>Partamos do princípio de que és uma pessoa com alguma dignidade e que por isso já não usas tabelas internas com HEADER LINE ;)&lt;/p>
&lt;p>Posto isto, imaginemos que declaras uma tabela interna:&lt;/p></description></item><item><title>Manter grupos de autorização de manutenção de tabelas</title><link>https://abapinho.com/2012/11/se54/</link><pubDate>Mon, 19 Nov 2012 09:00:24 +0000</pubDate><guid>https://abapinho.com/2012/11/se54/</guid><description>&lt;p>Há alguns projectos em que o grupo de autorizações associados à manutenção de tabelas é sempre &amp;amp;NC;&amp;amp;, ou seja, &amp;amp;N;ão cuidado&amp;amp;. É sinal de que lá é tudo amigo e ninguém faz mal a ninguém. Mas há outros projectos em que os grupos de autorização são levados a sério. O que não é sinónimo de dizer que estão organizados. A sério ou não, o normal é acabar tudo uma grande salgalhada onde ninguém sabe quem é que está autorizado a fazer o quê.&lt;/p>
&lt;p>Esta dica talvez ajude.&lt;/p></description></item><item><title>INSERT e APPEND com ASSIGNING FIELD-SYMBOL</title><link>https://abapinho.com/2012/11/insert-initial-line-into-table/</link><pubDate>Mon, 05 Nov 2012 09:00:11 +0000</pubDate><guid>https://abapinho.com/2012/11/insert-initial-line-into-table/</guid><description>&lt;p>A verdade nua e crua, custe o que custar, é que as estruturas estão fora de moda. Agora o que está em voga é FIELD-SYMBOLS.&lt;/p>
&lt;p>Quando fazes um LOOP a uma tabela interna, claro que também &lt;a href="https://abapinho.com/2011/07/assigning-vs-into/">usas ASSIGNING FIELD-SYMBOL em vez de INTO estrutura&lt;/a>, não é?&lt;/p>
&lt;p>Mas o que me lixava era o APPEND e o INSERT. Ainda não sabia como evitar usar uma estrutura para adicionar registos.&lt;/p></description></item><item><title>Ninguém liga ao LISTBOX</title><link>https://abapinho.com/2012/10/ninguemligaaolistbox/</link><pubDate>Mon, 29 Oct 2012 09:00:07 +0000</pubDate><guid>https://abapinho.com/2012/10/ninguemligaaolistbox/</guid><description>&lt;p>Por alguma razão misteriosa, a LISTBOX é uma funcionalidade pouco utilizada nos ecrãs de selecção do SAP. E, no entanto, na web está por todo o lado. Vá-se lá saber porquê.&lt;/p>
&lt;p>Caro leitor, proponho que atentes nas suas vantagens:&lt;/p></description></item><item><title>SAPagaio</title><link>https://abapinho.com/2012/10/sapagaio/</link><pubDate>Mon, 15 Oct 2012 09:00:47 +0000</pubDate><guid>https://abapinho.com/2012/10/sapagaio/</guid><description>Na SE38, e cria um programa com o seguinte código. Depois liga o som do teu computador e faz F8.
INCLUDE ole2incl. DATA : ole TYPE ole2_object, voz TYPE ole2_object, texto TYPE string. CREATE OBJECT voz &amp;#39;SAPI.SpVoice&amp;#39;. texto = &amp;#39;Olá eu sou o SAP e falo português com sotaque estrangeiro&amp;#39;. CALL METHOD OF voz &amp;#39;Speak&amp;#39; = ole EXPORTING #1 = texto. Nota: o papagaio ficou de fora na foto, só apanharam a arara com que ele estava a conversar :)</description></item><item><title>É a sério ou a brincar?</title><link>https://abapinho.com/2012/10/a-serio-ou-a-brincar/</link><pubDate>Mon, 08 Oct 2012 09:00:16 +0000</pubDate><guid>https://abapinho.com/2012/10/a-serio-ou-a-brincar/</guid><description>&lt;p>Há coisas que só podem mesmo acontecer em produtivo.
Outras há que muito pelo contrário&lt;/p></description></item><item><title>Se ainda não usas ABAP Objects és mariquinhas pé-de-salsa</title><link>https://abapinho.com/2012/10/mariquinhas-pe-de-salsa/</link><pubDate>Mon, 01 Oct 2012 09:00:20 +0000</pubDate><guid>https://abapinho.com/2012/10/mariquinhas-pe-de-salsa/</guid><description>A SAP tem um livro chamado Official ABAP Programming Guidelines que descreve regras e boas práticas de como programar em ABAP. E lá diz assim (dizia em estrangeiro, eu traduzi):
Pág. 42: Regra 3.1: Usa ABAP Objects sempre que possível para novos desenvolvimentos. Só podes criar blocos de processamento clássicos em casos excepcionais.
Pág. 45: Num bloco de processamento clássico, deverás delegar imediatamente a execução para um método apropriado (ver Regra 6.</description></item><item><title>Belos diagramas de relações de tabelas</title><link>https://abapinho.com/2012/09/diagrama-relacoes-tabelas/</link><pubDate>Mon, 24 Sep 2012 09:00:39 +0000</pubDate><guid>https://abapinho.com/2012/09/diagrama-relacoes-tabelas/</guid><description>O Rui Dias mostrou-me um site onde podes ver as relações que qualquer tabela standard tem com as outras.
Por exemplo para a T012. E se experimentares com a KNA1 é ainda mais giro.
Gostas? Eu gosto.
Obrigado Rui Dias.
O Abapinho saúda-vos.</description></item><item><title>Atalho para o campo da transacção</title><link>https://abapinho.com/2012/09/atalho-campo-transaccao/</link><pubDate>Mon, 10 Sep 2012 09:00:09 +0000</pubDate><guid>https://abapinho.com/2012/09/atalho-campo-transaccao/</guid><description>Estás tu escrevendo furiosamente pelo SAP adentro qualquer quando de repente precisas de ir lá acima ao campo da transacção escrever /OS37 ou algo assim. Mas escreves com tanto tanto tanto fervor que a simples ideia de largar o teclado por um momento para ir com a mão ao rato te parece catastrófica. Então, em vez disso, carregas em 3 teclas: CTRL-SHIFT-7.
Obrigado a Renato Sousa pela dica.
O Abapinho saúda-vos.</description></item><item><title>Cria sessões com o teclado</title><link>https://abapinho.com/2012/09/cria-sessoes-com-o-teclado/</link><pubDate>Mon, 03 Sep 2012 09:00:02 +0000</pubDate><guid>https://abapinho.com/2012/09/cria-sessoes-com-o-teclado/</guid><description>Queres criar uma nova sessão e roubaram-te o rato. Não faz mal. Carregas no CTRL e na tecla + e vais ver uma nova sessão a aparecer.
Obrigado Renato Sousa pela dica.
E obrigado a freeimageslive / gratuit pela foto.
O Abapinho saúda-vos.</description></item><item><title>Narcisismo digital</title><link>https://abapinho.com/2012/08/narcisismo-digital/</link><pubDate>Mon, 27 Aug 2012 09:00:38 +0000</pubDate><guid>https://abapinho.com/2012/08/narcisismo-digital/</guid><description>&lt;p>Chama-se &lt;em>reflexão&lt;/em> à capacidade de um programa se ver a si próprio. O ABAP tem uma série de capacidades reflexivas como o RTTS ou a capacidade de gerar código dinamicamente. Além disso há mais umas funções assim e assado que fazem isto e aquilo. Hoje apresento-vos uma delas:&lt;/p>
&lt;p>GET_GLOBAL_SYMBOLS&lt;/p></description></item><item><title>Bom programa para encontrar user-exits</title><link>https://abapinho.com/2012/08/encontrar-user-exits/</link><pubDate>Mon, 20 Aug 2012 09:00:00 +0000</pubDate><guid>https://abapinho.com/2012/08/encontrar-user-exits/</guid><description>Volta não volta lá andamos nós à procura de user-exits e BADIs, BTEs e quejandos. A SAP não ajuda. Mas vão aparecendo aqui e ali programas, quase sempre chamados Z_USEREXIT, que dão uma ajuda nessa ingrata busca. Pois recentemente fiquei a saber de mais um. Partilho-o aqui porque é o melhor que vi até hoje:
https://wiki.sdn.sap.com/wiki/display/Snippets/Find+User-exits,+BADIs,+BTEs,+Etc+by+TCode+or+Program
Obrigado Bruno Esperança pela dica. E obrigado a rverscha pela foto.
O Abapinho saúda-vos.</description></item><item><title>Classe para converter STRINGs</title><link>https://abapinho.com/2012/08/classe-para-converter-strings/</link><pubDate>Mon, 13 Aug 2012 09:00:56 +0000</pubDate><guid>https://abapinho.com/2012/08/classe-para-converter-strings/</guid><description>&lt;p>Sabes como às vezes tens uma variável do tipo STRING e precisas de a enviar para uma função que precisa dela no tipo SOLIX? Acontece-me frequentemente. Pois descobri esta classe óptima que permite converter strings entre os mais variados formatos:&lt;/p>
&lt;p>CL_BCS_CONVERT&lt;/p></description></item><item><title>Salta a parede</title><link>https://abapinho.com/2012/08/salta-a-parede/</link><pubDate>Mon, 06 Aug 2012 09:00:31 +0000</pubDate><guid>https://abapinho.com/2012/08/salta-a-parede/</guid><description>&lt;p>Baixa a música.
Fecha a porta.
Olha à volta.
Está alguém a olhar para ti?
Não estás a ser observado?
Nem câmaras de vigilância?
Então, podemos continuar.&lt;/p></description></item><item><title>Evitando a concorrência num programa ABAP</title><link>https://abapinho.com/2012/07/evitando-a-concorrencia-num-programa-abap/</link><pubDate>Mon, 30 Jul 2012 09:00:27 +0000</pubDate><guid>https://abapinho.com/2012/07/evitando-a-concorrencia-num-programa-abap/</guid><description>&lt;p>Dizem que a concorrência no comércio é boa. Boa para os consumidores, isto é. Faz descer os preços e assim. Mas dentro dos computadores prejudica quem os consome.&lt;/p>
&lt;p>Normalmente em ABAP combate-se a concorrência ao nível dos dados, bloqueando ( &lt;em>euqueue&lt;/em> ) determinadas tabelas com base na sua chave. Mas por vezes pode ser necessário algo mais violento como garantir que um programa não pode correr mais do que uma vez ao mesmo tempo. Para fazer isso pode usar-se o objecto de bloqueio ESINDX.&lt;/p></description></item><item><title>Mergulhando no Caos com as classes CL_ABAP_RANDOM*</title><link>https://abapinho.com/2012/07/numeros-aleatorios/</link><pubDate>Mon, 23 Jul 2012 09:00:07 +0000</pubDate><guid>https://abapinho.com/2012/07/numeros-aleatorios/</guid><description>&lt;p>Os programas ABAP são todos demasiado bem comportados; demasiado previsíveis.&lt;/p>
&lt;p>Enquanto demiúrgos, temos a obrigação moral de lhes dar um pouco de livre arbítrio, dar-lhes a cheirar o caos, mostrar-lhes as árvores da vida e do conhecimento e, num passe de &lt;em>kenosis&lt;/em> , deixá-los à vontade para trincarem a maçã. Só assim nos sentiremos completos e realizados; só assim poderemos descansar ao sétimo dia.&lt;/p>
&lt;p>E para isso, nada como os números aleatórios.&lt;/p></description></item><item><title>Parâmetros complexos em funções remotas</title><link>https://abapinho.com/2012/07/parametros-complexos-por-rfc/</link><pubDate>Mon, 16 Jul 2012 09:00:01 +0000</pubDate><guid>https://abapinho.com/2012/07/parametros-complexos-por-rfc/</guid><description>&lt;p>As chamadas a funções remotas (por RFC) não suportam parâmetros com estruturas complexas ( &lt;em>deep structures&lt;/em> ). Por outras palavras, se algum dos parâmetros tiver uma estrutura em que um dos seus campos seja outra estrutura ou uma tabela interna, azar, não dá.&lt;/p>
&lt;p>Desistes? Não desistas. O Abapinho dá-te a solução: serialização.&lt;/p></description></item><item><title>F1 nos campos do ecrã de selecção</title><link>https://abapinho.com/2012/07/f1-ecra-seleccao/</link><pubDate>Mon, 09 Jul 2012 09:00:07 +0000</pubDate><guid>https://abapinho.com/2012/07/f1-ecra-seleccao/</guid><description>&lt;p>Acabaste de fazer um belíssimo relatório encabeçado por um ecrã de selecção atafulhado de campos muito interessantes. Mas o mais normal é que, se tiver alguma complexidade, quem correr o teu relatório não saiba para que serve cada um dos campos. Para isso há, claro, as especificações técnica e funcional. Há? E mesmo que haja, não seria mais simples se ela pudesse fazer F1 em cima de cada campo e logo ali aprender para que serve?&lt;/p>
&lt;p>Vou mostrar-te duas formas possíveis de dares informação individualizada sobre os campos de um ecrã de selecção.&lt;/p></description></item><item><title>Saltando alegremente de linha em linha</title><link>https://abapinho.com/2012/06/saltar-para-linha/</link><pubDate>Mon, 25 Jun 2012 09:00:09 +0000</pubDate><guid>https://abapinho.com/2012/06/saltar-para-linha/</guid><description>No canto inferior direito do editor ABAP, na linha de status, diz qual é a linha e coluna em que o cursor se encontra. Se fizeres duplo-clique em cima dessa informação aparece-te uma janela de diálogo onde podes introduzir um número de linha para saltar directamente para lá. O atalho de teclado é CTRL-O. Dá muito jeito.
Obrigado Fábio Branquinho pela dica.
E obrigado a juandesant pela foto.
O Abapinho saúda-vos.</description></item><item><title>Pesquisar em menus</title><link>https://abapinho.com/2012/06/pesquisar-em-menus/</link><pubDate>Mon, 18 Jun 2012 09:00:02 +0000</pubDate><guid>https://abapinho.com/2012/06/pesquisar-em-menus/</guid><description>Sabias que podes pesquisar nos menus SAP? Provavelmente sim. Mas olha, eu não. Passei anos a perscrutar o menu S000 em busca das mais variadas coisas. Estou certo de que se tivesse feito uma pesquisa teria encontrado muitas delas num instante. Às vezes uma pessoa não se lembra do óbvio. Se és essa pessoa, esta dica é para ti.
Obrigado Sérgio Fraga pela dica.
O Abapinho saúda-vos.</description></item><item><title>Ponto e vírgula ou vírgula e ponto?</title><link>https://abapinho.com/2012/06/ponto-e-virgula-ou-virgula-e-ponto/</link><pubDate>Mon, 11 Jun 2012 09:00:34 +0000</pubDate><guid>https://abapinho.com/2012/06/ponto-e-virgula-ou-virgula-e-ponto/</guid><description>Há números com pontos, há números com vírgulas e há números com pontos e vírgulas. O problema é que também há números com vírgulas e pontos. É que há vírgulas que são pontos e há pontos que são vírgulas, conforme a tua terra, ou seja, conforme as configurações do teu utilizador. Quando se importa um ficheiro com números decimais, há que converter esses números do seu campo alfa-numérico em campos numéricos.</description></item><item><title>Mais RANGEs, menos SELECTs</title><link>https://abapinho.com/2012/06/mais-ranges-menos-selects/</link><pubDate>Mon, 04 Jun 2012 09:00:33 +0000</pubDate><guid>https://abapinho.com/2012/06/mais-ranges-menos-selects/</guid><description>&lt;p>O dicionário diz o seguinte do verbete &amp;ldquo;estilo&amp;rdquo;: &amp;ldquo;conjunto de aspectos formais e recursos expressivos que caracterizam um texto&amp;rdquo;.&lt;/p>
&lt;p>Dá mais gosto ler textos com estilo do que textos sem estilo. Se o ABAP é uma linguagem, um programa em ABAP é um texto. Há programas que, no que toca ao estilo, parecem escritos com os pés; enquanto há outros que se poderia jurar que a pena que os escreveu deixou-se guiar pelas alvas mãos de uma qualquer donzela do século XVIII afligida por males de amor. Felizmente penso que não é possível escrever programas em ABAP tão pirosos quanto esta última frase.&lt;/p>
&lt;p>Aqui no Abapinho usa-se a etiqueta &amp;ldquo;estilo&amp;rdquo; para identificar artigos que falam sobre isso mesmo: estilo. Estes artigos tentam encontrar formas de melhorar o estilo dos programas ABAP. Esta é uma das etiquetas favoritas do Abapinho como podes ver &lt;a href="https://abapinho.com/tags/estilo/">aqui&lt;/a>. E isto que estás a ler é mais um desses artigos.&lt;/p>
&lt;p>Adiante.&lt;/p></description></item><item><title>Barra Ó</title><link>https://abapinho.com/2012/05/barra-o/</link><pubDate>Mon, 21 May 2012 10:00:00 +0000</pubDate><guid>https://abapinho.com/2012/05/barra-o/</guid><description>Durante toda a minha vida SAPica usei o comando /olalala para iniciar a transacção lalala numa nova janela. Mas nunca tinha experimentado escrever só /o. Experimentei. E o que aconteceu foi interessante:
Ou seja, é o mesmo que ia à SM04 e depois escolher o nosso utilizador. Mas muito mais prático.
O Abapinho saúda-vos.</description></item><item><title>Constantes gregárias</title><link>https://abapinho.com/2012/05/constantesgregarias/</link><pubDate>Mon, 14 May 2012 10:00:28 +0000</pubDate><guid>https://abapinho.com/2012/05/constantesgregarias/</guid><description>&lt;p>Se és daqueles que, em vez de usarem constantes, espetam com os valores directamente no código, então pára de ler isto e vai ali para o canto de castigo durante 1 hora que é para aprenderes a não ser mandrião. Quando voltares podes continuar a ler.&lt;/p></description></item><item><title>A sua password expirou. Mude-a 5 vezes.</title><link>https://abapinho.com/2012/05/a-sua-password-expirou/</link><pubDate>Mon, 07 May 2012 10:00:08 +0000</pubDate><guid>https://abapinho.com/2012/05/a-sua-password-expirou/</guid><description>Não é incomum criarmos uma relação emocional com as nossas passwords. Por isso, é sempre com alguma dor que se recebe aqueles abjectos avisos ameaçadores que dizem que &amp;ldquo;a sua password vai expirar&amp;rdquo;. Brevemente seguidos pelo duro golpe que recebemos no coração quando surge a inevitável ignóbil invectiva que diz que &amp;ldquo;a sua password expirou&amp;rdquo;. Nesses momentos a mágoa é tanta que todas as musas nos abandonam, temos uma cãibra na imaginação e ficamos ali, especados, esquecidos, esvaziados de qualquer ideia que nos ajude a escolher a nossa próxima palavra-chave.</description></item><item><title>Atender o cliente ou aviar o freguês?</title><link>https://abapinho.com/2012/04/cliente-ou-fregues/</link><pubDate>Mon, 23 Apr 2012 10:00:05 +0000</pubDate><guid>https://abapinho.com/2012/04/cliente-ou-fregues/</guid><description>Em todo o lado onde se use o elemento de dados KUNNR, a sua descrição diz &amp;ldquo;Cliente&amp;rdquo;. E se quiseres mudar a descrição deste campo de &amp;ldquo;Cliente&amp;rdquo; para &amp;ldquo;Freguês&amp;rdquo;? &amp;ldquo;Freguês&amp;rdquo; é tão mais bonito! Ou imagina que a empresa para quem trabalhas trafica droga e te diz que gostava que no LIFNR aparecesse &amp;ldquo;Dealer&amp;rdquo; em vez de &amp;ldquo;Fornecedor&amp;rdquo;. Claro que nos ecrãs e relatórios Z podemos descrevê-lo como quisermos mas&amp;hellip; e nas transacções standard?</description></item><item><title>Mete botões no ecrã de selecção</title><link>https://abapinho.com/2012/04/botoes-no-ecra-de-seleccao/</link><pubDate>Mon, 16 Apr 2012 10:00:45 +0000</pubDate><guid>https://abapinho.com/2012/04/botoes-no-ecra-de-seleccao/</guid><description>&lt;p>Quando num relatório é preciso criar botões para os utilizadores carregarem, normalmente recorre-se ao Screen Painter para criar um ecrã que depois é invocado pelo report com CALL SCREEN. Mas, a não ser que o ecrã a desenhar tenha já alguma complexidade, não é preciso apanhar a valente seca de fazer um ecrã que depois fica para lá. Ecrãs sempre me irritaram.&lt;/p>
&lt;p>Mostro aquí um exemplo de utilização de botões num normalíssimo ecrã de selecção recorrendo a um botão chamado PUSHBUTTON e a um truque muito esperto chamado ONLI.&lt;/p></description></item><item><title>Atafulha o ecrã de selecção de bonecada</title><link>https://abapinho.com/2012/04/bonecada-no-ecra-seleccao/</link><pubDate>Mon, 09 Apr 2012 10:00:58 +0000</pubDate><guid>https://abapinho.com/2012/04/bonecada-no-ecra-seleccao/</guid><description>&lt;p>Foi o SAP que nasceu tristonho ou são os SAPeiros que não o alegram?&lt;/p>
&lt;p>É verdade que o SAPGui não é nenhum arco-íris nem inspira felicidade ao olhar para ele. Mas ainda assim põe uma catrefada de bonequinhos ao nosso dispôr que podemos usar para o tornar nem que seja um pouquinho mais animado.&lt;/p>
&lt;p>E vê como é tão fácil.&lt;/p></description></item><item><title>Ó Tempo Volta Para Trás</title><link>https://abapinho.com/2012/04/o-tempo-volta-para-tras/</link><pubDate>Mon, 02 Apr 2012 10:00:08 +0000</pubDate><guid>https://abapinho.com/2012/04/o-tempo-volta-para-tras/</guid><description>&lt;p>&amp;ldquo;Ó tempo volta para trás
Dá-me tudo o que eu perdi
Tem pena e dá-me a vida
A vida que eu já vivi
Ò tempo volta p&amp;rsquo;ra trás
Mata as minhas esperanças vãs
Vê que até o próprio sol
Volta todas as manhãs&amp;rdquo; - António Mourão&lt;/p>
&lt;p>Ó &lt;a href="https://www.youtube.com/watch?v=LOtAfLvhSZo">Tony&lt;/a>, é para já. Vou mostrar-te como podes voltar atrás no tempo.&lt;/p></description></item><item><title>F1 + F9 = Informações técnicas</title><link>https://abapinho.com/2012/03/f1-f9-informacoes-tecnicas/</link><pubDate>Mon, 05 Mar 2012 16:18:59 +0000</pubDate><guid>https://abapinho.com/2012/03/f1-f9-informacoes-tecnicas/</guid><description>Amiúde sinto necessidade de, num ecrã funcional, ver as informações técnicas de um determinado campo. Coloco o cursor sobre o campo desejado, depois carrego em F1 e aparece um ecrã de diálogo com ajuda sobre esse campo. A seguir carrego no botão que diz &amp;ldquo;informações técnicas&amp;rdquo;. Mas há uma forma rápida de fazer o mesmo recorrendo apenas ao teclado.
É que há dois modos possíveis para o F1 mostrar ajuda de um campo:</description></item><item><title>Quando a tabela interna não é estruturada</title><link>https://abapinho.com/2012/02/tabela-interna-nao-estruturada/</link><pubDate>Mon, 27 Feb 2012 10:00:06 +0000</pubDate><guid>https://abapinho.com/2012/02/tabela-interna-nao-estruturada/</guid><description>Quando queres seleccionar linhas numa tabela interna normalmente fazes algo assim:
DATA: BEGIN OF itbl, campo1 TYPE c, campo2 TYPE c, END OF itbl. READ TABLE itbl WITH KEY campo1 = &amp;#39;X&amp;#39; campo2 = &amp;#39;Y&amp;#39;. LOOP AT itbl WHERE campo1 = &amp;#39;X&amp;#39; and campo2 = &amp;#39;Y&amp;#39;. COISO. ENDLOOP. Mas, e se a tabela não for estruturada e quiseres pesquisar na linha como um todo? Bem, nesse caso, fica aqui a dica: usas a palavra especial TABLE_LINE :</description></item><item><title>Cria variantes de teste em funções a partir do debugger</title><link>https://abapinho.com/2012/02/variantes-de-teste-em-debug/</link><pubDate>Mon, 20 Feb 2012 10:00:42 +0000</pubDate><guid>https://abapinho.com/2012/02/variantes-de-teste-em-debug/</guid><description>&lt;p>Imagina que estás a fazer debug de uma transacção e entras numa função e encontras algo interessante. Tão interessante que tens de lhe fazer debug várias vezes. A via convencional é tornar a iniciar o debug da transacção desde o início. Que seca.&lt;/p>
&lt;p>Mas há uma via mais directa. Quando estás a fazer debug de uma função podes, directamente a partir do debugger, criar dados de teste para essa função com os valores com que a função tiver sido chamada nessa instância. É assim:&lt;/p></description></item><item><title>O histórico do SAPGui não funciona ainda que activo?</title><link>https://abapinho.com/2012/02/sapgui-historico/</link><pubDate>Mon, 06 Feb 2012 10:00:01 +0000</pubDate><guid>https://abapinho.com/2012/02/sapgui-historico/</guid><description>&lt;p>Já te aconteceu o SAPGui não guardar um histórico dos valores que vais introduzindo nos vários campos ainda que, nas configurações, a opção de Histórico esteja activa?&lt;/p></description></item><item><title>A SE80 tem favoritos</title><link>https://abapinho.com/2012/01/favoritos-se80/</link><pubDate>Mon, 30 Jan 2012 10:00:39 +0000</pubDate><guid>https://abapinho.com/2012/01/favoritos-se80/</guid><description>Na transacção SE80 há de tudo. Parece aquelas mercearias de aldeia atafulhadas de tralha onde se compra pasta de dentes, pão, sandálias, perfume e arroz a granel. Eu gosto dessas mercearias. Mas para lá ir é preciso saber ao que se vai, senão anda-se ao tio ao tio.
Mas isso é nesses mercearias, porque na SE80&amp;hellip; há favoritos.
Pois é. Só soube há uns dias que a transacção SE80 tem a capacidade de guardar favoritos.</description></item><item><title>Se um desconhecido te oferecer valores, isso é Input</title><link>https://abapinho.com/2012/01/call-selection-screen/</link><pubDate>Mon, 23 Jan 2012 10:00:08 +0000</pubDate><guid>https://abapinho.com/2012/01/call-selection-screen/</guid><description>Num relatório, os valores são normalmente pedidos ao utilizador no ecrã de selecção inicial, antes da execução do programa. Mas e se quiseres pedir-lhe mais alguns valores, interactivamente, a meio da execução do programa?
Uma forma de o fazer é criar um ecrã com os campos desejados e depois invocá-lo com CALL SCREEN. Mas desenhar o ecrã e definir o PAI e o PBO é uma valente maçada.
Outra solução é recorrer às funções POPUP_GET_VALUES ou POPUP_GET_VALUES_DB_CHECKED.</description></item><item><title>Ecrãs de selecção com abas</title><link>https://abapinho.com/2012/01/ecra-seleccao-abas/</link><pubDate>Mon, 16 Jan 2012 10:00:23 +0000</pubDate><guid>https://abapinho.com/2012/01/ecra-seleccao-abas/</guid><description>&lt;p>Os ecrãs de selecção dos programas ABAP têm várias funcionalidades que, embora sofisticadas e simples de usar, são geralmente ignoradas. Aqui mostrar-te-ei quão simples é criar abas para melhor organizar os parâmetros de um programa. Desta vez, excepcionalmente, vou poupar-te à verborreia. É uma aula prática.&lt;/p></description></item><item><title>Debug em janelas de diálogo modais</title><link>https://abapinho.com/2012/01/debug-em-popups/</link><pubDate>Mon, 09 Jan 2012 10:00:29 +0000</pubDate><guid>https://abapinho.com/2012/01/debug-em-popups/</guid><description>&lt;p>Há determinados momentos em que não é possível fazer /H para iniciar o &lt;em>debugger&lt;/em>. O caso mais comum é durante uma janela de diálogo modal (aquilo que os estrangeiros chamam de &lt;em>popup&lt;/em> ). Mas há uma forma simples, ainda que rocambolesca, para o conseguires:&lt;/p></description></item><item><title>O que diz uma mensagem?</title><link>https://abapinho.com/2012/01/texto-mensagem/</link><pubDate>Mon, 02 Jan 2012 10:00:15 +0000</pubDate><guid>https://abapinho.com/2012/01/texto-mensagem/</guid><description>Queres obter o texto de uma mensagem da qual só sabes o ID e o número e não sabes como? Aprende aqui:
DATA texto TYPE string. MESSAGE ID &amp;#39;00&amp;#39; TYPE &amp;#39;E&amp;#39; NUMBER &amp;#39;163&amp;#39; WITH &amp;#39;123&amp;#39; INTO texto. É só isto. Agora do lado de dentro da variável texto encontras o seguinte texto:
&amp;ldquo;O mandante 123 não existe no sistema&amp;rdquo;
Obrigado a Peteris B pela foto.
O Abapinho saúda-vos.</description></item><item><title>Sê preguiçoso quando escreves em ABAPês</title><link>https://abapinho.com/2011/12/modelos-de-codigo/</link><pubDate>Mon, 26 Dec 2011 00:11:42 +0000</pubDate><guid>https://abapinho.com/2011/12/modelos-de-codigo/</guid><description>&lt;p>Para tentar determinar quais as profissões com gente mais preguiçosa fiz as seguintes pesquisas no Google:&lt;/p>
&lt;table>
&lt;thead>
&lt;tr>
&lt;th>Profissão&lt;/th>
&lt;th>Resultados&lt;/th>
&lt;/tr>
&lt;/thead>
&lt;/table>
&lt;p>&amp;ldquo;médico preguiçoso&amp;rdquo;| 2.140.000&lt;/p>
&lt;p>&amp;ldquo;advogado preguiçoso&amp;rdquo;| 1.430.000&lt;/p>
&lt;p>&amp;ldquo;gestor preguiçoso&amp;rdquo;| 1.020.000&lt;/p>
&lt;p>&lt;em>&amp;ldquo;engenheiro preguiçoso&amp;rdquo;&lt;/em>| &lt;em>647.000&lt;/em>&lt;/p>
&lt;p>&amp;ldquo;político preguiçoso&amp;rdquo;| 602.000&lt;/p>
&lt;p>&amp;ldquo;economista preguiçoso&amp;rdquo;| 284.000&lt;/p>
&lt;p>&amp;ldquo;pedreiro preguiçoso&amp;rdquo;| 91.200&lt;/p>
&lt;p>Como se pode concluir inequivocamente, os engenheiros não são suficientemente preguiçosos pois são ultrapassados pelos advogados e pelos médicos. Isto tem de mudar. E esta dica vai ajudar. Mas não sem deixar clara a seguinte diferença: preguiça não é ergasiofobia. Falo aqui da preguiça nobre, a de quem gosta de fazer as coisas mas procura fazê-las com o mínimo esforço possível. Já os preguiçosos mandriões, esses não são para aqui chamados.&lt;/p>
&lt;p>O SAP, que lá vai evoluindo lentamente, lançou já há uns anos um editor novo que vem cheio de &lt;a href="https://wiki.sdn.sap.com/wiki/display/ABAP/New+ABAP+Editor">capacidades&lt;/a> muitas das quais, ainda que convenientes, são pouco aproveitadas. Uma delas chama-se &amp;ldquo;Modelos de código&amp;rdquo; que passo a apresentar:&lt;/p></description></item><item><title>ALV com múltipla escolha num ecrã de diálogo modal</title><link>https://abapinho.com/2011/12/alv-popup/</link><pubDate>Mon, 19 Dec 2011 10:00:31 +0000</pubDate><guid>https://abapinho.com/2011/12/alv-popup/</guid><description>&lt;p>Sabes apresentar, numa janela de diálogo, uma ALV com uma lista de registos permitindo escolha múltipla? Eu não sabia e agora já sei. Vou explicar como é.&lt;/p></description></item><item><title>Pasta temporária do SAP Gui</title><link>https://abapinho.com/2011/12/pasta-temporaria-sap-gui/</link><pubDate>Mon, 05 Dec 2011 10:00:09 +0000</pubDate><guid>https://abapinho.com/2011/12/pasta-temporaria-sap-gui/</guid><description>Por vezes um programa quer gravar um ficheiro localmente, no computador do utilizador através do SAP Gui. Nesses casos é comum que um dos campos do ecrã de selecção seja a localização da pasta no disco local.
Eis uma forma de inicializar esse campo com a pasta temporária do SAP Gui:
PARAMETERS: p_path TYPE string. AT SELECTION-SCREEN ON VALUE-REQUEST FOR p_path. CALL METHOD cl_gui_frontend_services=&amp;gt;directory_browse EXPORTING initial_folder = p_path CHANGING selected_folder = p_path.</description></item><item><title>Análises parciais na SE30</title><link>https://abapinho.com/2011/11/se30-parciais/</link><pubDate>Mon, 28 Nov 2011 11:37:25 +0000</pubDate><guid>https://abapinho.com/2011/11/se30-parciais/</guid><description>Claro que já conheces a transacção SE30 (Análise de tempo de execução) e claro que a usas amiúde para analisar programas standard e descobrir nele tabelas, funções, BADIs e quejandos.
Ora se fores como eu, manténs uma relação de amor-ódio com esta transacção: se por um lado a amas por graças a ela consegues ver as entranhas de um programa sem ter de fazer debug, por outro lado odeia-la porque normalmente a lista de entranhas costuma ter milhares de linhas e tornar-se ingerível.</description></item><item><title>Programas poliglotas que sabem o que dizem</title><link>https://abapinho.com/2011/11/programas-poliglotas/</link><pubDate>Mon, 21 Nov 2011 10:00:20 +0000</pubDate><guid>https://abapinho.com/2011/11/programas-poliglotas/</guid><description>O SAP é um grande poliglota. Mas o ABAP nem sempre. O ABAP até tem muita facilidade em aprender e falar várias línguas, mas às vezes os programadores não o deixam.
Muitos programadores cinzelam os textos literais directamente no programa, deixando-o irremediavelmente incapaz de comunicar em vários idiomas. Imagino duas razões para se agrilhoar um programa a uma única língua:
A preguiça, que é a principal razão para se fazerem as coisas mal feitas;</description></item><item><title>Adeus DESCRIBE TABLE. Já vais tarde.</title><link>https://abapinho.com/2011/11/lines/</link><pubDate>Mon, 07 Nov 2011 10:20:18 +0000</pubDate><guid>https://abapinho.com/2011/11/lines/</guid><description>Durante doze anos Quando quis contar As linhas de uma itab Fazia o que todos fazem: DESCRIBE TABLE itab LINES linhas.
Até que outro dia Vi uma coisa que, Parece mentira, Nunca antes vira: LINES( itab ).
Dá no mesmo E sem ter de declarar O raio da variável.
Assim, em vez de:
DATA: linhas TYPE i. DESCRIBE TABLE itabl LINES linhas. IF linhas = 42. WRITE &amp;#39;A tua tabela é a verdade&amp;#39;.</description></item><item><title>A mensagem travesti</title><link>https://abapinho.com/2011/10/mensagem-travesti/</link><pubDate>Mon, 31 Oct 2011 10:00:55 +0000</pubDate><guid>https://abapinho.com/2011/10/mensagem-travesti/</guid><description>Nos módulos AT SELECTION-SCREEN de um REPORT é-te possível lançar mensagens de erro e voltar ao ecrã de selecção. Mas uma vez que passes do START-OF-SELECTION, se lançares uma mensagem de erro, o programa termina. A solução para dar um erro e, ainda assim, regressar ao ecrã de selecção, é travestir a mensagem:
START-OF-SELECTION. IF condicao_desejada. MESSAGE S208(00) with &amp;#39;Erro!&amp;#39; DISPLAY LIKE &amp;#39;E&amp;#39;. EXIT. ENDIF. WRITE &amp;#39;Olá, eu sou o resto do programa&amp;#39;.</description></item><item><title>O circunlóquio do VALUE CHECK</title><link>https://abapinho.com/2011/10/value-check/</link><pubDate>Mon, 24 Oct 2011 10:00:24 +0000</pubDate><guid>https://abapinho.com/2011/10/value-check/</guid><description>Nunca te aconteceu esbarrares com uma coisa no ABAP que parece que é mas não é? A documentação diz que é, tudo indica que assim seja, e depois afinal não é.
Provavelmente já precisaste de, ao definir um parâmetro no ecrã de selecção de um relatório, limitar as possibilidades do que o utilizador pode introduzir aos valores disponíveis no tipo de dados desse parâmetro, certo? Para isto existe o VALUE CHECK.</description></item><item><title>Variantes automáticas em reports</title><link>https://abapinho.com/2011/10/variantes-automaticas/</link><pubDate>Mon, 17 Oct 2011 10:00:57 +0000</pubDate><guid>https://abapinho.com/2011/10/variantes-automaticas/</guid><description>Quando se está a desenvolver um relatório com um ecrã de selecção, é muito chato de cada vez que o testamos ter de preencher o ecrã de selecção com os dados de teste. Normalmente acabamos por criar uma variante de teste para nos poupar a esse chatice. Mas mesmo assim, de cada vez que corremos o relatório, temos de invocar manualmente esta variante.
Aqui está uma forma simples de invocar automaticamente uma variante.</description></item><item><title>De pé ó vítimas da fome</title><link>https://abapinho.com/2011/10/importar-classes-locais/</link><pubDate>Tue, 11 Oct 2011 10:55:54 +0000</pubDate><guid>https://abapinho.com/2011/10/importar-classes-locais/</guid><description>Classes. Sempre as houve entre as pessoas. Mas no ABAP ainda há poucos que as tenham em conta. Se ser classicista na sociedade pode resultar em pedantismo, no ABAP, a única luta de classes é a que alguns travam para que estas sejam mais usadas.
Há dois tipos de classes: as globais e as locais. As globais são criadas na transacção SE24. As locais, que por sinal dou por mim a usar cada vez mais, são feitas declarativamente na SE38.</description></item><item><title>Esquece!</title><link>https://abapinho.com/2011/10/esquece/</link><pubDate>Fri, 07 Oct 2011 10:00:49 +0000</pubDate><guid>https://abapinho.com/2011/10/esquece/</guid><description>O SAP GUI tem boa memória. Vai decorando os valores que lhe vamos metendo nos campos e depois sugere-os quando, mais tarde, voltamos a esses campos. Mas às vezes decora coisas que mais valia esquecer. Como por exemplo quando introduzimos um valor errado e a seguir ele insiste em sugerir-nos esse valor errado.
Há uns tempos descobri que este pequeno drama tem solução. Quando, no campo, aparece a combo box com as várias hipóteses, usa as setas do teclado para te posicionares no valor que queres esquecer e depois carrega na tecla DELETE.</description></item><item><title>SPLIT INTO TABLE</title><link>https://abapinho.com/2011/10/split-into-table/</link><pubDate>Mon, 03 Oct 2011 10:00:13 +0000</pubDate><guid>https://abapinho.com/2011/10/split-into-table/</guid><description>Aqui vos mostro uma forma criativa de preencher uma tabela interna com constantes que aprendi num programa standard. Imagina que querias criar uma tabela interna com os seguintes tipos de documento financeiro:
AB AF CH DG DZ EX F3 F4.
A forma mais convencional seria assim:
DATA: t_blart TYPE STANDARD TABLE OF blart, wa_blart LIKE LINE OF t_blart. wa_blart = &amp;#39;AB&amp;#39;. APPEND wa_blart TO t_blart. wa_blart = &amp;#39;AF&amp;#39;. APPEND wa_blart TO t_blart.</description></item><item><title>Selecção vertical de texto no editor ABAP não dá? Dá!</title><link>https://abapinho.com/2011/09/seleccao-vertical-de-texto/</link><pubDate>Mon, 26 Sep 2011 10:00:06 +0000</pubDate><guid>https://abapinho.com/2011/09/seleccao-vertical-de-texto/</guid><description>Como todos sabem, pode fazer-se selecções de blocos de texto verticais e horizontais em quase todo o lado do SAPGUI carregando em CTRL-Y e depois arrastando o rato para fazer a selecção. Como todos também sabem, isto não funciona no editor de ABAP. Mas o que provavelmente nem todos sabem é que há uma forma de fazer este tipo de selecções no editor de ABAP: primir e manter o ALT. Assim já podes seleccionar blocos de texto.</description></item><item><title>Parâmetros não parametrizáveis</title><link>https://abapinho.com/2011/09/parametros-nao-parametrizaveis/</link><pubDate>Mon, 12 Sep 2011 10:00:52 +0000</pubDate><guid>https://abapinho.com/2011/09/parametros-nao-parametrizaveis/</guid><description>Volta não volta aparece um cliente que pede a um funcional que pede a um programador que crie um parâmetro protegido contra escrita no ecrã de selecção de um programa. É um bocado cretino visto que a ideia dos parâmetros é serem parametrizáveis.
Mas enfim, vê-se de tudo.
Os clientes têm tanta imaginação que a SAP devia criar um módulo de cinema, SAP CI, especialmente para eles poderem realizar os tantos filmes que lhes vão na cabeça.</description></item><item><title>Saltando alegremente de ELSE em ELSE</title><link>https://abapinho.com/2011/08/alt-clique-para-saltar/</link><pubDate>Mon, 22 Aug 2011 11:02:30 +0000</pubDate><guid>https://abapinho.com/2011/08/alt-clique-para-saltar/</guid><description>Tens à tua frente um daqueles IF ELSEIF ELSEIF ELSEIF ELSEIF ELSE ENDIF gigantescos que atravessa centenas de linhas de código.
Se fizeres duplo clique em cima do IF ou de qualquer dos ELSEIF vais parar ao ENDIF. Se fizeres duplo-clique lá em baixo no ENDIF vais parar lá acima ao IF. Isto toda a gente sabe. Dá jeito com IF ENDIF pequeninos. Já com os grandes, não serve de muito.</description></item><item><title>Saltos dentro do editor ABAP</title><link>https://abapinho.com/2011/08/saltos-no-editor-abap/</link><pubDate>Mon, 15 Aug 2011 10:06:39 +0000</pubDate><guid>https://abapinho.com/2011/08/saltos-no-editor-abap/</guid><description>Nunca te aconteceu estar a programar num programa ABAP daqueles que parecem um testamento com centenas e centenas de linhas e teres de estar sempre a saltar entre uma zona e outra do código?
Até há uns dias eu, ignorante, usava o PageUp e o PageDown para saltar entre os dois sítios e perdia montes de tempo à procura do lugar exacto do código que me interessava.
Mas entretanto o Sérgio Fraga ensinou-me que o editor ABAP tem uma funcionalidade chamada bookmarks que permite evitar o disparate de andar a subir e a descer às apalpadelas.</description></item><item><title>CASE de pernas para o ar</title><link>https://abapinho.com/2011/08/case-de-pernas-para-o-ar/</link><pubDate>Mon, 08 Aug 2011 10:00:47 +0000</pubDate><guid>https://abapinho.com/2011/08/case-de-pernas-para-o-ar/</guid><description>Qual é a tua cor preferida?
SELECTION-SCREEN BEGIN OF BLOCK b1. PARAMETERS: p_azul BUTTONGROUP GROUP COR DEFAULT &amp;#39;X&amp;#39;, p_verde BUTTONGROUP GROUP COR, p_roxo BUTTONGROUP GROUP COR. SELECTION-SCREEN END OF BLOCK b1. Se respondeste azul sobrevives e podes atravessar a ponte.
De qualquer das formas, em ABAP costuma fazer-se o seguinte para descobrir a cor que o utilizador escolheu:
IF p_azul = &amp;#39;X&amp;#39;. lv_cor = &amp;#39;AZUL&amp;#39;. ELSE IF p_verde = &amp;#39;X&amp;#39;. lv_cor = &amp;#39;VERDE&amp;#39;.</description></item><item><title>CTRL-clique para seleccionar uma palavra</title><link>https://abapinho.com/2011/07/ctrl-clique/</link><pubDate>Mon, 18 Jul 2011 11:19:51 +0000</pubDate><guid>https://abapinho.com/2011/07/ctrl-clique/</guid><description>Uma dica simples mas valiosa: em qualquer sítio do SAP GUI - incluindo o editor de ABAP - para seleccionar uma palavra basta fazer CTRL-clique em cima dela. Fixe, não?
Infelizmente não funciona no GUI Java do Mac :-(
(Obrigado ao Sérgio Fraga pela dica)
O Abapinho saúda-vos.</description></item><item><title>RANGE instantâneo - É só juntar água</title><link>https://abapinho.com/2011/07/range-instantaneo/</link><pubDate>Mon, 11 Jul 2011 11:07:07 +0000</pubDate><guid>https://abapinho.com/2011/07/range-instantaneo/</guid><description>Vou ensinar-te uma fórmula mágica para gerar um RANGE em que praticamente é só juntar água.
Imagina que queres fazer um RANGE a partir de uma seleção da base de dados para depois o utilizar num outro SELECT qualquer. Claro que o poderias fazer assim:
DATA: lt_kunnr TYPE STANDARD TABLE OF kunnr, lr_kunnr TYPE RANGE OF kunnr, wa_kunnr LIKE LINE OF lr_kunnr. FIELD-SYMBOLS: &amp;lt;kunnr&amp;gt; LIKE LINE OF lt_kunnr. SELECT kunnr INTO TABLE lt_kunnr FROM kna1.</description></item><item><title>Soneca</title><link>https://abapinho.com/2011/06/soneca/</link><pubDate>Fri, 17 Jun 2011 11:43:28 +0000</pubDate><guid>https://abapinho.com/2011/06/soneca/</guid><description>Volta não volta é preciso meter um programa a dormir. E como em quase tudo, há várias formas de o fazer, e umas formas são melhores do que outras.
A forma mais standard de conseguir isto em ABAP é a seguinte:
WAIT UP TO 10 SECONDS. A vantagem do WAIT UP TO N SECONDS é que o processo é libertado durante estes 10 segundos, ficando assim disponível para quem o quiser apanhar.</description></item><item><title>Várias versões da mesma história</title><link>https://abapinho.com/2011/06/versoes-sap/</link><pubDate>Thu, 09 Jun 2011 13:41:50 +0000</pubDate><guid>https://abapinho.com/2011/06/versoes-sap/</guid><description>Toda a gente sabe que as versões do SAP são uma grande confusão. Os senhores de Heidelberg que brincam a dar os nomes às coisas lá deles ou são uns caprichosos, ou andam a gozar connosco, ou devem andar sempre à bulha.
Aqui fica uma tabelinha para ajudar a deslindá-las:
Ano | UI | Edição | Versão | Versinha | BASIS | WebAS | ECC | NetWeaver
&amp;mdash;|&amp;mdash;|&amp;mdash;|&amp;mdash;|&amp;mdash;|&amp;mdash;|&amp;mdash;|&amp;mdash;|&amp;mdash;
| Terminal</description></item><item><title>Macros globais</title><link>https://abapinho.com/2011/05/macros-globais/</link><pubDate>Thu, 19 May 2011 18:02:41 +0000</pubDate><guid>https://abapinho.com/2011/05/macros-globais/</guid><description>Noutro artigo falámos de macros, uma funcionalidade relativamente obscura e pouco utilizada que tanto pode ser útil como criar uma grande salganhada. Mas estas não são as únicas macros do ABAP. Há outras, ainda mais obscuras e com ainda maior potencial de enfarelhamento de um sistema: as macros globais.
Nem sei se revele isto de tão esquisito que é&amp;hellip; Mas também não me parece bem escondê-lo&amp;hellip; Seja, revelarei.
É possível definir macros a nível global do sistema que podem ser utilizadas em qualquer programa ABAP.</description></item><item><title>Começar com o pé direito</title><link>https://abapinho.com/2011/04/transaccao-inicial/</link><pubDate>Sat, 23 Apr 2011 09:27:25 +0000</pubDate><guid>https://abapinho.com/2011/04/transaccao-inicial/</guid><description>Quando se faz login no SAP normalmente vai parar-se ao menu. Mas pode usar-se o módulo de função NAVIGATION_SET_START_TCODE para pré-definir uma transacção inicial. Vale o que vale, mas é melhor saber que existe do que não saber que existe e ainda melhor do que sabe que não existe. Quem sabe dê jeito a alguns utilizadores. Existe também o módulo de função NAVIGATION_GET_START_TCODE para ver qual está pré-definida.
O Abapinho saúda-vos.</description></item><item><title>Nem o Luís de Matos faria melhor</title><link>https://abapinho.com/2011/04/call-transaction/</link><pubDate>Thu, 21 Apr 2011 11:26:14 +0000</pubDate><guid>https://abapinho.com/2011/04/call-transaction/</guid><description>Às vezes acontece querermos aceder a uma transacção e não termos permissões. É uma chatice. Felizmente existe o módulo de função ALINK_CALL_TRANSACTION que alivia a situação. Mas usa com cuidado, não vá alguém zangar-se. Bem-vindo ao lado negro do Abapinho. Se disserem que fui eu que disse, nego tudo.
(obrigado aoBohman pela foto)
Actualização: com este módulo de função também lá chegas: CALL_TRANSACTION_FROM_TABLE.
Nova actualização: se os outros falharem tenta este módulo de função: RS_HDSYS_CALL_TC_VARIANT (limpando a flag AUTHORITY_CHECK).</description></item><item><title>Bate às portas certas</title><link>https://abapinho.com/2011/04/portas-sap/</link><pubDate>Sat, 02 Apr 2011 08:49:57 +0000</pubDate><guid>https://abapinho.com/2011/04/portas-sap/</guid><description>&lt;p>Para tua conveniência, aqui tens as portas TCP/IP utilizadas pelo &lt;em>NetWeaver Application Server ABAP&lt;/em> e pelo &lt;em>Internet Connection Manager (ICM)&lt;/em> :&lt;/p></description></item><item><title>ABAP Ninja</title><link>https://abapinho.com/2011/03/abapninja/</link><pubDate>Fri, 25 Mar 2011 18:51:10 +0000</pubDate><guid>https://abapinho.com/2011/03/abapninja/</guid><description>Uma das grandes novidades do ERP 6.0 é a Enhancement Framework que é uma espécie de &amp;ldquo;amigo do senhorio&amp;rdquo; que permite dar marteladas em todas as paredes do SAP sem escavacar a pintura. Infelizmente ainda há muito pouca documentação sobre isto e é sempre o cabo dos trabalhos para encontrar o Enhancement Point adequado à martelada desejada.
O site ABAP Ninja tenta ajudar. É um motor de pesquisa de Enhancements. Dizem que têm mais de 13.</description></item><item><title>Santo Isidoro de Sevilha</title><link>https://abapinho.com/2011/03/santo-isidoro-de-sevilha/</link><pubDate>Sun, 20 Mar 2011 17:29:14 +0000</pubDate><guid>https://abapinho.com/2011/03/santo-isidoro-de-sevilha/</guid><description>Não sabes a quem rogar as tuas preces nos momentos de desespero? Já podes ficar descansado. Os programadores têm um santo. Santo Isidoro de Sevilha.
Um senhor muito culto e inteligente que respirou o ar espanhol dos séculos VI e VII que, como diz a Wikipédia, &amp;ldquo;escreveu sobre matemática, astronomia, medicina, anatomia humana, zoologia, geografia, meteorologia, geologia, mineralogia, botânica e agricultura, não acrescentando nada de inovador ou original, não realizou qualquer experiência, não fez novas observações ou reinterpretações e não descobriu nada, mas a influência na Idade média e no Renascimento foi grande&amp;rdquo;.</description></item><item><title>LOOP FROM INDEX</title><link>https://abapinho.com/2011/03/loop-from-index/</link><pubDate>Thu, 10 Mar 2011 12:15:12 +0000</pubDate><guid>https://abapinho.com/2011/03/loop-from-index/</guid><description>É muito fácil meter os pés pelas mãos no que toca a performance quando se manipula tabelas internas. Principalmente quando elas são assim a tender para o grandalhonas. É até comum que estes problemas só surjam passados uns meses, quando as tabelas tendem a crescer com o tempo.
Por exemplo, quando fazes loop a duas tabelas, uma de cabeçalhos e outra de itens, fazes assim?
LOOP AT itab1 ASSIGNING &amp;lt;fs1&amp;gt;. LOOP AT itab2 ASSGNING &amp;lt;fs2&amp;gt; WHERE field1 = &amp;lt;fs1&amp;gt;-field1.</description></item><item><title>Indicador de progresso</title><link>https://abapinho.com/2011/03/indicador-de-progresso/</link><pubDate>Mon, 07 Mar 2011 12:04:18 +0000</pubDate><guid>https://abapinho.com/2011/03/indicador-de-progresso/</guid><description>Sabes aquelas barras de progresso que vão indicando quanto falta para terminar um processo? Aquelas que às vezes quando chegam ao fim voltam ao princípio e te deixam frustrado e baralhado sem entender para que servem afinal? Eis como as podes usar num programa ABAP.
DATA: lv_texto TYPE char40, lv_valor type i. DO 10 TIMES. WAIT UP TO 1 SECONDS. CLEAR lv_texto. lv_valor = sy-index * 10. lv_texto(3) = lv_valor. CONCATENATE lv_texto &amp;#39;%!</description></item><item><title>Executa um comando no teu computador</title><link>https://abapinho.com/2011/02/executar-comando-local/</link><pubDate>Wed, 16 Feb 2011 21:33:38 +0000</pubDate><guid>https://abapinho.com/2011/02/executar-comando-local/</guid><description>Imagina que queres executar um programa no teu PC a partir de um programa ABAP. Não sei porque carga de água quererás tu fazer isto mas ok, se queres mesmo fazer, é assim:
DATA: i_returncode TYPE i. CALL FUNCTION &amp;#39;GUI_EXEC&amp;#39; EXPORTING command = &amp;#39;Notepad.exe&amp;#39; parameter = &amp;#39;eu_sou_um_texto.txt&amp;#39; IMPORTING returncode = i_returncode. É provável que dê para fazer coisas boas com isto. Mas está à vista a grande javardice que se pode fazer por isso pensa bem antes de começares para aí a escangalhar os computadores dos utilizadores todos.</description></item><item><title>SAT - A nova ferramenta de análise de execução</title><link>https://abapinho.com/2011/02/sat/</link><pubDate>Wed, 16 Feb 2011 14:31:40 +0000</pubDate><guid>https://abapinho.com/2011/02/sat/</guid><description>Desde pequenino que uso a transacção SE30 para duas coisas diferentes:
Analisar um programa que desconheço (normalmente standard) para saber que funções usa, que BADIs disponibiliza, etc;
Analisar um programa meu em busca de problemas de performance.
A verdade, nua e crua, é que a transacção SE30 é uma porcaria pegada. Extremamente limitada e inflexível, não dá jeito nenhum para qualquer análise mais complexa.
Aparentemente os senhores da SAP concordam e resolveram substitui-la pela fantástica nova ferramenta SAT - ABAP Runtime Analysis , em tudo mais sofisticada.</description></item><item><title>As estruturas PRE-a-porter</title><link>https://abapinho.com/2011/01/pre-a-porter/</link><pubDate>Tue, 11 Jan 2011 11:51:37 +0000</pubDate><guid>https://abapinho.com/2011/01/pre-a-porter/</guid><description>Quantas vezes não é necessária uma pequena estrutura para guardar, por exemplo, uma lista que relacione materiais e centros. Mas perder tempo a inventar a roda é sempre de evitar.
No reino do MM há uma pequena família de estruturas que uso amiúde: são elas as PRE*, uma série de estruturas que vai desde a PRE01 à PRE50, com uns saltos pelo meio. Embora sejam, na sua maioria, específicas demais para servirem algum propósito, há algumas úteis.</description></item><item><title>A Ressurreição de um programa</title><link>https://abapinho.com/2010/12/ressurreicao/</link><pubDate>Thu, 16 Dec 2010 13:23:34 +0000</pubDate><guid>https://abapinho.com/2010/12/ressurreicao/</guid><description>Batendo impetuoso com seus braços no peito, o famoso guerreiro gritava desesperado: &amp;ldquo;Oh meu Zeus! Apaguei um grande programa , um programa precioso, feito de bronze, forjado por vós deuses no próprio Olimpo. Que será de mim quando isto for descoberto! Oh, ignomínia! Oh, funesto infortúnio! Zeus pai, não te enfureças com tal revés, Se és mesmo meu pai, acode-me ao invés.&amp;rdquo;
Assim falou; e Zeus compadeceu-se dele que chorava, garantindo que seu programa se salvaria e não pereceria.</description></item><item><title>Imprimir para PDF local</title><link>https://abapinho.com/2010/12/imprimir-pdf/</link><pubDate>Wed, 01 Dec 2010 04:25:12 +0000</pubDate><guid>https://abapinho.com/2010/12/imprimir-pdf/</guid><description>Receita rápida:
Manda-se imprimir o que se quer, dizendo ao SAP para guardar a ordem de impressão no spool e não a imprimir imediatamente. Reserva-se o número da ordem de impressão num recipiente à parte.
A seguir, corre-se o programa RSTXPDFT4 , junta-se-lhe o número da ordem de impressão, mistura-se bem e executa-se o dito.
Por fim escolhe-se onde, no computador local, se quer desenformar o ficheiro PDF com o conteúdo da ordem de impressão.</description></item><item><title>Depuração telepática</title><link>https://abapinho.com/2010/11/depuracaotelepatica/</link><pubDate>Fri, 26 Nov 2010 10:55:58 +0000</pubDate><guid>https://abapinho.com/2010/11/depuracaotelepatica/</guid><description>Imagine o seguinte cenário: um utilizador (ou utilizadora) está sentado no escritório dele, a correr uma transacção ou não sei o quê. Tem um problema e chama um programador (ou programadora) para o (ou a) ajudar a entender o que se passa. Normalmente o programador (ou programadora) teria de se deslocar lá, à sala do senhor utilizador (ou senhora utilizadora) e das duas uma: fazer debug no computador dele (ou dela) ou aprender como recriar o problema e depois fazer debug no seu computador.</description></item><item><title>SE37.com</title><link>https://abapinho.com/2010/11/se37-com/</link><pubDate>Wed, 10 Nov 2010 12:52:03 +0000</pubDate><guid>https://abapinho.com/2010/11/se37-com/</guid><description>Neste site pode-se consultar documentação de módulos de função ABAP:
www.se37.com
Basta escolher continue as guest pois a inscrição só é necessária para edição ou adição de conteúdos. E depois é só introduzir um grupo de funções ou um módulo de função para ver a sua documentação.
Actualização: já não existe.
O Abapinho saúda-vos.</description></item><item><title>Pede ajuda aos PDFs da SAP</title><link>https://abapinho.com/2010/11/pdfs-sap/</link><pubDate>Wed, 10 Nov 2010 12:39:55 +0000</pubDate><guid>https://abapinho.com/2010/11/pdfs-sap/</guid><description>A SAP disponibiliza uma série de documentos PDF que contém ajuda e informação preciosa nas mais variadas áreas. Estes PDFs estão dispersos pelos vários sites da SAP, mas alguém no site Easy Service Marketplace compilou todos numa conveniente lista:
www.easymarketplace.de/online-pdfs.php
Obriado Sérgio Fraga por este outro link com mais uma série de PDFs:
sapignite.com/download-sap-pdf-material-abap/.
Espero que vos ajude!
Actualização: Isto parece já não existir.
O Abapinho saúda-vos.</description></item><item><title>Downloadar e uploadar programas e afins</title><link>https://abapinho.com/2010/09/downloadupload/</link><pubDate>Tue, 28 Sep 2010 11:16:37 +0000</pubDate><guid>https://abapinho.com/2010/09/downloadupload/</guid><description>Há palavras em inglês que o português de Portugal não se dá ao trabalho de traduzir. O verbo inglês download vira downloadar ou fazer download. A seu tempo, há-de seguir o caminho que beef seguiu até conseguir chegar a bife , transformando-se lentamente em algo tipo daunelaudar. Mas até lá&amp;hellip; fazem-se downloads.
Já que a SAP nunca se preocupou em permitir o download e upload de objectos do DDIC e do ABAP Workbench, foram sempre aparecendo umas almas caridosas com uns programas mais ou menos medíocres que o permitiam.</description></item><item><title>Pesquisar em tabelas internas simplórias</title><link>https://abapinho.com/2010/09/tabelas-internas-simplorias/</link><pubDate>Tue, 21 Sep 2010 10:36:51 +0000</pubDate><guid>https://abapinho.com/2010/09/tabelas-internas-simplorias/</guid><description>Imagina uma tabela interna tão simplória que nem sequer tem uma estrutura de dados com campos:
DATA: t_simploria TYPE STANDARD TABLE OF char30. Agora imagina que queres fazer uma pesquisa nessa tabela para saber se contém o valor &amp;lsquo;sumo de melão&amp;rsquo;. mas como não tem campos, como a fazes? Normalmente usarias algo tipo WITH KEY campo = valor. Mas ela não tem campos. O ABAP disponibiliza uma palavra especial que resolve este problema: TABLE_LINE.</description></item><item><title>Transacção I18N = Internacionalização</title><link>https://abapinho.com/2010/09/i18n/</link><pubDate>Mon, 06 Sep 2010 13:54:15 +0000</pubDate><guid>https://abapinho.com/2010/09/i18n/</guid><description>Os americanos são tão bons como os tibetanos a arranjar mnemónicas e abreviaturas para tornar as coisas fáceis de decorar.
Internationalization é uma palavra inglesa com 20 letras. Então, a abreviatura adoptada foi I18N, constituida pela primeira e última letras entremeadas por um 18 que representa as 18 letras do meio. Meio maluco mas giro e a verdade é que pegou.
Pegou tanto que o SAP tem uma transacção chamada I18N.</description></item><item><title>É meu, só meu e de mais ninguém</title><link>https://abapinho.com/2010/09/e-meu-so-meu-e-de-mais-ninguem/</link><pubDate>Wed, 01 Sep 2010 14:25:53 +0000</pubDate><guid>https://abapinho.com/2010/09/e-meu-so-meu-e-de-mais-ninguem/</guid><description>Imagina que estás a trabalhar num sistema partilhado por muitos outros utilizadores que não conheces. Como no IDESACCESS por exemplo. Nada impede que, por distracção ou perfídia, algum desses outros utilizadores altere ou mesmo apague os teus programas.
Na SE38, nas características técnicas do programa, existe um pisco chamado &amp;ldquo;Bloqueio do editor&amp;rdquo; que, se o activares, só tu próprio passarás a poder modificá-lo.
O Abapinho saúda-vos.</description></item><item><title>Mensagens entre utilizadores</title><link>https://abapinho.com/2010/08/mensagens-entre-utilizadores/</link><pubDate>Fri, 13 Aug 2010 09:35:39 +0000</pubDate><guid>https://abapinho.com/2010/08/mensagens-entre-utilizadores/</guid><description>Muitas vezes precisamos de aceder aos dados de uma tabela através da SM30 ou a um qualquer documento e esbarramos com uma mensagem a dizer que os dados estão bloqueados por outro utilizador.
Há várias hipóteses:
Ter muita paciência e esperar;
Ter bastante paciência, enviar uma mensagem do SAPOffice e esperar que um dia o utilizador a vá ver;
Ter alguma paciência, enviar um e-mail e esperar;
Ser impaciente, ir ter com o outro e pedir-lhe para por favor sair dali;</description></item><item><title>Enfiar um browser dentro do SAPGui</title><link>https://abapinho.com/2010/06/browser-no-sap/</link><pubDate>Thu, 10 Jun 2010 20:01:45 +0000</pubDate><guid>https://abapinho.com/2010/06/browser-no-sap/</guid><description>Quem não gosta de uma promiscuidadezita de vez em quando? Até o Abapinho. É por isso que hoje vos sugerimos que se deleitem a enfiar um browser dentro do SAPGui. E para conseguir isso basta correr este programa na SE38: SAPHTML_R3HTTP_DEMO.
Pronto, ficam a saber. E como há clientes para tudo, quem sabe não se encontre aí pelo mundo algum cliente que invente um problema para esta solução.
O Abapinho saúda-vos.</description></item><item><title>ZTETRIS</title><link>https://abapinho.com/2010/05/ztetris/</link><pubDate>Sun, 09 May 2010 15:56:34 +0000</pubDate><guid>https://abapinho.com/2010/05/ztetris/</guid><description>O Abapinho aconselha todos os ABAPers a, pelo sim, pelo não, instalarem o programa ZTETRIS no seu ambiente de desenvolvimento. A versão do Tetris para ABAP é da autoria de Sergey Shumakov.
Quando te fartares de jogar podes sempre investigar como é que o programa faz para ir várias vezes ao servidor sem intervenção do utilizador.
O Abapinho saúda-vos.</description></item><item><title>ALV Grid Control - Manuais de referência</title><link>https://abapinho.com/2010/05/alv/</link><pubDate>Tue, 04 May 2010 06:15:24 +0000</pubDate><guid>https://abapinho.com/2010/05/alv/</guid><description>Os ALVs são poderosos. Mas esse poder vem à custa de alguma complexidade. Além disso, como quase tudo em SAP, funcionam de forma obscura. Aqui ficam dois manuais de referência em PDF. São muito parecidos mas suficientemente diferentes para referir os dois.
Este chama-se BCSRVALV, é da SAP e data de 2001. No site da SAP encontra-se aqui. E aqui também se aprende sobre isto.
Já este chama-se ALV_Grid_Control, é de 2004 e está assinado por um senhor chamado Serdar ŞİMŞEKLER que diz ser turco.</description></item><item><title>Transportar conteúdo de uma tabela</title><link>https://abapinho.com/2010/04/conteudo-tabela/</link><pubDate>Thu, 29 Apr 2010 11:26:54 +0000</pubDate><guid>https://abapinho.com/2010/04/conteudo-tabela/</guid><description>Fazes assim:
Vais à transacção SE01;
Crias uma nova ordem de workbench;
Editas a lista de objectos;
Adicionas-lhe o objecto R3TR-TABU-[nome_tabela];
Clicas na chave que aparece na coluna a seguir;
Metes um asterisco * na primeira linha;
Gravas a ordem de transporte;
Pedes a quem de direito para a passar para onde te aprouver;
Vais beber um sumo de melão;
Quando voltas, já está.
O Abapinho saúda-vos.</description></item><item><title>Glossário SAP</title><link>https://abapinho.com/2010/04/glossario-sap/</link><pubDate>Tue, 27 Apr 2010 10:09:32 +0000</pubDate><guid>https://abapinho.com/2010/04/glossario-sap/</guid><description>É frequente em SAP cruzarmo-nos com um conceito desconhecido. Às vezes esqueço-me de que há ferramentas disponíveis muito fáceis de consultar. E o glossário SAP é um exemplo disso. Pode ser acedido de várias formas:
No próprio SAP: através da transacção STERM;
Online: num site da SAP: https://help.sap.com/saphelp_glossary/en/;
No nosso computador: usando o programa ABAP GLOS_DOWNLOAD_HTML para fazer download de todo o seu conteúdo.
Tenho a certeza de que, agora que sei onde está, o vou consultar muito mais vezes.</description></item><item><title>Onde é que eu vi aquilo?</title><link>https://abapinho.com/2009/11/busca-abap/</link><pubDate>Wed, 04 Nov 2009 04:09:36 +0000</pubDate><guid>https://abapinho.com/2009/11/busca-abap/</guid><description>A pesquisa de objectos em ABAP e por todo o SAP é normalmente feita de duas formas: listando objectos de um tipo através de search helps ou procurando objectos em que um determinado objecto é usado, através da opção where used.
Só que às vezes o que buscamos não se trata de um objecto mas sim de uma frase qualquer ou mesmo um comentário que sabemos existir no código mas não fazemos ideia de onde.</description></item><item><title>A técnica das Matrioskas</title><link>https://abapinho.com/2009/10/matrioskas/</link><pubDate>Fri, 09 Oct 2009 13:00:55 +0000</pubDate><guid>https://abapinho.com/2009/10/matrioskas/</guid><description>É sabido que quando é necessário fazer uma pequena alteração a uma função standard para a qual não há nenhum tipo de user-exit, o mais normal é fazer uma cópia dela para uma função Z e lá proceder à alteração necessária.
No entanto, quando esta alteração pode ser feita no início ou no final do programa, há uma forma mais elegante de conseguir o mesmo resultado: a técnica das Matrioskas. Criar uma função Z com os mesmos parâmetros que lá dentro invoca a função standard e que, além disso, antes ou depois de a invocar, tem o código para implementar a alteração necessária.</description></item><item><title>Evitar mensagens dinâmicas</title><link>https://abapinho.com/2009/09/evitar-mensagens-dinamicas/</link><pubDate>Mon, 07 Sep 2009 17:40:15 +0000</pubDate><guid>https://abapinho.com/2009/09/evitar-mensagens-dinamicas/</guid><description>Qual é, digam lá, a melhor coisinha que o ABAP tem? É, digo eu, poder fazer where used em cima de tudo o que mexe.
E no entanto, esta maravilhosa funcionalidade só funciona maravilhosamente quando as coisas não são invocadas dinamicamente. Eu uso o where used amiúde para descobrir onde uma determinada mensagem está a ser usada. Ora não é nada incomum encontrar chamadas dinâmicas a mensagens, principalmente em casos onde as mensagens não são enviadas directamente para o utilizador mas sim, por exemplo, para o Application Log.</description></item><item><title>READ TABLE blablabla TRANSPORTING NO FIELDS</title><link>https://abapinho.com/2009/08/transporting-no-fields/</link><pubDate>Thu, 20 Aug 2009 04:51:19 +0000</pubDate><guid>https://abapinho.com/2009/08/transporting-no-fields/</guid><description>Por vezes ao fazer READ TABLE a uma tabela interna queremos apenas verificar se um determinado registo existe, e não nos preocupamos com os dados retornados. Algo tipo:
READ TABLE lt_kna1 INTO wa_kna1 WITH KEY kunnr = l_kunnr. CHECK SY-SUBRC = 0. Ora já que a estrutura WA_KNA1 não vai ser necessária de qualquer forma, mais vale não a usar, usando antes a opção TRANSPORTING NO FIELDS:
READ TABLE lt_kna1 TRANSPORTING NO FIELDS WITH KEY kunnr = l_kunnr.</description></item><item><title>Pesquisa SAP no Firefox e no Internet Explorer</title><link>https://abapinho.com/2009/06/pesquisa-sap-firefox/</link><pubDate>Thu, 18 Jun 2009 14:44:23 +0000</pubDate><guid>https://abapinho.com/2009/06/pesquisa-sap-firefox/</guid><description>Quando se faz desenvolvimentos em ABAP, pesquisar na SAP Community ou nas notas e na documentação da SAP é uma actividade recorrente. Como tal, quanto mais fácil for fazê-lo, melhor. Ideal seria que fazê-lo fosse tão fácil como pesquisar no Google. Ora uns senhores chamados JNYSolutions tornaram isso possível criando plugins de pesquisa para o Firefox e o Internet Explorer que adicionam a SDN, as notas e a documentação da SAP como motores de busca.</description></item><item><title>Verificar pasta</title><link>https://abapinho.com/2009/06/verificarpasta/</link><pubDate>Sat, 13 Jun 2009 20:40:29 +0000</pubDate><guid>https://abapinho.com/2009/06/verificarpasta/</guid><description>Eis uma função para verificar se uma pasta existe e se nela temos permissões de escrita.
PARAMETERS: p_dir TYPE btctext80 DEFAULT &amp;#39;/usr/sap/trans&amp;#39;. CALL FUNCTION &amp;#39;PFL_CHECK_DIRECTORY&amp;#39; EXPORTING directory = p_dir write_check = &amp;#39;X&amp;#39; * FILNAME = &amp;#39; &amp;#39; EXCEPTIONS pfl_dir_not_exist = 1 pfl_permission_denied = 2 pfl_cant_build_dataset_name = 3 pfl_file_not_exist = 4 others = 5. CASE sy-subrc. WHEN 0. WRITE /: &amp;#39;Directory:&amp;#39;, p_dir, &amp;#39; exists&amp;#39;. WHEN 1. WRITE /: &amp;#39;Directory does not exist:&amp;#39;, p_dir.</description></item><item><title>Testar na SE37 não grava dados? Grava.</title><link>https://abapinho.com/2009/05/se37-gravar/</link><pubDate>Wed, 20 May 2009 10:40:40 +0000</pubDate><guid>https://abapinho.com/2009/05/se37-gravar/</guid><description>Uma forma prática de aprender a usar um módulo de funções ou verificar se este nos é útil é através da funcionalidade de teste da transacção SE37. Escolhe-se o módulo de função, faz-se F8 (Executar) e tem-se uma forma interactiva de testar uma função.
Isto é óbvio.
O que não será óbvio para toda a gente é que este teste não faz COMMIT à transacção e, por isso, qualquer alteração que a função possa fazer à base de dados - como gerar um documento por exemplo - não é gravada.</description></item><item><title>A transacção N</title><link>https://abapinho.com/2009/05/transaccao-n/</link><pubDate>Thu, 14 May 2009 12:44:21 +0000</pubDate><guid>https://abapinho.com/2009/05/transaccao-n/</guid><description>É intrigante o porquê de, nos dias que correm, a transacção SE16 continuar a ser tão utilizada, quando já existe há tantos anos uma muito melhor, a SE16N.
A transacção SE16N tem mais:
sainete: tem um interface mais dinâmico e sofisticado;
simpatia: mostra em simultâneo a descrição funcional e o nome técnico dos campos;
sabedoria: mostra em simultâneo o valor interno e externo dos campos com rotinas de conversão;
E pode, vejam só, ser também invocada através da transacção N.</description></item><item><title>O Abapinho saúda-vos</title><link>https://abapinho.com/2009/03/inicio/</link><pubDate>Thu, 19 Mar 2009 10:51:11 +0000</pubDate><guid>https://abapinho.com/2009/03/inicio/</guid><description>Bem-vindo ao Abapinho, um blog sobre ABAP em português.</description></item></channel></rss>