ABAP para funcionales

ABAP para funcionales - Parte 1

FORMACIÓN CON INSTRUCTOR

Versión del curso: 3.0

Duración del curso: 9 días

1
 Contenido

Contents
Introduccion al lenguaje ABAP ........................................................................................................................................ 7
Lección 1 - ABAP Repository ............................................................................................................................................ 8
Estructura del repositorio ABAP .................................................................................................................................. 9
Método de acceso al ABAP Repository...................................................................................................................... 11
Herramientas de búsqueda del ABAP Repository ..................................................................................................... 12
Object Navigator ........................................................................................................................................................ 13
Herramientas de Workbench ABAP ........................................................................................................................... 13
ABAP Dictionary: .................................................................................................................................................... 13
Screen Painter: ...................................................................................................................................................... 13
Menu Painter: ........................................................................................................................................................ 13
Function Builder: ................................................................................................................................................... 13
Generador de clases: ............................................................................................................................................. 13
Disposición de pantalla del Object Navigator ............................................................................................................ 14
Utilización del área de navegación ........................................................................................................................ 15
Organizar proyectos de desarrollo ABAP ................................................................................................................... 17
Transporte de objetos de desarrollo ..................................................................................................................... 17
Creación de paquetes ............................................................................................................................................ 18
Especificación de ruta de transporte y capas ........................................................................................................ 19
Pasos para crear un paquete ................................................................................................................................. 20
Ejercicio 1 - Crear un Paquete y Orden de transporte ............................................................................................... 22
Tipos de programas ABAP ........................................................................................................................................ 23
Programas Ejecutables: ............................................................................................................................................. 23
Flujo de proceso de un programa ejecutable: ....................................................................................................... 24
Programas de diálogo: ............................................................................................................................................... 24
Flujo de proceso en un programa de diálogo: ....................................................................................................... 25
Características del lenguaje de programación ABAP ................................................................................... 26
Sintaxis ABAP general I .............................................................................................................................................. 27
Características de la sintaxis ABAP ........................................................................................................................ 27
Sintaxis ABAP general II ............................................................................................................................................. 28
Características adicionales de la sintaxis ABAP ..................................................................................................... 28
Documentación de palabras clave en el Editor ABAP .................................................................................. 29
Activación de programas ................................................................................................................................... 30

2
 Generación de objetos de tiempo de ejecución ........................................................................................................ 31
Ejercicio 2 - Desarrollar un programa ABAP sencillo ..................................................................................................... 32
Creación de transacciones ............................................................................................................................................. 33
Ejercicio 3 - Crear una transacción ................................................................................................................................ 35
Introducción al diccionario ABAP .................................................................................................................................. 36
La transacción para ingresar al diccionario es SE11 .................................................................................................. 37
Definiciones de tipos en el diccionario ABAP ............................................................................................................ 39
Servicios del diccionario ABAP ................................................................................................................................... 40
Enlace con el entorno de desarrollo y de tiempo de ejecución ................................................................................ 41
Diálogos de actualización .............................................................................................................................................. 43
Ejercicio 4 - Crear una tabla con diálogo de actualización: ........................................................................................... 46
Introcucción a eventos en ABAP .................................................................................................................................... 47
Ejercicio 5 - Utilización de eventos ................................................................................................................................ 50
Elementos básicos del lenguaje ABAP ........................................................................................................................... 51
Tipos de datos y objetos de datos ............................................................................................................................. 51
Tipos de datos estándar ABAP ................................................................................................................................... 52
Tipos de datos estándar ABAP completos ............................................................................................................. 52
Tipos de datos estándar ABAP incompletos .......................................................................................................... 52
Tipos de datos locales ................................................................................................................................................ 53
Tipos de datos globales ............................................................................................................................................. 53
Definición de objetos de datos variables ....................................................................................................................... 55
Ejemplos de definición de objetos de datos elementales ............................................................................................. 56
Sentencias básicas ABAP ............................................................................................................................................... 58
Cálculos y expresiones aritméticas ............................................................................................................................ 59
Condicionales y expresiones lógicas .......................................................................................................................... 60
Sentencias LOOPS o repetitivas. ................................................................................................................................ 61
Creación de Mensajes. ............................................................................................................................................... 62
Trabajando con ABAP Debugger.................................................................................................................................... 63
Selection Screen ............................................................................................................................................................ 66
Declarando campos como parámetros...................................................................................................................... 67
Ejercicio 6 – Programa con pantalla de selección .......................................................................................................... 68
Trabajando con Estructuras ........................................................................................................................................... 69
Trabajando con ABAP Debugger.................................................................................................................................... 71
Trabajando con Tablas Internas .................................................................................................................................... 72
Tipos de tablas ........................................................................................................................................................... 73
STANDARD TABLES ................................................................................................................................................ 73
SORT TABLES .......................................................................................................................................................... 73

3
 HASHED TABLES ..................................................................................................................................................... 73
Ejercicio 7 – Tablas internas .......................................................................................................................................... 84
Acceso a base de datos .................................................................................................................................................. 85
Recuperación de una fila de datos ............................................................................................................................ 87
Campos de la estructura de destino con los mismos nombres que los de la lista de campos .................................. 89
Recuperación de datos mediante un array fetch ...................................................................................................... 90
Problemas generales del rendimiento de la base de datos ....................................................................................... 91
Índices de bases de datos ...................................................................................................................................... 91
Acceso mediante campos no clave ........................................................................................................................ 92
Acceso mediante índice secundario ...................................................................................................................... 93
Mecanismo de enlace para unión de tablas (JOIN) ............................................................................................... 94
Entradas para definir una unión de tablas................................................................................................................. 95
Definición de unión de tablas ................................................................................................................................ 95
Opciones de implementación para uniones de tablas .......................................................................................... 96
Métodos para implementar un enlace de tablas .................................................................................................. 96
Ejercicio 8 - Implementar un acceso a un registro individual de una tabla ................................................................... 97
Ejercicio 9 - Implementar un acceso a múltiples registros de una tabla mediante arrayfetch ..................................... 98
Subrutinas en lenguaje ABAP ........................................................................................................................................ 99
Modularización mediante subrutinas dentro de programas ................................................................................... 100
Definición de parámetros para subrutinas .......................................................................................................... 101
Transferencia de parámetros: definición de una interfaz ................................................................................... 102
Maneras de transferir parámetros de interfaz .................................................................................................... 103
Definición y llamada de subrutinas...................................................................................................................... 104
Proceso de definición de subrutinas.................................................................................................................... 104
Especificación de tipo de parámetros de interfaz ............................................................................................... 106
Objetos de datos locales y globales ......................................................................................................................... 107
Ejercicio 10 - Subrutinas .............................................................................................................................................. 108
Utilización de ABAP List Viewer (ALV) ......................................................................................................................... 109
Incorporando un ALV en un programa .................................................................................................................... 110
Arquitectura de la pantalla de selección ..................................................................................................................... 114
Ventajas de las pantallas de selección......................................................................................................................... 115
Opciones de entrada en la pantalla de selección .................................................................................................... 119
Declarando Campos con Select Options .................................................................................................................. 121
Authority-Check ........................................................................................................................................................... 125
Capítulo 9 - Sentencias útiles ABAP ............................................................................................................................ 127
CONCATENATE ............................................................................................................................................................. 127
SPLIT ............................................................................................................................................................................ 128

4
COMMIT WORK ........................................................................................................................................................... 129
TRANSLATE .................................................................................................................................................................. 129
CONDENSE ................................................................................................................................................................... 130
UNPACK ....................................................................................................................................................................... 131
Capítulo 10 - Módulo de funciones ............................................................................................................................. 132
Grupo de funciones ..................................................................................................................................................... 134
Ejercicio 11 - Crear un Grupo de Funciones ................................................................................................................ 137
Creando Modulo de Funciones:................................................................................................................................... 138
Estructura del grupo de funciones .............................................................................................................................. 141
Ejercicio 12 - Crear un Módulo de Funciones .............................................................................................................. 143
Llamado de módulo de funciones: .............................................................................................................................. 144
Ejercicio 13 - Uso de declaraciones globales en un grupo de funciones. .................................................................... 146
Qué es un módulo de función RFC?............................................................................................................................. 147
Cómo crear una RFC?............................................................................................................................................... 147
RFC( Remote Function Call ) en SAP R/3 .................................................................................................................. 148
Business Application Programming Interface (BAPI) - SAP R/3 ................................................................................... 150
Ventajas de usar BAPI .............................................................................................................................................. 150
Listado de BAPIs SAP: .............................................................................................................................................. 150
Capítulo 11 – Ampliaciones en SAP ............................................................................................................................. 152
Ventajas: .................................................................................................................................................................. 152
Desventajas: ............................................................................................................................................................ 152
Tipos de ampliaciones ................................................................................................................................................. 153
User Exit ................................................................................................................................................................... 154
Ventajas ............................................................................................................................................................... 154
Desventajas.......................................................................................................................................................... 155
Pasos para realizar un User Exit............................................................................................................................... 155
Field Exit................................................................................................................................................................... 159
Ventajas ............................................................................................................................................................... 159
Desventajas.......................................................................................................................................................... 159
Pasos para realizar un Field Exit .......................................................................................................................... 160
Screen Exit ............................................................................................................................................................... 164
Ventajas ............................................................................................................................................................... 164
Desventajas.......................................................................................................................................................... 164
Pasos para realizar un Screen Exit ....................................................................................................................... 164
Menu Exit ................................................................................................................................................................. 167
Ventajas ............................................................................................................................................................... 167
Desventajas.......................................................................................................................................................... 167

5
 Pasos para realizar un Menu Exit......................................................................................................................... 167
Include en tablas transparentes .............................................................................................................................. 173
Ventajas ............................................................................................................................................................... 173
Desventajas.......................................................................................................................................................... 173
Pasos para realizar un Include a Tabla Transparente .......................................................................................... 173
Enhancement-Point ................................................................................................................................................. 177
Transacciones relacionadas ......................................................................................................................................... 179
Capítulo 12 - IDOCs ...................................................................................................................................................... 180
Introducción ................................................................................................................................................................ 180
Características / Estructura ......................................................................................................................................... 180
IDOCs – Transacción WE02/WE05 ............................................................................................................................... 182
Transacción BD87 ........................................................................................................................................................ 182
Transacción WE19 ....................................................................................................................................................... 183
Creación – Paso 1 (segment type) ............................................................................................................................... 184
Creación – Paso 2 (Idoc Type) ...................................................................................................................................... 185
Creación – Paso 3 (Message Type ) ............................................................................................................................. 186
Creación – Paso 4 (Relación Message -IDOC ) ............................................................................................................. 187
Creación – Paso 5 (Parthner Profile) ............................................................................................................................ 187
Creación – Pasos adicionales ....................................................................................................................................... 188
Creación – Logical System ........................................................................................................................................... 188
Creación – Logical System ........................................................................................................................................... 189
Creación – Modelo de Distribución ............................................................................................................................. 190
Creación – Ports........................................................................................................................................................... 191
IDocs – De salida .......................................................................................................................................................... 191
IDOCs – De salida - Programa ABAP ..................................................................................................................... 191
IDOCs – De salida – Punteros....................................................................................................................................... 193
Ejercicio 14: Creacion de un IDoc ................................................................................................................................ 198

6
Introduccion al lenguaje ABAP
ABAP (Advanced Business Application Programming) es un lenguaje de cuarta generación,
propiedad de SAP, que se utiliza para programar la mayoría de sus productos.

Utiliza sentencias de Open SQL para conectarse con prácticamente cualquier base de datos.
Cuenta con miles de funciones para el manejo de archivos, bases de datos, fechas, etc. Permite
conexiones RFC (Remote Function Calls) para conectar a los sistemas SAP con cualquier otro
sistema o lenguaje de programación.

ABAP fue desarrollado por SAP como lenguaje de informes para SAP R/2 en los años 80, una
plataforma que permitía a las grandes corporaciones construir aplicaciones de negocios para
gestión de materiales y finanzas. ABAP, muy parecido al COBOL en sus orígenes, originalmente
significaba Allgemeiner Berichtsaufbereitungsprozessor, palabras alemanas para procesador
genérico para la preparación de informes. En sus inicios ABAP incluía el concepto de Bases de
datos lógicas, que suministraba un alto nivel de abstracción para el acceso a bases de datos.

ABAP fue pensado como un lenguaje de programación para que los usuarios finales pudieran
manipular la información, pero el 4GL se fue volviendo demasiado complicado para usuarios
normales, por lo que es necesario programadores experimentados para realizar desarrollos.

ABAP se mantuvo como el lenguaje de desarrollo para la siguiente versión cliente-servidor de

SAP R/3, que fue lanzada al mercado en 1992, en el que casi todo el sistema, menos las llamadas
al sistema básicas estaban escritas en ABAP. En 1999, con el lanzamiento de la décima versión
4.6 de R/3, SAP lanzó una extensión orientada a objetos denominada ABAP Objects.

Una versión posterior de la plataforma de desarrollo de SAP fue NetWeaver, la cual soportaba
ABAP y Java como lenguajes de programación, y actualmente con la nueva versión S/4 se
encuentra el entorno de desarrollo Fiori para todos los desarrollos de tipo web o para dispositivos
móviles.

7
 Introducción al
Capítulo 1 Workbench ABAP

Lección 1 - ABAP Repository

8
El Repository consiste en todos los objetos de desarrollo del sistema, como programas, módulos de
funciones, definiciones de tablas de base de datos, y demás componentes del entorno ABAP ya sean
definidos por SAP, o desarrollados por el cliente.
El Repository se encuentra en la base de datos y es independiente de mandante. Esto significa que los
componentes del repositorio pueden ser visualizados desde cualquier mandante dentro de un servidor.
La base de datos contiene datos de aplicación y de customizing, siendo en general datos
dependientes del mandante. Esto significa que cada registro de datos se asigna a un mandante
particular y solo pueden leerlo y modificarlo los usuarios que han entrado al sistema en este
mandante concreto.

Estructura del repositorio ABAP

El sistema subdivide el repositorio de acuerdo con los componentes de aplicación.
Un componente de aplicación, por ejemplo, gestión de materiales (MM), consiste en varios paquetes que
contienen objetos relevantes para una subdivisión lógica más detallada. Siempre que se crea un objeto de
repositorio, debe asignarse a un paquete.

Es posible que algunos objetos de repositorio tengan sub objetos que, a su vez, sean objetos de repositorio.
Además, los objetos de repositorio pueden hace r referencia a otros objetos de repositorio.

El repositorio consiste en todos los objetos de desarrollo del sistema, como programas,
definiciones de tablas (diccionario de datos), módulo de funciones, y demás componentes del
lenguaje ABAP y configuraciones del sistema. Dentro de los objetos del repositorio encontramos
objetos proporcionados por SAP (objetos estándar) y objetos específicos y definidos en exclusiva
por el cliente (objetos Z)

En el caso de los objetos correspondientes al lenguaje ABAP, los mismos se encuentran en el repositorio
como objetos independientes de mandante, mientras que el customizing en general, es dependiente del
mandante y debemos transportarlo dentro del servidor para hacer pruebas en uno u otro mandante.

El repositorio se subdivide según los componentes de aplicación, se puede decir se subdivide en

los diferentes módulos de SAP (MM, CO, FI, HR, etc). Pero el hecho de decir que se subdividen
no significan que sean excluyentes, es decir, en la ramificación de los módulos hay objetos que se
pueden compartir entre diferentes módulos.

9
10
Método de acceso al ABAP Repository
Para acceder al Sistema de información del ABAP Repository, realice los pasos siguientes:

En el menú SAP Easy Access, seleccione Herramientas → Workbench ABAP → Resumen → Sistema de
información, o bien puede ejecutar la transacción SE84.

Al ingresar debe seleccionar el tipo de objeto a tratar mediante un doble clic en un tipo de objeto indicado,
tras lo cual una pantalla de selección aparece y le permite limitar su búsqueda.

11
Herramientas de búsqueda del ABAP Repository
El sistema de información del repositorio ABAP es adecuado para la búsqueda de objetos del repositorio
independientemente de la aplicación a la cual se encuentre asociado el objeto.
Mediante el sistema de información del repositorio ABAP podemos buscar todos los programas realizados
por un programador determinado, los módulos de funciones modificados después de una fecha concreta, o
cualquier objeto que sea requerido buscar.

La siguiente imagen ilustra el modo de uso del sistema de información del repositorio ABAP.

12
Object Navigator
El Workbench ABAP incluye todas las herramientas necesarias para crear y tratar objetos de Repository.
Estas herramientas cubren todo el ciclo de desarrollo del software que pueda requerir una empresa.

Herramientas de Workbench ABAP

El Workbench ABAP se compone de diversar herramientas entre las cuales podemos describir las
principales del siguiente modo:

Editor ABAP:
Transacción:
SE38
Función:
Se utiliza para editar el código fuente dentro de SAP.

Toda modificación a realizar sobre un programa ABAP se realiza desde esta transacción, como asi también
al momento de efectuar debug sobre un programa, se utiliza esta misma transacción.
En algún caso puede suceder que no se posea permisos para la transacción SE38 al momento de realizar
debug, y se pueda utilizar la transacción SA38, la cual solo sirve de consulta de programas, sin posibilidad
de modificación de código desde esta última transacción.

ABAP Dictionary:
Transacción: SE11
Función:
Se utiliza para visualizar y/o editar definiciones de tabla de base de datos, tipos de datos y otras entidades.
En caso de no contar con permisos ejecutar la transacción SE11, se puede utilizar para visualización la
transacción SE12, la cual solo sirve para visualizaciones.

Screen Painter:
Transacción: SE51
Función:
Se utiliza para configurar pantallas junto con funciones para diálogos de usuario.

Menu Painter:
Transacción: SE41
Función:
Se utiliza para diseñar componentes de interfaces de usuario como barra de menú, barra de herramientas
estándar, barra de herramientas de aplicación y opciones de teclas de función.

Function Builder:
Transacción: SE37
Función:
Se utiliza para actualizar módulos de funciones / funciones ABAP.

Generador de clases:
Transacción: SE24
Función:
Se utiliza para actualizar clases e interfaces globales.

13
Puede tener una lista de los objetos de Repository necesarios en esta herramienta de desarrollo central.
Para editar uno de los objetos del repositorio, debe hacer doble clic sobre él tras lo cual automáticamente se
llamará a la herramienta correspondiente para editar el objeto seleccionado.

Disposición de pantalla del Object Navigator

La pantalla del Object Navigator está dividida en las siguientes áreas:

Area de navegación:
Se utiliza para visualizar una lista de objetos jerárquica
Area de herramientas
Se utiliza para visualizar y tratar un objeto de desarrollo mediante la herramienta adecuada.
Puede visualizar u ocultar el área de navegación en función de cómo desee visualizar la pantalla o al
momento de haber seleccionado un objeto y estar tratándolo.

En ambas áreas, puede elegir las funciones mediante un menú contextual, al cual accede con el botón
derecho del ratón. El menú contextual ofrece solamente las funciones diseñadas para el objeto
correspondiente.

14
Utilización del área de navegación

El sistema visualiza las listas de objeto en el área de navegación. Por ejemplo, si elige visualizar
un paquete, se mostrarán todos los objetos de repositorio ABAP que pertenezcan al paquete
especificado, mientras que si hace doble clic en un objeto, podrá visualizarlo o tratarlo.

Puede navegar entre las listas de objetos que se han visualizado anteriormente en la sesión de
Object Navigator actual (flechas azules).

Puede añadir objetos de uso frecuente a sus favoritos.

Sincronización de las áreas de navegación y de herramientas

15
En caso necesario, puede sincronizar ambas áreas como se describe a continuación:

Puede visualizar un objeto en el área de herramientas haciendo doble clic en el área de

navegación o utilizando la función correspondiente del menú contextual del objeto.

Puede visualizar la lista de objetos de un objeto que se esté editando en el área de herramientas
mediante el botón Visualizar lista de objetos en el área de navegación.

Para crear un objeto nuevo, use el menú contextual para un tipo de objeto de la lista de objetos
correspondiente. Como alternativa, seleccione Editar objeto u Otro objeto para crear un objeto.

16
Organizar proyectos de desarrollo ABAP

Transporte de objetos de desarrollo

Los proyectos de desarrollo se llevan a cabo en un sistema de desarrollo. Los objetos de desarrollo tratados
o creados en un proyecto se transportan a sistemas subsiguientes (sistema de test y/o producción) al
finalizar el proyecto. Al inicio de un proyecto de desarrollo, el gestor de proyectos crea una orden de
transporte, en la cual nombra a los empleados del proyecto en el Transport Organizer o directamente en el
Workbench ABAP.

A continuación, el Transport Organizer crea una tarea para cada empleado del proyecto en la orden de
transporte. Al tratar o crear un objeto de desarrollo, el empleado relevante lo asigna a la orden de transporte.
El objeto se indica en la tarea del empleado. Todos los objetos de Repository en los que trabaja un
empleado durante un proyecto de desarrollo se recopilan en su tarea.

Transporte de ordenes dentro del servidor de desarrolle, entre mandantes

Para este fin contamos con la transacción SCC1. Esta transacción será utilizada en los casos en
que se deban copiar objetos dependientes de mandante desde un mandante a otro. Esta
transacción no transporta las órdenes sino que copia el contenido. Se utiliza mayormente con
órdenes de customizing y también con algunas órdenes de workbench, por ejemplo las que
contienen formularios SAPscript.

17
Creación de paquetes

Los atributos del paquete tienen el significado siguiente (puede obtener información detallada
mediante el campo de ayuda F1):

Componente de aplicación:
Determine la ubicación del paquete dentro de la jerarquía de aplicaciones especificando el
componente de aplicación correspondiente.

Componente de software:
Para los desarrollos de cliente, indique HOME como componente de software.

Capa de transporte:
La capa de transporte determina si los objetos del paquete se deben transportar a un sistema
subsiguiente y, si es así, a cuál. Para los desarrollos de cliente debe especificar la capa de
transporte que su administrador de sistema fijó para este fin.

Paquete superior directo

El paquete superior inmediato (o el sinónimo "paquete que lo rodea") hace referencia al paquete que
contiene el paquete actual como sub paquete directo basándose en la jerarquía de paquetes. La
jerarquía de paquetes ordena todos los paquetes en forma de varios árboles: Cada paquete posee
(potencialmente) varios sub paquetes y, a su vez, puede ser el subpaquete de un paquete que lo
rodea.

Tipo de paquete:
Seleccione entre los tres tipos de paquetes:
Paquete de desarrollo - puede contener objetos del repositorio y otros paquetes
Paquete principal - solo puede contener otros paquetes
Paquete de estructura - solo puede contener los paquetes principales.

Indicador para la encapsulación de paquete:

Cuando se activa esta propiedad de paquete, el paquete se encapsula. Como resultado, solo
estarán visibles al exterior los elementos de desarrollo expuestos en las interfaces del paquete.
Los posibles paquetes de cliente necesitan accesos de uso a esas interfaces de paquetes que
contienen los elementos de desarrollo utilizados.

18
Especificación de ruta de transporte y capas

SAP es una solución que utiliza varios entornos para el ciclo de vida del software. Esto significa
que se inicia trabajando en un entorno de desarrollo y todo el trabajo va pasando por las capas de
transporte definidas desde el entorno de desarrollo hasta el entorno de producción pasando por el
entorno de pruebas.

Esta es una manera de determinar un sistema de integración y consolidación para los objetos a
transportar.

Una capa de transporte se asigna a cada clase de desarrollo y por tanto a todos los objetos en
esa clase. La capa de transporte determina en qué sistema se desarrolla y se realizan los cambios
al repositorio de objetos. También determina si los objetos se transportan a otros sistemas dentro
del grupo cuando el desarrollo se ha completado.

19
Incluso en una infraestructura de sistema simple necesita al menos dos capas de transporte
diferente para distinguir entre los desarrollos de cliente y las modificaciones a los objetos SAP. En
una infraestructura de sistema más compleja pueden existir capas de transporte adicionales con
diferentes sistemas de destino.

Esta capa de transporte se asigna al sistema de desarrollo como su capa de

transporte estándar. Los objetos entregados por SAP pertenecen a la capa de transporte “SAP”.

Pasos para crear un paquete

Al momento de crear un programa, podemos crearlo directamente o hacerlo a través de un

paquete, en veremos cómo crear un paquete y luego guardar el programa dentro del paquete
creado.

En la lista desplegable escogemos paquete, escribimos el nombre del paquete y ENTER, nos
pedirá crear el objeto:

20
Agregamos una descripción y crear:
En el área de navegación, seleccione el tipo de objeto Paquete e indique el nombre del paquete
en el campo de entrada debajo, asegurándose de que cumpla con las convenciones del cliente
para fijar nombres. Pulse ENTER. Si el paquete especificado no existe todavía, el sistema abrirá
un diálogo para crear un paquete. En la ventana de diálogo, busque la opción de especificar un
paquete e indique el nombre del paquete. Para crear el objeto, presione F5.

Fije los atributos del paquete que se deben crear.

Una vez completos los datos del paquete, asigne el mismo a una orden de transporte.

21
Ejercicio 1 - Crear un Paquete y Orden de transporte
Durante el presente curso se deberán generar diversos objetos ABAP. Para ordenar los objetos
dentro de un paquete de objetos ABAP, se solicita crear un nuevo paquete en base a la siguiente
nomenclatura: ZABAPFmmyyyy##

ZABAPF: Texto fijo

mmyyyy : Mes y año del curso
##: Corresponde al número de grupo asignado a cada asistente.

Para la descripción de la orden de transporte utilizaremos ABAPF-mmyyyy-## Ejercictación ABAP

Funcionales utilizando la misma lógica del nombre del paquete.

ABAPF: Texto fijo

mmyyyy : Mes y año del curso
##: Corresponde al número de grupo asignado a cada asistente.

22
Tipos de programas ABAP
En ABAP podemos crear básicamente dos tipos de programas, los de tipo Ejecutable o Report y
los de Diálogo o también llamados Modulpool. Si bien ambos son programas ABAP, cada uno
tiene un fin diferente dentro del ambiente de SAP.

Programas Ejecutables:
Este tipo es el más común de todos y el que mayormente desarrollamos. Son los programas que
tienen una primer pantalla que llamamos pantalla de selección donde colocamos algunos datos
que van a servir como filtro o información para el proceso a realizar y luego cuando le damos click
al botón ejecutar (o la tecla F8), se procesan los datos y muestra el resultado en una nueva
pantalla de salida.
Las pantallas en SAP se las denomina dynpro y se las numera con un número de 4 dígitos. Los
programas ejecutables habitualmente tienen una única pantalla de selección que lleva el número
1000, eventualmente podemos por programa definir que exista más de una pantalla de selección.
La pantalla de selección es una pantalla que el sistema arma automáticamente en función de
algunos datos que definimos en el programa mediante diferentes instrucciones que servirán para
que el usuario pueda cargar los parámetros de selección y luego ejecutar el reporte.

Este tipo de programas pueden ser utilizados para ejecución en proceso de fondo mediante Jobs,
o lanzados desde el editor ABAP sin necesidad de tener una transacción asociada.

23
Flujo de proceso de un programa ejecutable:

El Flujo de un programa ejecutable es sencillo, mientras no se presione el botón ejecutar se

mantendrá en la pantalla de selección, en ese momento se pueden ejecutar algunas validaciones
sobre los datos mediante los diferentes eventos que se ejecutan al operar sobre la pantalla de
selección del reporte.
Luego de presionado el botón ejecutar, el programa ejecuta todo el proceso tomando la
información definida en la pantalla de selección, eventualmente accediendo a la base de datos
para obtener información de las tablas y devuelve el resultado en forma de lista, la cual puede ser
una lista simple armada con la instrucción sin posibilidad de modificación de dicha lista al
visualizarse, o puede ser un reporte de tipo ALV con toda la funcionalidad de ajuste del mismo
según se requiera.

Programas de diálogo:
Son programas más complejos y se utilizan mayormente para la actualización de datos. Estos
programas permiten manejar varias pantallas (dynpros) donde cada una de ellas tiene asociados
dos bloques de código, uno llamado PBO (Process Before Output) que se ejecuta antes de
mostrar la dynpro y otro llamado PAI (Process After Input) que se ejecuta cada vez que hay una
interacción del usuario con la pantalla; esta interacción puede estar dada por ejemplo por el hecho
de presionar la tecla enter o presionar algún botón de la pantalla.
Las dynpros de los programas de diálogo no se generan automáticamente como pasa con la
pantalla de selección de los programas ejecutables, en este caso las tenemos que dibujar
mediante una herramienta que dispone SAP para tal fin.

También en los programas de diálogo hay que definir la navegación entre dynpros, es decir
cuando el usuario presiona determinado botón, se define a que número de dynpro debe pasar.

Este tipo de programas no pueden ejecutarse si no es por medio de una transacción.

24
Flujo de proceso en un programa de diálogo:

En este ejemplo se muestra la secuencia de proceso para dos pantallas definidas de forma
estática, es decir siempre que el usuario salga de la dynpro 0100 va a ir a la 0200, también es
posible que la siguiente dynpro se defina de forma dinámica, por ejemplo:

25
 Características del lenguaje de programación ABAP

El lenguaje de programación de ABAP posee las siguientes características:

 Se tipifica.
 Permite aplicaciones multilingües.
 Permite el acceso SQL.
 Se ha ampliado como lenguaje orientado a objetos.
 Es independiente de la plataforma.
 Es compatible con versiones posteriores.

El lenguaje de programación ABAP está diseñado para aplicaciones empresariales basadas en

diálogo.
Para admitir el procesamiento de datos específico de tipo, se admiten las conversiones de tipo y el
casteo de tipos de datos.
Si utiliza elementos de texto traducibles, podrá desarrollar aplicaciones multilenguaje.
El Open SQL estándar incrustado en ABAP permite el acceso directo a la base de datos.
Objeto ABAP es la ampliación del lenguaje de programación ABAP orientado a objetos. La
sintaxis ABAP es independiente de la plataforma. Esto significa que la sintaxis ABAP siempre
tiene el mismo significado o función, independientemente del sistema de base de datos relacional
y del sistema operativo de la aplicación y del servidor de presentación. Las aplicaciones
implementadas en ABAP también funcionarán en versiones futuras debido a la compatibilidad
ascendente del lenguaje.

26
 Sintaxis ABAP general I

Características de la sintaxis ABAP

 Los programas ABAP consisten en sentencias individuales.

 La primera palabra de una sentencia se llama palabra clave ABAP.
 Cada sentencia finaliza con un punto.
 Las palabras siempre deben estar separadas por un espacio.
 Las sentencias pueden tener sangría.
 El sistema de tiempo de ejecución ABAP no distingue entre mayúsculas y minúsculas en
palabras clave, adiciones y operandos.

27
 Sintaxis ABAP general II

Características adicionales de la sintaxis ABAP

 Las sentencias pueden ocupar más de una línea.

 Pueden existir múltiples sentencias en una sola línea (aunque no se recomienda).
 El sistema de tiempo de ejecución ABAP reconoce las líneas que comienzan con un asterisco * en
la primera columna como líneas de comentario y las ignora.
 Las comillas dobles (") indican que el resto de la línea es un comentario.
 Combinación de sentencias
o Puede combinar varias sentencias consecutivas con un inicio idéntico en una sentencia
encadenada de la siguiente manera
o Escriba la parte inicial idéntica de las sentencias, seguida por dos puntos.
o Realice una lista de las partes finales de las sentencias, separadas por comas.
o Utilice espacios en blanco y saltos de línea antes y después de los separadores; es decir, dos
puntos, comas y puntos.

28
Documentación de palabras clave en el Editor ABAP

Puede navegar hasta la documentación para una sentencia ABAP de las siguientes maneras:

Utilice F1 para navegar directamente a la documentación para la sentencia donde se encuentra el

cursor.

Seleccione el botón “i” con la descripción Ayuda de para navegar a una ventana de diálogo, donde
puede introducir la palabra clave ABAP requerida.

29
 Activación de programas

Siempre que cree o modifique un objeto de desarrollo y lo grabe, el sistema almacena solo una
versión inactiva en el Repository.

Dispone de una versión activa y una versión inactiva del objeto. Cuando complete el desarrollo del
objeto, debe activar la versión inactiva (versión de tratamiento) del objeto. Esta versión se
convierte entonces en la nueva versión activa del objeto.

Si el programa está disponible en las versiones activa e inactiva, puede cambiar entre las
visualizaciones de las dos versiones mediante el botón correspondiente del Editor ABAP.

Al activar un programa, el sistema visualiza una lista de los objetos inactivos que ha procesado. Esta
es su lista de trabajo. Seleccione los objetos que desee activar con la transacción de activación actual.

Funciones que se ejecutan al activar un objeto:

 Grabar el objeto como versión inactiva

 Verificación de la sintaxis o consistencia de la versión inactiva
 Sobrescribir la versión activa anterior con la versión inactiva (sólo después de una comprobación
positiva)
 Generar el objeto de tiempo de ejecución relevante para ejecuciones posteriores, si el objeto es
un programa.

30
 Generación de objetos de tiempo de ejecución

Si el programa dispone tanto de una versión inactiva como de una versión activa, puede hacer que
ambas versiones se ejecuten de la forma siguiente:

• Si inicia el programa mediante el menú contextual del área de navegación o a través de una
transacción, se utilizará la versión activa. Esto significa que se ejecutará el LOAD generado para la
última activación.
• Si inicia la versión inactiva cargada en el Editor ABAP mediante la tecla F8, se generará y ejecutará un
objeto de tiempo de ejecución temporal.

De este modo, es posible continuar con el desarrollo de un objeto de repositorio sin modificar el status
de sistema actual. Todas las modificaciones en el objeto de desarrollo se visualizan a través del
sistema solo después de activar el objeto.

31
 Ejercicio 2 - Desarrollar un programa ABAP sencillo
Se solicita crear un programa ABAP sencillo que reciba la entrada de usuario y muestre información en
la pantalla de salida.

El programa a desarrollar debe ser asignado al paquete creado anteriormente bajo el nombre
ZABAPFmmyyyy## y utilizando la misma OT que se utilizó en la creación del paquete.
Cree un programa ejecutable con el nombre ZABAPFmmyyyy##_HOLA, el cual debe permitir que el
usuario indique un nombre en la pantalla de selección, el cual aparecerá posteriormente en la lista
junto con el texto 'Hola'.

Pasos a seguir:
1. Cree el programa en la transacción se38 o se80 sin Include TOP.
2. En la siguiente ventana de diálogo, asegúrese de que el tipo de programa sea Programa ejecutable.
3. Defina el campo de entrada pa_name en la pantalla de selección con el tipo string.
4. Implemente la salida del texto Hola Mundo!. Para ello, utilice la sentencia de ABAP WRITE.
5. Asegúrese de que el resultado aparezca en una línea nueva. Para ello, utilice la sentencia NEW-LINE.
6. Mediante una sentencia encadenada, implemente el texto de salida 'Hola', junto con el nombre de
entrada desde la pantalla de selección.
7. Verifique si existen errores de sintaxis en el programa. Active y realice un test.

32
 Creación de transacciones

Solo se pueden incluir transacciones en un menú de rol y en los favoritos de usuario. Si desea
colocar un programa en un menú de rol o en los favoritos de usuario, debe crear una transacción
que represente el programa e integre la transacción en el menú. También puede iniciar el
programa indicando el código de transacción en el campo de comandos.

Para crear una transacción se puede realizar desde el object navigator, o desde la transacción SE93.

Para cada opción, deben seguirse los siguientes pasos:

Desde la transacción SE80

1. En el Object Navigator, visualice la lista de objetos del programa.
2. En el área de navegación, seleccione su programa y, a continuación, Crear → Transacción
desde el menú contextual.
3. Indique el código de transacción requerido. Asegúrese de respetar las convenciones del área de
nombres del cliente.
4. Asígnele un texto breve y seleccione el pulsador de opción Programa e imagen de selección
(transacción de report).
5. En la pantalla siguiente, indique el nombre del programa y seleccione Transacción de usuario
profesional.
6. En GUI activado, fije el indicador SAP GUI para Windows.
7. Grabe la transacción.

Desde la Transacción SE93

33
1. Indique el código de transacción requerido. Asegúrese de respetar las convenciones del área de
nombres del cliente.

2. Presione el botón crear y continúe a partir del punto 4 igual que si hubiese entrado por la
Transacción se80

34
Ejercicio 3 - Crear una transacción
Cree una transacción llamada ZABAPFmmyyyy##_hola y asóciela al programa con el mismo nombre
creado anteriormente según el modo que considere mas adecuado.

35
 Introducción al
Capítulo 2 Diccionario ABAP

Introducción al diccionario ABAP

El Diccionario ABAP permite la gestión central de todos los tipo de definiciones utilizadas en el
sistema R/3.

En el Diccionario de ABAP, puede crear tipos definidos por el usuario (Elementos de datos,
Estructuras y tipos de tabla) para su uso en programas de ABAP o Módulos de Función y en
objetos de base de datos como tablas, índices y vistas.

El Diccionario ABAP también ofrece una serie de servicios que apoyan programa desarrollo. Por
ejemplo, el establecimiento y la liberación de los cierres, la definición de un Ayuda de entrada (F4
de ayuda), y adjuntar una ayuda de campo (Ayuda F1) a un campo de pantalla se apoyó.

36
La transacción para ingresar al diccionario es SE11

Objetos de base de datos en el Dictionary ABAP

37
 En el diccionario ABAP, se puede:

 Definir las tablas y las vistas de la base de datos. El sistema crea estas tablas y vistas en la base de
datos subyacente con la definición en diccionario ABAP. Las modificaciones en la definición de una
tabla o una vista de base de datos se efectúan automáticamente en la base de datos.

 Definir índices en el diccionario ABAP para acelerar el acceso a los datos en una tabla. El sistema
también crea estos índices en la base de datos cuando se activa la tabla.

38
 Definiciones de tipos en el diccionario ABAP

Las diferentes categorías de tipos del diccionario ABAP son:

 Elementos de datos
Los elementos de datos describen un tipo de datos elemental mediante la definición de un tipo de datos, la
longitud y los caracteres decimales.

 Estructuras
Están formadas por componentes que pueden ser de cualquier tipo.

 Tipos de tabla
Describen la estructura de una tabla interna.

Cualquier tipo complejo definido por el usuario se puede crear a partir de estos tipos básicos.

Por ejemplo, los datos de un empleado se almacenan en una estructura llamada Empleado, con Nombre,
Dirección y Teléfono como sus componentes. El componente Nombre también es una estructura, con los
componentes Nombre y Apellido. Los componentes Nombre de pila y Apellido son elementales, ya que el
tipo es definido por un elemento de datos. El tipo de componente Dirección es una estructura cuyos
componentes son otras estructuras. Un tipo de tabla se usa para definir el componente Teléfono, porque un
empleado puede tener más de un número de teléfono.

Los tipos se usan en los programas ABAP en varios lugares, por ejemplo, para definir los tipos de
parámetros de interfaz de los módulos de funciones.

39
 Servicios del diccionario ABAP

 Ayudas para entradas para campos de pantalla

Las ayudas para entradas (ayuda F4) se pueden definir con ayudas para búsquedas.

 Ayuda de campo para campos de dynpro

A los campos de dynpro se les puede asignar una ayuda de campo (ayuda F1) mediante la creación de
documentación para los elementos de datos.

 Verificación de entrada
Una verificación de entrada asegura que los valores introducidos son consistentes y pueden ser fácilmente
definidos para los campos de dynpro usando claves externas.

 Activar y desactivar bloqueos

El Dictionary ABAP ofrece soporte para activar y desactivar bloqueos. Para activar y desactivar bloqueos,
debe crear objetos de bloqueo en el Dictionary ABAP. A partir de estos objetos de bloqueo se generan
automáticamente módulos de funciones para activar y desactivar bloqueos; luego se pueden enlazar en el
programa de aplicación.

 Grabación de datos en el memoria intermedia

Al acceder a los datos de la base de datos, puede mejorar el rendimiento de los objetos de la base de datos
(tablas, vistas, etc.) por medio de la grabación de datos en la memoria interna.

 Registro en log
Registrar un log permite grabar las modificaciones de las entradas de una tabla automáticamente.

40
 Enlace con el entorno de desarrollo y de tiempo de ejecución

El diccionario ABAP se integra activamente en los entornos de desarrollo y de tiempo de ejecución. Cada
modificación se refleja de inmediato en las pantallas y programas ABAP relevantes.

Los siguientes ejemplos explican la relación entre el Diccionario ABAP y las herramientas proporcionadas
por el entorno de desarrollo y de tiempo de ejecución:

 Cuando se ejecuta un programa o una dynpro, el intérprete de ABAP y el de dynpro acceden a las
definiciones de tipo almacenadas en el Diccionario ABAP.

 Las herramientas ABAP y Screen Painter usan la información almacenada en el Diccionario ABAP como
soporte durante el desarrollo de programas. Un ejemplo de ello es el botón Obtener de Dictionary en el
Screen Painter, que puede utilizar para añadir campos de una tabla o de una estructura definidas en el
Diccionario ABAP en una dynpro.

 La interfaz de base de datos usa la información sobre las tablas o las vistas de base de datos almacenada
en el Diccionario ABAP para acceder a los datos de estos objetos.

41
Algunos puntos importantes a revisar en una tabla:

Al momento de visualizar una tabla en el diccionario de datos podemos chequear por ejemplo cual
es su clave primaria y que campos forman parte de los índices secundarios, eso en el caso que
tengamos que buscar información para poder definir con que campos se debe hacer la búsqueda
de manera tal que se utilicen los índices.

42
Diálogos de actualización
Es habitual que se creen tablas Z en los sistemas SAP y también es habitual que los datos de esas
tablas tengan que actualizarse manualmente. Para resolver este requerimiento SAP proporciona los
diálogos de actualización que son básicamente programas de diálogo generados automáticamente
para actualizar los datos de una tabla en particular.

Muchas veces se confunden con las vistas de actualización, pero no es lo mismo, la vista de
actualización como su nombre lo dice es un programa asociado a la modificación de una vista de una o
más tablas, por lo tanto cuando se debe crear un programa para actualizar todos los campos de una
única tabla, se debe recurrir a un diálogo de actualización

Cuando creamos un diálogo de actualización este puede ser de uno o dos pasos. Si fuese de un paso,
todos los datos de la tabla se mostrarán en una única pantalla tipo Excel para su actualización

Si fuese de dos pasos, se mostrarán los datos en modo visualización en la primera pantalla y luego al
darle doble click a un registro se abrirá una nueva pantalla con el detalle de todos los campos de ese
registro para poder actualizarlo.

43
 Pasos para crear un diálogo de actualización

En la transacción se11 colocamos el nombre de la tabla para la cual vamos a crear el diálogo de
actualización.

Luego seleccionamos la opción del menú UTILITIES / TABLE MAINTEINANCE

GENERATOR. Al acceder al generador de diálogo debemos completar los siguientes
datos:

 Authorization Group:
En caso que para modificar los datos de la tabla deba chequearse un objeto de autorización,
debemos indicar acá el grupo al que pertenece el objeto. Si no hace falta chequear autorización lo
indicamos con &NC&

 Authorization object:
En el caso de chequear autorización, el nombre del objeto de autorización

 Function group:
Como el programa que se va a generar para actualizar la table va a estar dentro de un módulo de
función, acá debemos indicar el nombre del grupo de función en el que lo vamos a poner.
Habitualmente el nombre que ponemos es el mismo que la tabla

 Maintenance type:
Indicamos si va a ser una única pantalla para la actualización (un paso) o dos pantallas (dos
pasos)

 Maint. Screen No.

Este es el número de dynpro que se creará dentro del grupo de función, en el caso de haber
elegido un paso, se debe indicar solamente un número para la Overview Screen, en el caso de
haber elegido dos pasos, se debe indicar también un número diferente para la Single Screen.

 Recording routine:
Acá definimos si la grabación de los datos en la tabla va a solicitor orden de transporte. Eso sucederá
en el caso en que indiquemos Standard Recording Routine.

Por último debe presionarse el botón crear

44
45
 Ejercicio 4 - Crear una tabla con diálogo de actualización:
Se solicita crear una tabla Z dependiente de mandante para guardar datos de personas, que sea
actualizable mediante la transacción SM30.

1. Crear la tabla con el nombre ZABAPFmmyyyy##_MITABLA

2. En los atributos colocar Delivery class A y Display/Mainteinance Allowed
3. En la solapa campos completar con:

Nombre de campo Tipo de dato

DNI (clave) STCD1
NOMBRE NAME1
DIRECCION ADRTRANSACCIÓN

Tener en cuenta que debe ser dependiente de mandante.

En las opciones técnicas seleccionar appl0 y categoría de tamaño 0

En Extras/Enhancement Category seleccionar Cannot Be Enhanced

4. Activar.

5. Crear un diálogo de actualización siguiendo los pasos detallados anteriormente

6. Probar cargar los datos mediante la transacción SM30

46
 Introducción a
Capítulo 3 Eventos ABAP

Introcucción a eventos en ABAP

ABAP es un lenguaje de programación estructurado y secuencial. Para poder manejar diferentes
situaciones se encuentran los eventos, de los cuales podemos destacar:

INITIALIZATION

AT SELECTION-SCREEN

START-OF-SELECTION

Cuando se inicia un programa de ABAP, todos los objetos de datos globales de los programas son
los primeros creado en la memoria de trabajo (asignación de memoria). Después de eso, en
tiempo de ejecución se desencadena varios acontecimientos en sucesión. Si existe un bloque de
procesamiento en un evento en el programa, las declaraciones de este bloque se ejecutan en
secuencia. El orden como se ejecutan es el siguiente:

1. INITIALIZATION
Se utiliza para este evento para inicializar o cargar valores en la pantalla de selección previo a
que esta sea mostrada.
Este proceso se ejecuta desde que se ejecuta la transacción y hasta que se muestra la pantalla
de selección.

2. AT SELECTION-SCREEN
Se utilizada para validar los datos ingresados en la pantalla y los niveles de autorización.
Es lanzado siempre que se oprime ENTER en la pantalla de selección o cuando se oprime F8.

3. START-OF-SELECTION
Se utilizada este evento para la ejecución completa del programa.
Es ejecutado luego de oprimir F8 y es recomendable utilizar subrutinas para la ejecución del
código.

47
El ejemplo dado a continuación, contiene una pantalla de selección con un campo de entrada
para una fecha.

En circunstancias normales, la fecha actual es la de aparecer como el valor por defecto

(DEFAULT SY-DATUM). Sin embargo, bajo ciertas condiciones (IF) se mostrara el mismo día de
la semana siguiente (pa_date = pa_date + 7.).

En el mismo gráfico se muestra cómo el sistema de ejecución reacciona cuando un bloque falta.
Simplemente, no hay instrucciones ejecutadas por el correspondiente y se continúa con el
evento siguiente.

48
Si no hay ningún evento implementado dentro del programa, asume que todas las sentencias
corresponden al STAR-OF-SELECTION.

Además de los eventos ya mencionados, existe otro que veremos más adelante en este mismo
manual. Ej. AT LINE-SELECTION, este evento se ejecuta cuando el usuario hace doble clic en
una lista.

Este evento puede ser utilizado, por ejemplo, para mostrar la información detallada del registro
seleccionado en la lista.

Además de los eventos ya mencionados, se pueden utilizar otros bloques de procesamiento. Por
ejemplo las Subrutinas (FORM ENDFORM) este bloque es ejecutado por la sentencia
(PERFORM).

El siguiente grafico muestra la estructura general de un programa ABAP:

49
 Ejercicio 5 - Utilización de eventos
Se solicita crear un programa ABAP que reciba 2 parámetros de entrada y realice una asignación
inicial y una validación.

En el paquete creado anteriormente ZABAPFmmyyyy## y utilizando la misma OT, cree un

programa ejecutable con el nombre ZABAPFmmyyyy##_EVENTOS. Permitir que el usuario
indique un nombre en la pantalla de selección, y una fecha de ingreso a la compañía. El nombre
debe completarse automáticamente con el nombre de usuario de SAP y el segundo debe ser
obligatorio y no puede ser posterior a la fecha del día.

Pasos a seguir:
1. Cree el programa en la transacción se38 o se80 sin Include TOP.
2. En la siguiente ventana de diálogo, asegúrese de que el tipo de programa sea Programa
ejecutable.
3. Defina el campo de entrada pa_name en la pantalla de selección con el tipo string.
4. Defina el campo de entrada pa_fec en la pantalla de selección del tipo datum.
5. Implemente el evento initialization.
6. Implemente el evento at-selection-screen.
7. Implemente el evento start-of-selection.
8. Verifique si existen errores de sintaxis en el programa. Active y realice un test.

50
 Elementos básicos del lenguaje
Capítulo 4 ABAP

Elementos básicos del lenguaje ABAP

Tipos de datos y objetos de datos

Puede utilizar los tipos de datos de las siguientes maneras:

 Utilizar tipos de datos para definir los objetos de datos

El tipo de un objeto de datos define sus propiedades técnicas.
 Utilizar tipos de datos para definir los parámetros de interfaz
El tipo de un parámetro de interfaz determina el tipo del parámetro real que se transfiere al llamar
la unidad de modularización.
 Utilizar tipos de datos para definir campos de entrada/salida
El tipo de un campo de entrada/salida puede proporcionar información adicional a las
características técnicas, como la ayuda de entrada de valor y de campo.

51
 Tipos de datos estándar ABAP
Los tipos de datos estándar ABAP (tipos de datos integrados) se dividen en dos grupos:
• Completo
• Incompletos

Tipos de datos estándar ABAP completos

Los tipos de datos estándar ABAP integrados que ya contienen una especificación según el tipo
y de longitud fija se consideran tipos de datos completos.

Tipos estándar Descripción

Tipo para fecha (D), formato: AAAAMMDD, longitud 8 (fi-
D ja)
T Tipo para hora (T), formato: HHMMSS, longitud 6 (fija)
I, INT8 Tipo para entero, ya sea de longitud 4 (fija) (para I) o
longitud 8 (fija) (para INT8)
F Tipo para número de punto flotante (F), longitud 8 (fija)
STRING Tipo para cadena de caracteres de longitud dinámica
Tipo para secuencia de bytes de longitud dinámica
XSTRING (cade-
na heXadecimal)

Tipos de datos estándar ABAP incompletos

Los tipos estándar que no contienen una longitud fija se consideran tipos de datos incompletos.
Si se utilizan para definir objetos de datos, será necesario especificar la longitud de la variable.

Tipos estándar Descripción

C Tipo para cadena de caracteres (Carácter) para la que se
debe especificar la longitud
N Tipo para cadena de caracteres numérica (carácter
Numérico) para la que se debe especificar la longitud
Tipo para secuencia de bytes (cadena heXadecimal) para
X la
que se debe especificar la longitud
Tipo de número empaquetado (número Empaquetado)
E para
el que se debe especificar la longitud (en la definición de
un
número empaquetado, el número de puntos decimales
también puede especificarse).

52
Tipos de datos locales

Mediante los tipos estándar, puede declarar tipos de datos locales en el programa, que pueden ser
más completos o más complejos que los tipos de datos estándar subyacentes. Los tipos de datos
locales solo existen en el programa en cuestión y, por consiguiente, solo se pueden utilizar allí. La
declaración se realiza mediante la sentencia TYPES.

Tipos de datos globales

53
Un tipo de datos definido en el Diccionario ABAP se llama global, ya que puede utilizarse en todo
el sistema SAP en cuestión.

En esta lección, solo aprenderá cómo los elementos de datos se usan como tipos de datos para
los objetos de datos elementales.

54
 Definición de objetos de datos variables

Categorías de tipos de datos

• Integrado
• Local
• Global

Estos tipos se utilizarán para definir variables (objetos de datos).

Los objetos de datos siempre se definen con la palabra clave DATA. Puede utilizar un tipo
estándar, un tipo local o un tipo global ABAP para definir un objeto de datos.

Puede consultar un objeto de datos ya definido al definir variables adicionales (suplemento

LIKE).

55
Ejemplos de definición de objetos de datos elementales

Puede utilizar el suplemento VALUE para asignar previamente el valor de un objeto de datos
elemental.

Si falta la especificación de longitud de una definición de variable, se utiliza una longitud por
defecto para el tipo estándar (incompleto) (longitud 1 para los tipos C, N y X, y longitud 8 para el
tipo P). Si también falta el tipo de datos, se utiliza el tipo estándar C. Por ejemplo, la sentencia
DATA gv_myvar. no tiene especificación de tipo y longitud, entonces, se define una variable de
tipo C con una longitud 1).

56
Constantes: Tipos de datos fijos requieren valores fijos que se deben cargar cuando se declaran
las constantes.

Usted puede definir constantes con la palabra reservada CONSTANTS. Se define de manera
similar a los DATA Elements con el agregado de la palabra VALUE que es un requisito
obligatorio.

Los tipos de datos locales solo pueden ser usadas en el programa que fueron definidas. En
contraposición los tipos de datos globales pueden ser usados por todo el sistema, además de las
siguientes ventajas:

Proporcionan la ventaja de la reusabilidad y mantienen la consistencia del sistema. En el

diccionario ABAP usted tiene la opción de utilizar where-used list para mediante referencia de
utilización ver donde se usa.

Se pueden modificar los tipos de datos sin tocar el código ABAP.

57
Sentencias básicas ABAP

Cuando se inicia el programa, el contexto del programa se carga en un área de memoria del
servidor de aplicaciones y la memoria se pone a disposición de los objetos de datos definidos en
el programa. Todos los Data Objects son asignados previamente con el valor inicial del tipo
específico, excepto si un valor diferente fue pre-asignado mediante la sentencia VALUE.

Usted puede utilizar la instrucción MOVE para transferir el contenido de un objeto de datos a otro
objeto de datos.

MOVE var1 TO var2..

var2 = var1..

En ambos casos los objetos var1 y var2 son de diferentes tipos, por lo tanto podría haber un
conflicto de tipos. En este caso, la conversión de tipos se realiza de forma automática. La
sentencia CLEAR borra el contenido de la variable.

58
 Cálculos y expresiones aritméticas

En ABAP podrás utilizar sentencias aritméticas.

+ SUMA

- RESTA

* Multiplicación

/ División

** Exponencial

59
Condicionales y expresiones lógicas

En ABAP usted tiene 2 maneras de ejecutar diferentes secuencias de sentencias, dependiendo

de las necesidades.

En la construcción IF puede definir cualquier expresiones lógicas como las condiciones de

verificación. Si se cumple la condición, el sistema ejecuta el bloque de instrucciones correspondiente.
De lo contrario, la condición especificada en la rama ELSEIF (varios son posibles) se comprueba y así
sucesivamente. Si ninguna de las condiciones especificadas se cumplen, entonces el sistema ejecuta
la rama ELSE, si está disponible. ELSEIF y ramas ELSE son opcionales. Para obtener información
detallada sobre la formulación de una expresión lógica consulte la documentación de la palabra clave
en la instrucción IF.

Usted puede utilizar CASE para distinguir claramente los casos. El contenido del campo
especificado en la parte CASE se compara con los objetos de datos que figuran en el WHEN
para ver si coinciden. Si el contenido de los campos coinciden, el bloque de instrucciones
respectivas se procesa. Si la comparación es incorrecta, el sistema ejecuta la rama OTHERS si
está disponible. A excepción del primer WHEN, los demás son opcionales.

En ambas sentencias la secuencia de comparación es de arriba hacia abajo. Apenas encuentre

una coincidencia ejecuta esa parte del código y luego salta hasta el ENDIF o el ENDCASE.

60
Sentencias LOOPS o repetitivas.

DO.

IF <condición>.

EXIT.

ENDIF.

ENDDO.

DO n TIMES.

Sentencias ABAP

ENDIF.

WHILE <condición>.

Sentencias ABAP

ENDWHILE.

SELECT ... FROM <dbtab> ...

Sentencias ABAP

ENDSELECT.

LOOP AT <Tabla Interna>.

Sentencias ABAP

ENDLOOP.

Hay cuatro construcciones de bucle en ABAP. En la DO y en el WHILE el campo del sistema SY-INDEX
contiene el número de vuelta que se está ejecutando. Por lo tanto, consultar este campo del sistema sólo
tiene sentido dentro de un bucle. En bucles anidados, SY-INDEX contiene siempre el número de vuelta del
bucle en el que se encuentra.

La sentencia DO ENDDO, solo tiene sentido si colocamos la palabra reservada EXIT con alguna condición
que amerite salir.

La sentencia WHILE ENDWHILE, se va a ejecutar siempre que la condición sea verdadera, para salir
tendremos que cambiar el valor de la condición.

La sentencia SELECT y la sentencia LOOP se utilizan para recorrer tablas, la primera tablas de base de
datos y la segunda tablas internas.

61
Creación de Mensajes.
Para crear mensajes se utiliza la transacción SE91. En ella se crea una clase de mensajes y dentro
podremos agregar todos los mensajes que queramos. La idea es no poner los textos de los mensajes
dentro de código sino dentro de esta clase de mensajes en donde también se los puede traducir y
que tomen el idioma que el usuario esta logeado.

Dentro de nuestro programa ABAP con el botón PATRON podremos agregar nuestro mensaje en
el código.

A continuación vemos los distintos tipos de mensajes que podemos seleccionar.

62
Usted utiliza la instrucción MENSSAGE para enviar mensajes de diálogo a los usuarios de su
programa. Al hacer esto, debe especificar el número de tres dígitos y la clase de mensaje.
Mensaje número y clase de mensaje identifica claramente el mensaje que se mostrará.

Se utiliza el tipo de mensaje para indicar qué tipo de mensaje se va a mostrar.

Trabajando con ABAP Debugger

Al momento de iniciar un debug tenemos diversas formas de hacerlo.
Un modo es colocando un BreakPoint dentro del código de mi programa, tras lo cual durante la
ejecución del programa, al pasar por ese punto, el mismo se detendrá ingresando en modo
debug.

63
Otro modo es colocando la sentencia /h en el cuadro de comando y presionando ENTER.
Esto activa el modo debug y va a empezar a debugear a partir de ese punto.

Ya dentro de la aplicación para debugear podremos utilizar las teclas F5, F6, F7 y F8 para
ejecutar distintos comandos.

64
La tecla F5 nos permite avanzar paso a paso por nuestro código, o sea línea por línea de código.

La tecla F6 nos permite saltear Subrutinas, Módulos de Función, ETC. Aclaro que igual se
ejecutan pero sin que veamos ese código de ejecución.

La tecla F7 nos permite regresar a la sentencia siguiente a una subrutina o un módulo de

función.

La tecla F8 nos permite finalizar la ejecución o pasar al próximo BreakPoint.

65
Selection Screen

Las pantallas de selección sirven como interfaces entre el programa y el usuario. Se utilizan para
limitar la cantidad de información a leer de la base de datos.

Usted puede utilizar las palabras reservadas PARAMETERS y SELECT-OPTIONS, para generar
una pantalla de selección con parámetros de entrada.

Además de las pantallas de selección por defecto, usted puede crear pantallas de selección usando
SELECTION-SCREEN BEGIN OF .... y llamar a esas pantallas usando

CALL SELECTION-SCREEN. Cree las variantes para ahorrar los valores de la pantalla de la
selección que se utilizan en varias ocasiones. Estas variantes se pueden recordar para el uso
cuando están requeridas. Una variante es necesaria si un informe se ejecute en un proceso de
trabajo de fondo.

66
Declarando campos como parámetros.

La sentencia PARAMETERS se declara en lenguaje elemental. Como con la sentencia DATA,

usted puede declarar los parámetros con TYPE o LIKE. El sistema genera un campo de entrada
en la pantalla de selección. La cantidad de caracteres en el nombre no puede superar los 8
caracteres.
Los textos de los parámetros de selección se modifican en el menu: Pasar A --> Elementos de
Texto --> Textos de Selección.

Usted puede colocar valores por default con la sentencia DEFAULT valor. Si asigna una ID <pid>
MEMORIA, el sistema recupera el valor actual de la memoria de SAP y muestra de forma
automática. Si se declara campos obligatorios con la adición OBLIGATORY, los usuarios no
pueden salir de la pantalla de selección hasta que los valores se han especificado en estos
campos.

El Control automático por el Diccionario ABAP se apaga para pantalla de selección de informes,
de forma predeterminada. Sin embargo, si usted hace una referencia a un objeto de diccionario
que tiene una clave externa definida, con VALUE CHECK hará que el diccionario verifique que la
entrada es válida.

Usted puede definir un parámetro como check Box (AS CHECKBOX). Esto crea un campo de un
carácter que puede contener los valores de blanco o X. Usted podrá evaluarlos usando las
sentencias IF/ENDIF.

Usted puede también definir una serie de botones de radio para una pantalla de la selección con
el GRUPO de la adición RADIOBUTTON GROUP. La longitud máxima del nombre para un
GRUPO de RADIOBUTTON GROUP es cuatro caracteres. Solamente un botón de radio en un
grupo puede ser activo y evaluado durante el proceso del programa. Usted puede evaluar el
contenido de los botones de radio usando las estructuras de control de CASE/ENDCASE.

67
 Ejercicio 6 – Programa con pantalla de selección
Se solicita crear un programa ABAP simple para los cuatro tipos básicos de cálculo. Debe poder
indicar los valores y el operador aritmético en una pantalla de selección. El resultado debe
visualizarse en una lista.

1. Cree el programa ejecutable ZABAPFmmyyyy##_CALCULADORA sin ningún Include TOP y

asígnelo a su paquete.
2. Defina dos parámetros de entrada de tipo enteros como operandos (nombres sugeridos: pa_int1,
pa_int2) y un operador aritmético de tipo alfanumérico de un carácter de longitud (nombre
sugerido: pa_op). Utilice la palabra clave PARAMETERS de ABAP para ello.
3. Cree un objeto de datos elemental (nombre sugerido: gv_result) mediante la sentencia DATA
para el resultado de cálculos. Defínalo como un tipo de número empaquetado de 16 dígitos de
longitud y dos posiciones decimales.
4. Calcule el resultado según el operador aritmético especificado. Utilice la sentencia CASE para
distinguir los casos.
5. Presente el resultado en una lista mediante la sentencia WRITE. Si desea presentar textos
durante el proceso, asegúrese de que esos textos se puedan traducir y se visualicen como
dependientes de idioma.

Consejo: Cree símbolos de texto y utilícelos en lugar de literales.

6. Visualice un mensaje de error en la lista si el usuario especifica un operador aritmético no válido.

Utilice la sentencia IF para verificar.
7. Visualice un mensaje de error en la lista si el usuario intenta dividir por cero.
8. Active y realice un test del programa.

68
 Trabajando con Estructuras

En ABAP, usted puede definir estructuras. Esto le permite combinar variables de diferentes tipos dentro de
una unidad lógica denominada estructura. Esto significa que los componentes o variables pueden ser parte
de una estructure e incluso de una tabla interna.

En el programa, las variables de las estructuras son definidas con DATA. Cuando usted define los tipos de
datos con TYPES, puede referenciarlos a:

• Elementos de datos del diccionario.

• A una tabla transparente
• A una estructura
• A tipos de datos declarados localmente en el programa

En el programa, las variables de estructura se definen con la declaración DATA, de la misma manera
que los objetos de datos elementales. Cuando configura los tipos, puede consultar:

 Una estructura de diccionario

 Una tabla transparente (que luego se usa como tipo de estructura) o

 Un tipo de estructura que se declara localmente en el programa

El siguiente grafico muestra una WORK AREA declarada del tipo de una estructura previamente
definida con TYPES.

69
Usted puede usar la sentencia TYPES para definir estructuras locales.

BEGIN OF structure_type_name,

... ,

END OF structure_type_name.

Puede asignar cualquier tipo de datos usando TYPE. Para más información puede oprimir
F1 sobre la sentencia TYPES.

También puede definir la WorkArea directamente usando DATA:

DATA: BEGIN OF structure_name,

... ,

END OF structure_name.

Los componentes de la estructura son accedidos utilizando el -.

Por esta razón usted no debe usar guiones en los nombres.

La sentencia MOVE-CORRESPONDING copia el contenido de la estructura de origen a la de

destino un componente a la vez. Solo son considerados los componentes con el mismo nombre.
Para asignar individualmente cada valor se utiliza la sentencia MOVE.

70
Trabajando con ABAP Debugger
Cuando estamos en modo debug, haciéndole doble click en la estructura podremos ver su
contenido.

71
 Trabajando con Tablas Internas
Una tabla interna es un objeto que puede tener muchos registros de una misma estructura.
La cantidad de información que puede tener cada tabla interna está restringida solo por la
capacidad del sistema.

Cada elemento de una tabla interna se lo denomina registro o entrada de una tabla. Por esta
razón cada componente individual en un registro se lo llama campo o columna. El tipo de
registro está definido previamente con DATA o con TYPES.

Las tablas internas, por lo tanto son una forma simple de procesamiento de grandes conjuntos
de datos de manera estructurada. Las aplicaciones típicas incluyen:

o Obtener información de la base de datos.

o Formatear información para una salida de reporte

o Formatear información para otros servicios (Ej. Subrutinas, Módulos de Función, Etc.)

Las siguientes propiedades definen una tabla interna por completo:

Line type

El tipo de línea describe la estructura de las filas de la tabla.

Key

La clave de una tabla interna se compone de los campos claves, incluyendo su ordenamiento.

El orden de los campos clave se utiliza, entre otras cosas, para el ordenamiento según sus
campos claves.

72
Tipos de tablas
Usted puede elegir entre 3 diferentes tipos de tablas: Standard, Sorted, and Hashed.
Dependiendo el tipo de acceso que utilice, puede ser más apropiado uno u otro tipo de tabla.

STANDARD TABLES

La fila de numeración (índice) se mantiene internamente. Tanto el índice y los accesos principales son
posibles.Usted debe elegir este tipo de tabla cuando se utilizan, sobre todo el índice para acceder a la tabla
interna.

SORT TABLES

Los registros de datos se ordenan automáticamente en orden ascendente de los campos clave. También en este
caso, el índice se mantiene internamente. Tanto el índice y los accesos principales son posibles.

Usted debe elegir este tipo de tabla si todo acceso a la tabla interna con la llave o le gustaría que la tabla
se ordene automáticamente por clave.

HASHED TABLES

Los registros de datos se gestionan clave para un acceso rápido mediante el procedimiento de hashing.
Una clave única es requerida. Con las tablas hash sólo tiene acceso clave son posibles.

73
El tipo de datos de una tabla interna es denominado Tipo Tabla. Los tipos de tabla pueden definirse
globalmente en el diccionario de SAP o de forma local en el programa con la sentencia TYPES. En el
grafico anterior podemos ver como declarar una tabla declarada de un tipo de datos proveniente del
diccionario.

En el grafico anterior muestra un tabla interna declarada de forma local. Usted puede definirle una clave
con la sentencia KEY y los campos de la tabla.

74
En el ejemplo dado, declaramos una estructura con campos apuntando al diccionario y con esa
estructura declaramos una tabla interna indicando el tipo de tabla interna (Standard, Sorted,
Hashed).

Cualquiera de los casos descriptos en el grafico anterior declaran una misma tabla interna. Si la tabla
interna es del tipo Standard no es necesario aclararlo.

75
Para el proceso de un solo registro de una tabla interna, siempre necesitara la creación de una
WorkArea con el mismo formato.

APPEND
Agrega el contenido de una workarea en una tabla interna. Esta operación solo puede ser usada
en tablas Standard.

INSERT
Inserta el contenido de una WorkArea en una tabla interna.

En el caso de las talas Standard funciona igual que el APPEND ingresando el registro en la
última posición. En el caso de las tablas internas de tipo Sort y Hashed serán ingresados donde
correspondan.

READ
Copia el contenido de un registro de una tabla interna a una WorkArea.

MODIFY
Modifica un registro de una tabla interna con el contenido de una WorkArea.

DELETE
Borra registros de una tabla interna.

COLLECT
Acumula el contenido de una WorkArea en una tabla interna que tengan la misma clave, en caso
contrario inserta el registro.

76
LOOP . . . ENDLOOP
Recorre la tabla interna registro por registro poniendo el resultado en una WorkArea especificada
con la sentencia INTO.

DELETE
Borra los registros de una tabla interna cuando coincide con la condición.

INSERT
Inserta el contenido de varios registros de una tabla interna a otra cuando se cumple con la
condición.

APPEND
Agrega los registros de una tabla interna a otra cuando se cumple la condición y siempre que
tengan el mismo formato.

77
Usted puede insertar un registro en un atabla interna agregando los datos en una WorkArea y
utilizando la sentencia INSERT. Según el tipo de tabla será insertado donde corresponda. En las
tablas de tipo Hashed y en las de tipo Standard el Insert funciona como el Append.

78
Puede leer y editar el contenido de una tabla interna registro por registro usando la sentencia
LOOP. La variable de sistema SY-TABIX contiene el número de registro que está trabajando, o
sea la vuelta de loop que corresponda.

El ejemplo del grafico anterior muestra el recorrido de una tabla interna y la impresión de los
datos que se encuentran en la WorkArea con la sentencia WRITE.

Para modificar el contenido de la tabla que está recorriendo, primero modificar la WorkArea y
luego con la sentencia MODIFY modificar la tabla.

MODIFY itab FROM wa.

En el LOOP, usted podrá restringir el acceso a ciertos registros usando el agregado de FORM- TO.
En el ejemplo anterior el sistema recorre solo los primeros 5 registros.

Usted puede usar el READ TABLE para leer un solo registro. Usted puede agregar la sentencia

INDEX para especificar el número específico de registro a leer.

79
En el loop usted podrá restringir los accesos usando el agregado WHERE. En el ejemplo anterior
solo recorre los registros en donde carrid sea igual a LH.

Usted puede usar el READ TABLE para leer un registro de una tabla interna. En este caso usted
utiliza la sintaxis WITH TABLE KEY para elegir el registro correcto.

La variable de sistema SY-SUBRC se encuentra en cero cuando se ha encontrado un registro.

80
La tablas de tipo Standard y Hashed pueden ser ordenadas de forma ascendente o descendente
por cualquier columna utilizando la sentencia SORT. Si no se especifica forma de ordenamiento
el mismo es de forma ascendente.

REFRESH
Borra el contenido de la tabla interna.

CLEAR
Para tablas sin header line borra el contenido de la tabla. En las que tienen cabecera, borra la
cabecera.

FREE
Borra el contenido de la tabla y también el espacio de memoria que ocupa

En el debug, usted puede monitorear el contenido de una tabla interna

81
 El CON HEADER LINE además en la definición de la tabla interna le da la opción de crear una tabla con la
línea de cabecera. Cuando esto se hace un área de trabajo (línea de encabezado) que se adapte a la tabla
se crea automáticamente de modo que la definición adicional de la misma no es necesaria. Esto también
simplifica la sintaxis de los comandos de tabla, ya que el sistema siempre se refiere al área de trabajo
generados automáticamente, por lo que ya no tiene que ser especificado explícitamente. A pesar de las
ventajas mencionadas ya no desea utilizar la tabla con líneas de cabecera, porque:

 El área de trabajo generados automáticamente tiene el mismo nombre que la tabla interna, que no
contribuye a hacer que el programa de lectura.
 Tablas con líneas de cabecera no están permitidos en:
 Objetos de datos complejos (estructuras y tablas internas que tienen las tablas internas como
componentes).
 Objetos ABAP (objeto de extensión orientadas de ABAP)

Sólo mencionar las tablas internas con líneas de encabezado aquí por algunos programas más antiguos
todavía los utiliza y tienes que trabajar con estos programas de vez en cuando. Es por ello que las
particularidades más de la línea de cabecera son los siguientes:

Si una tabla interna con la línea de cabecera se llama ITAB, entonces ITAB-tablefield se utiliza para
abordar el campo correspondiente en el área de trabajo.

Usted puede abordar el cuerpo de la tabla con ITAB []. El siguiente ejemplo ilustra la situación antes
mencionada:

DATA itab1 TYPE TABLE OF scarr WITH HEADER LINE. DATA itab2 LIKE itab1.
itab1 = itab2 . Sólo las operaciones con líneas de cabecera!
itab1[] = itab2[] . Las operaciones con cuerpo tabla

82
La siguiente sintaxis muy antigua también define una tabla interna con la línea de cabecera, a pesar de que
no se indica específicamente.

DATA: BEGIN OF itab OCCURS n, field1 TYPE ... ,

field2 TYPE ... ,

... ,

END OF itab.

83
 Ejercicio 7 – Tablas internas
Se solicita crear un programa ABAP llamado ZABAPFmmyyyy##_TABLAINT que lea de la base
de datos los datos de vuelos (tabla SPFLI) y los muestre en una lista simple.

Pasos a seguir:
1. Cree el programa en la transacción se38 o se80 sin Include TOP.

2. En la siguiente ventana de diálogo, asegúrese de que el tipo de programa sea Programa

ejecutable.

3. Defina dos variables, una llamada lt_spfli del tipo net310_t_sflight que será la tabla interna y otra
llamada ls_spfli que será utilizada como work área para esa tabla interna.

4. Como todavía no vimos como acceder a buscar datos en la base de datos, vamos a utilizar el
método read_flights de la clase zcl_net310_flightmodel para completar la tabla interna. Para ello
utilice el botón pattern que le ayudará a generar el código necesario para la llamada al método.

5. Mediante un loop en la tabla mostraremos el contenido de los campos carrid, connid y fldate de
cada vuelo.

6. Verifique si existen errores de sintaxis en el programa. Active y realice un test.

7. Utilice el ABAP Debugger para comprobar la presentación de la tabla interna en la lista.

Solución:

84
 Capítulo 5 Acceso a base de datos

Acceso a base de datos

Leyendo Tablas de Base de Datos Obteniendo Información

SQL es la abreviatura de (Structured Query Language), un lenguaje que define, cambia, cread y
lee el acceso a Base de datos.

Cada Base de Datos relacional tiene un SQL Nativo, que es específico para esa base de datos.
En ABAP uno programa en Open SQL, funcionando sobre cualquier base de datos. Open SQL
es convertido dinámicamente a SQL Nativo, evitando problemas con futuros cambios de base de
datos.

85
 El siguiente grafico no muestra de forma genérica como es la sentencia de acceso a Base de datos

La sentencia SELECT contiene una serie de cláusulas, cada una de las cuales tiene una tarea distinta
como las siguientes:-

• La cláusula SELECT nombra los campos de la tabla que se leerán.-

• La cláusula FROM nombra la fuente (tabla o vista de base de datos) desde la cual se deben seleccionar
los datos.-

• La cláusula INTO determina la variable de destino en la cual se deben colocar los datos seleccionados.-

• La cláusula WHERE especifica las columnas de la tabla que se deben seleccionar.

86
Recuperación de una fila de datos

La sentencia SELECT SINGLE permite leer un registro individual de la tabla de base de datos.
Para garantizar un acceso único, rellene todos los campos clave con la cláusula WHERE. El
campo de mandante es una excepción. Si no se especifica nada, se aplica el mandante actual.
Un mandante solo se puede especificar en la sentencia SELECT en combinación con el
suplemento CLIENT SPECIFIED.

Use un asterisco (*) para especificar que se leerán todos los campos seleccionados de la fila de
la tabla. Si solo desea una selección específica de columnas, reemplace el * con una lista de los
campos requeridos, como se muestra en la siguiente imagen.

Use la cláusula INTO para especificar la variable de destino en la cual se debe copiar el registro
de datos. La estructura de destino debe estar justificada a la izquierda del mismo modo que la
lista de campos.

Si el sistema encuentra un registro apropiado, SY-SUBRC devuelve el valor 0.

87
Si desea leer solo una selección determinada de campos de la fila de la tabla, especifíquelas
como lista de campos dentro de la sentencia SELECT (como se muestra en la figura). A
continuación, nombre una variable de estructura de destino en la cláusula INTO que tenga la
misma estructura que la lista de campos (al menos al principio); es decir, que contenga los
nombres de los campos de la lista en el mismo orden. Sólo es necesario que coincidan los tipos
de campo correspondientes. Los nombres de los campos de estructura de destino no se tendrán
en cuenta.

De forma alternativa, enumere los campos de destino correspondientes en la cláusula INTO de la

siguiente manera: INTO (field_1, ... , field_n).

88
Campos de la estructura de destino con los mismos nombres que los de la
lista de campos

Si desea utilizar una variable de estructura para recibir el registro de lectura, que tiene campos con el
mismo nombre que los campos de la lista de destino, pero con una estructura distinta (campos
adicionales, orden de campos distinto), utilice el suplemento CORRESPONDING FIELDS OF. Esto
hace que el sistema solo complete los campos del área de destino que tiene el mismo nombre que los
campos de la tabla de base de datos. Asegúrese de que los tipos de campo sean los mismos para los
campos correspondientes; en caso contrario (como en la sentencia MOVE), se inicia una conversión y
es posible que solo se transporten datos incompletos (causados por bloqueos) a los campos de
destino. Ventajas de utilizar INTO CORRESPONDING FIELDS OF

La estructura de destino no debe estar justificada a la izquierda del mismo modo que la lista de
campos.

La construcción es fácil de actualizar, porque la extensión de la lista de campos o de la

estructura de destino no requiere la realización de otras modificaciones en el programa, siempre
que exista un campo de la estructura con el mismo nombre (y si es posible, del mismo tipo
también).

89
Recuperación de datos mediante un array fetch

Puede utilizar el suplemento INTO TABLE para copiar la parte seleccionada de la base de datos en una
tabla interna directamente, en lugar de fila por fila. Esta técnica se conoce como array fetch. Es una técnica
de alto rendimiento para rellenar una tabla interna con entradas de una tabla de basa de datos porque el
transporte de datos se realiza en bloques y no por filas.

Un Array Fetch no es un tipo de procesamiento de loop, por ellos, no se requiere ni se permite una
sentencia ENDSELECT.

Del mismo modo que las variantes SELECT, la tabla interna especificada como de destino en el Array
Fetch se debe estructurar con justificación a la izquierda como la lista de campos. Si la tabla interna no
cumple con este requisito previo, debe utilizar el suplemento INTO CORRESPONDING FIELDS OF TABLE
en lugar del suplemento INTO TABLE. Con el método, las columnas de base de datos especificadas en la
lista de campos se copian en las columnas de la tabla interna que tienen los mismos nombres. Asegúrese
de que los tipos de campo de las columnas correspondientes coincidan para evitar conversiones complejas
y posiblemente transferencia de datos incompletos en la tabla de destino.

Con Array Fetch, se sobrescribe el contenido que pueda estar presente en la tabla interna. Si en lugar de
sobrescribir desea adjuntar filas, utilice el suplemento APPENDING TABLE.

Si el sistema copia al menos un registro en la tabla interna, sy-subrc devuelve el valor de 0. El número de
filas que se copiaron se devuelve en sy-dbcnt.

90
Problemas generales del rendimiento de la base de datos
En la mayoría de los casos, el acceso a la base de datos supone una exigencia considerable
para el requisito de tiempo de ejecución de una aplicación ABAP. Para evitar sobrecargar
innecesariamente al sistema y mantener al mínimo el tiempo de espera para los otros usuarios,
preste mucha atención a los requisitos de tiempo de ejecución para los accesos a la base de
datos.

Open SQL tiene varias tecnologías disponibles que le permiten optimizar el requisito de tiempo
de ejecución.

Índices de bases de datos

Toda base de datos gestiona registros de una tabla de base de datos basada en los campos
clave. Si el acceso a la base de datos está restringido para todos o para los primeros campos
clave, la base de datos puede alcanzar los registros de datos requeridos con rapidez y eficacia.

91
Acceso mediante campos no clave

Si el acceso a la base de datos está dirigido a campos que no pertenecen a la clave de tabla
(campos no clave), el principio de gestión de pedidos interna no se puede utilizar para el acceso
rápido. En el peor escenario, se deberán buscar las entradas requeridas en toda la tabla o, como
mínimo, en gran parte de ella. A esto se le conoce como una búsqueda secuencial y el tiempo de
espera para el acceso a la base de datos puede ser muy prolongado.

92
Acceso mediante índice secundario

Si accede a una tabla de base de datos con frecuencia mediante una selección particular de
campos de búsqueda, definir un índice secundario que contenga los campos utilizados en la
selección acelerará los accesos correspondientes.

El índice secundario es una pequeña tabla independiente que incluye los campos del índice y
una referencia a los registros relevantes para cada registro de la tabla de base de datos actual.
Si los campos de la selección coinciden con los campos del índice secundario (alineados a la
izquierda y continuos, como mínimo), la base de datos busca dentro del índice secundario y, a
continuación, lee los registros de datos correspondientes a través de la referencia.

Cree un índice secundario en modo de visualización para la tabla transparente relevante en el

Diccionario ABAP con el botón Índices. Cuando active el índice, se creará el índice secundario
en la base de datos.

Si el sistema utiliza un índice secundario establecido y cómo lo utiliza en el acceso de base de datos
es una función del sistema de base de datos conocido como el Optimizador de base de datos. En
Open SQL no es ni posible ni necesario desencadenar el uso de un índice secundario especificándolo
explícitamente en la sentencia SELECT.

58

93
Mecanismo de enlace para unión de tablas (JOIN)

A menudo es necesario leer datos de varias tablas y visualizarlos en una tabla.

En general, la técnica con el mejor rendimiento para esta tarea es un enlace de tablas. Leerá y
mostrará registros desde la tabla de base de datos SPFLI. Para cada registro, se debe mostrar
también los nombres completos de cada compañía aérea respectiva, que está almacenada en
SCARR. En la figura se muestra la creación lógica del enlace de tablas correspondiente, desde
la cual puede seleccionar todos los datos requeridos mediante la sentencia SELECT.

94
Entradas para definir una unión de tablas

Definición de unión de tablas

Especifique los siguientes detalles cuando defina un enlace de tabla:

Tablas de unión

¿A qué tablas de base de datos se debe acceder y cuáles se deben enlazar?

Condiciones de enlace

¿Cuáles son las condiciones para resumir los registros correspondientes en las tablas que se
combinarán en un enlace de tabla?

Columnas de unión

¿Qué columnas de las tablas seleccionadas deben estar disponibles en el enlace de tablas?

95
Opciones de implementación para uniones de tablas

Métodos para implementar un enlace de tablas

Estas son las diferentes formas de implementar un enlace de tabla:

En el Diccionario ABAP, cree una vista de base de datos que corresponda a un enlace de tablas
y selecciónela de este en su programa.

Para obtener información detallada, consulte la documentación online del Workbench ABAP, en
la sección Diccionario ABAP.

En su programa, usted define el enlace directamente en su sentencia SELECT (enlace ABAP).

En tiempo de ejecución, el sistema genera dinámicamente una consulta de base de dados
apropiada en la interfaz de base de datos.

Para obtener más información, consulte la documentación de palabra clave de la cláusula FROM
de la sentencia SELECT.

61

96
 Ejercicio 8 - Implementar un acceso a un registro individual de una
tabla
Se solicita crear un programa ABAP llamado ZABAPFmmyyyy##_SINGLE que lea de la base de
datos los datos de un vuelo determinado y lo muestre en una lista simple.

Pasos a seguir:
1. Cree el programa en la transacción se38 o se80 sin Include TOP.

2. En la siguiente ventana de diálogo, asegúrese de que el tipo de programa sea Programa

ejecutable.

3. Defina 3 parámetros para ingresar los datos del vuelo: carrid, connid y fldate.

4. Asegúrese de colocarlos en un recuadro con el título “Datos del vuelo” para que se vean bonitos.

5. Defina un tipo de datos local que contenga los campos: carrid, connid, fldate, seatsmax y
seatsocc. Todos con referencia a la tabla del diccionario sflight.

6. Defina una work área del tipo anteriormente creado.

7. Realice una búsqueda en la tabla sflight del vuelo que coincida con los datos ingresados en la
pantalla de selección y recupere los datos de los campos de la work área definida anteriormente.

8. En el caso que no se encuentre el vuelo se debe mostrar un mensaje indicando lo ocurrido.

9. En caso que el vuelo se encuentre, mostrar los datos obtenidos.

10. Verifique si existen errores de sintaxis en el programa. Active y realice un test.

97
 Ejercicio 9 - Implementar un acceso a múltiples registros de una tabla
mediante arrayfetch
Nos piden crear un programa ABAP llamado ZABAPFmmyyyy##_MULTIPLE que lea de la base de
datos los datos de los vuelos de una compañía y los muestre en una lista simple.

Pasos a seguir:
1. Copie el programa ZABAPFmmyyyy##_SINGLE con el nuevo nombre.

2. Defina una tabla interna con el tipo de línea de la work área ya definida.

3. En el caso en que el parámetro de la pantalla de selección tenga la fecha y el nro de vuelo en blanco,
se procederá a aplicar la nueva lógica detallada a continuación. En caso contrario el programa deberá
seguir funcionando como antes.

4. Realice una búsqueda en la tabla sflight de todos los vuelos que coincidan con el código de
aerolínea ingresado en la pantalla de selección volcando el resultado en la tabla interna

5. En el caso que no se encuentren datos se debe mostrar un mensaje indicando lo ocurrido.

6. En caso contrario, se debe realizar un loop de la tabla para mostrar los datos obtenidos.

7. Verifique si existen errores de sintaxis en el programa. Active y realice un test.

98
 Capítulo 6 Subrutinas en lenguaje ABAP

Subrutinas en lenguaje ABAP

Una subrutina es una unidad dentro de la modularización del programa donde se encapsula una
función en forma de código fuente. Usted saca una parte de un programa a una subrutina para
obtener una mejor visión de conjunto del programa principal y usar la secuencia correspondiente
en diversas ocasiones.

Usando subrutinas significa que su programa se vuelve más fácil de mantener porque los
cambios de funcionalidad solo tienen que ser aplicados en la subrutina y no en varios puntos de
un programa. Además puede procesar una subrutina con debug como una unidad y luego ver el
resultado, haciendo más fácil encontrar un error.

99
Modularización mediante subrutinas dentro de programas

Una subrutina es una unidad de modularización dentro de un programa. Para el intérprete ABAP, una
subrutina siempre forma parte del programa principal. En el ejemplo anterior de la imagen no se
utilizan parámetros, lo que hace que la sintaxis de la subrutina sea muy sencilla. Pero una subrutina
utiliza normalmente valores de objetos de datos y también los devuelve. La siguiente imagen,
Transferencia de parámetros: visibilidad de variables globales, muestra cómo se pueden utilizar estas
variables en la subrutina.

100
Definición de parámetros para subrutinas

Las variables definidas en el programa principal se pueden ver globalmente dentro del programa y se
pueden modificar en cualquier punto de este. Esto quiere decir que además las subrutinas definidas en el
programa pueden modificar las variables.

101
Transferencia de parámetros: definición de una interfaz

Desde una subrutina, puede tratar todas las variables globales definidas en el programa principal. Sin
embargo, para llamar una subrutina con objetos de datos diferentes para cada situación, debe utilizar
marcadores de posición en lugar de variables globales. Los marcadores de posición se sustituyen por
las variables globales requeridas al llamar la subrutina. Estos marcadores de posición se llaman
parámetros formales y juntos forman la interfaz de subrutina. Debe declarar la interfaz en el momento
de definir la subrutina.

Cuando se llama la subrutina, los parámetros formales deben ser especializados por medio de
variables globales correspondientes (parámetros reales). Esta asignación de parámetros reales a
parámetros formales al llamar una subrutina se llama transferencia de parámetros.

102
 Maneras de transferir parámetros de interfaz

La forma en la que se transfieren estas variables de programa principal a los parámetros

formales de la subrutina se denomina el tipo de transferencia y se especifica en cada parámetro
de la interfaz de la subrutina.

• Llamar por valor: Use este tipo de transferencia para poner a disposición de la subrutina el valor
de una variable global, en forma de una copia de variable, sin permitir que la subrutina modifique
la variable global respectiva.

• Llamar por valor y resultado: Use este tipo de transferencia para transferir el valor de una
variable global a la subrutina y para volver a escribir en el original el valor final completamente
procesado de la copia.

• Llamar por referencia: Use este tipo de transferencia para ejecutar el procesamiento de
subrutinas directamente en el parámetro real especificado.

103
Definición y llamada de subrutinas

Proceso de definición de subrutinas

Indique una subrutina con FORM.

Especifique el nombre y la interfaz de la subrutina después de FORM. A continuación, figuran las

sentencias de la subrutina.

Concluya la subrutina con la sentencia ENDFORM.

En la definición de la interfaz, puede colocar en una lista los parámetros de la subrutina (f1, f2 y
f3) y tipificarlos.

Especifique el tipo de transferencia requerido para cada parámetro de la siguiente manera:

Llamar por valor

Coloque en una lista cada uno de los parámetros formales que deben tener el tipo de
transferencia “llamar por valor” (f1) con el prefijo VALUE en USING. Consulte la imagen anterior
para conocer la sintaxis.

Llamar por valor y resultado

104
Coloque en una lista cada uno de los parámetros formales que deben tener el tipo de
transferencia “llamar por valor y resultado” (f2) con el prefijo VALUE en CHANGING. Consulte la
imagen anterior para conocer la sintaxis.

Llamar por referencia

Coloque en una lista cada uno de los parámetros formales que deben tener el tipo de transferencia “llamar
por referencia” (f3) con el prefijo VALUE en CHANGING. Consulte la imagen anterior para conocer la
sintaxis.

105
Especificación de tipo de parámetros de interfaz

Un parámetro formal se tipifica de forma genérica si se hace mediante TYPE ANY, o no se

tipifica en absoluto. Los parámetros reales de cualquier tipo se pueden transferir a un parámetro
de este tipo.

En tiempo de ejecución, se determina el tipo de parámetro real y se asigna al parámetro formal

(herencia de tipo) cuando se llama la subrutina. Sin embargo, si las sentencias de la subrutina no
son adecuadas para el tipo heredado, puede producirse un error de tiempo de ejecución
(conflicto de tipo). Solo utilice un tipo genérico cuando el tipo del parámetro real no se conozca al
crear el programa, o cuando el tipo del parámetro real pueda variar en el tiempo de ejecución
(programación dinámica).

Para implementar la tipificación concreta de un parámetro formal, se especifica un tipo global o

integrado en el suplemento TYPE. Al hacerlo, se determina que sólo se puedan transferir a la
subrutina los parámetros reales del tipo especificado. La verificación de sintaxis detecta cualquier
violación de la consistencia de tipo entre los parámetros formales y reales. La verificación de
sintaxis incrementa la estabilidad del programa, ya que previene los conflictos de tipo en
sentencias dentro de la subrutina.

Si tipifica con los tipos estándares P, N, C o X, la característica 'longitud de campo' que falta solo
se transfiere del parámetro real al parámetro formal en tiempo de ejecución. Con estos tipos se
consigue la tipificación completa (es decir, incluida la longitud de campo) al definir y especificar
tipos definidos localmente.

106
Objetos de datos locales y globales

Las variables definidas en el programa principal son objetos de datos globales. Son visibles y se
puede acceder a ellas en todo el programa principal y en cualquier subrutina llamada. Las
variables definidas dentro de una subrutina se llaman locales porque existen en la subrutina
relevante de la misma forma que los parámetros formales. El espacio de memoria de los
parámetros formales y los objetos de datos locales se asigna al llamar la subrutina y se libera de
nuevo después de la ejecución.

Los parámetros formales y los objetos de datos locales de una subrutina no pueden tener el
mismo nombre. Si existe un objeto de datos global con el mismo nombre que un parámetro
formal o un objeto de datos local, el parámetro formal o el objeto de datos local se trata dentro de
la subrutina y el objeto de datos global se trata fuera de la subrutina. Este proceso se llama regla
muestra: dentro de la subrutina, el objeto de datos local es la muestra del global con el mismo
nombre.

Para identificar los objetos de programa internos de forma única, utilice los prefijos siguientes
para sus objetos de subrutina: p... para parámetros de utilización, c... para parámetros de
modificación y l... para objetos de datos locales.

107
 Ejercicio 10 - Subrutinas

1. Modifique el programa ZABAPFmmyyyy##_CALCULADORA de manera que pueda realizar otro cálculo

distinto (cálculo de porcentaje) en una subrutina.

2. Copie el programa ZABAPFmmyyyy##_CALCULADORA y asígnele el

nombre
ZABAPFmmyyyy##_SUBRUTINA

3. Cree una subrutina (nombre sugerido: CALC_PORC) que lleve a cabo un cálculo de porcentaje mediante
dos parámetros de entrada y devuelva el resultado. La subrutina debe calcular el valor porcentual que
corresponde al primer parámetro, si el valor del segundo parámetro representa 100%.

4. Defina dos parámetros USING para transferir los operandos (nombres sugeridos: PV_ACT y PV_MAX), así
como un parámetro CHANGING para devolver el resultado (nombre sugerido: CV_RESULT). Tipifique los
parámetros de forma apropiada a los objetos de datos globales correspondientes del programa principal.

5. Implemente el cálculo de porcentaje en la subrutina. Asegúrese de evitar el error de dividir entre cero. En
este caso, emita un texto de advertencia en la lista

6. Amplíe el programa principal de forma que pueda llamar una nueva subrutina si el usuario indica el
operador aritmético “%”.

7. Amplíe la estructura IF o CASE con una bifurcación que se procese cuando el parámetro contenga el valor
“%”.

8. En esta bifurcación llame la subrutina y suministre los parámetros con parámetros reales y adecuados.

9. Ejecute el programa y verifique el resultado.

10. Siga el flujo del programa con el ABAP Debugger. Utilice las teclas de función o los botones adecuados
para omitir la subrutina o salir de ella.

108
 Capítulo 7 Utilización de ABAP
List Viewer (ALV)

Utilización de ABAP List Viewer (ALV)

Los siguientes temas ilustran las posibles áreas de aplicación de la programación ABAP
orientada a objetos y el uso de clases estándar de SAP. Por ejemplo, el control Grid ALV en el
contexto de Control Framework y add-ins empresariales (BAdI).

SAP Control Framework es una colección de clases e interfaces globales que se puede utilizar
para añadir controles SAP GUI en los programas de objetos ABAP, independientemente de la
plataforma.

El control Grid ALV es una herramienta que se puede utilizar para visualizar listas no jerárquicas
en una forma estandarizada. Los datos de la lista se muestran en tablas. Es muy fácil trabajar
con esta herramienta, ya que solo son necesarios unos pocos pasos de programación.

El control Grid ALV contiene numerosas funciones estándar interactivas que los usuarios de listas
necesitan a menudo, por ejemplo, imprimir o exportar. Como programador, tiene la opción de suprimir
estas funciones estándar. Si es necesario, puede adaptar las implementaciones para que cumplan las
necesidades de la aplicación. También es posible añadir las funciones propias a la barra de
herramientas de aplicación.

109
Incorporando un ALV en un programa
Para incluir un control ALV a un programa es necesario antes que nada contar con una tabla
interna donde estén cargados los datos a mostrar, en nuestro ejemplo la tabla será pt_salida.

A continuación se debe crear un objeto de la clase cl_salv_table que va a ser nuestro control ALV,
para ello necesitamos la variable lv_alv que será el puntero al nuevo objeto. No crearemos el objeto
de la manera tradicional (create object) sino que haremos uso del método Factory de la propia clase
cl_salv_table para crearlo. Este método recibe como parámetro el nombre de la variable que va a
apuntarlo y la tabla que contiene los datos:

El método Factory puede que lance una excepción en caso que no pueda crear el objeto ALV, es
por eso que lo llamamos dentro de un bloque try – endtry para que en el caso que hubiese algún
error lo atrape el catch y muestre el mensaje.

Una vez instanciado el objeto, ahora solo queda llamar al método que lo muestra por pantalla:

Al ejecutar este método se mostrará el reporte en su forma más sencilla:

75

110
Luego se pueden ir agregando opciones para dejarlo cada vez más lindo y con mayor
funcionalidad, por ejemplo, de la siguiente forma le agregamos la barra con los botones
standard:

111
El reporte quedaría del siguiente modo:

También otras opciones de visualización como por ejemplo la “cebra”:

112
El reporte quedaría del siguiente modo:

113
 Capítulo 8 Pantalla de selección
(Selection Screen)

Arquitectura de la pantalla de selección

En general, las pantallas de selección se utilizan para introducir criterios de selección para la
selección de datos. Por ejemplo, si el programa crea una lista de datos de una tabla de base de
datos muy grandes, a menudo tiene sentido para el usuario para seleccionar los registros de
datos que realmente requiere la lectura y sólo los de la base de datos. Además de reducir el
requisito de memoria, esto también reduce la carga de red.

114
 Ventajas de las pantallas de selección

La pantalla de selección tiene las siguientes funciones estándar:

 Textos sobre la pantalla de selección (textos de selección) se puede mantener en varios idiomas.
En tiempo de ejecución de los textos se muestran automáticamente en el idioma de inicio de sesión
del usuario. (Automática del idioma)

 El sistema verifica los tipos de forma automática: Si el usuario escribe algo que no se corresponde
con el tipo del campo de entrada, la interfaz gráfica de usuario SAP lo ignorará, por lo que ni siquiera
van a aparecer en la pantalla de selección.

 Además de las entradas solo valor (PARAMETERS), también se puede aplicar selecciones
complejas (SELECT-OPTIONS) en la pantalla de selección. El usuario puede entonces
introducir intervalos, las condiciones comparativas o incluso los patrones como las restricciones.

 Si el campo de entrada se define mediante un elemento de diccionario (por ejemplo, datos de

elementos), entonces el campo de la documentación (documentación del elemento de datos)
se pueden mostrar en el campo de entrada, utilizando la F1 (Ayuda para entradas) la tecla de
función.

 La ayuda del elemento de datos de búsqueda para mostrar las posibles entradas se pueden
llamar con el F4 (Ayuda para entradas) la tecla de función.

 Usted puede ahorrar fácilmente completado pantallas de selección de variantes para su

reutilización o el uso en el fondo la operación.

115
El gráfico anterior ilustra el uso de SELECTION OPTIONS, que permiten entradas complejas. Cada
pantalla de selección contiene un icono de información (también conocido como una ayuda "en
pantalla" icono). Seleccione este icono para mostrar información adicional

Si un campo de entrada se escribe con un elemento de dato, la siguiente información semántica

adicional está disponible en la pantalla de selección:

116
 La etiqueta del campo a largo del elemento de datos se puede copiar para describir el campo de
entrada en la pantalla de selección (selección de texto). (Véase el gráfico siguiente). La
documentación del elemento de datos está disponible automáticamente como una ayuda de
entrada (ayuda F1).

 Si ayuda de búsqueda está relacionada con el elemento de datos, está disponible como una
ayuda de entrada (ayuda F4).
(Una ayuda de búsqueda es un objeto independiente diccionario que muestra una lista de
posibles valores de entrada para el usuario (posiblemente con otra información), de la que puede
seleccionar uno para la entrada.)

 Si el campo de entrada se escribe con un campo de estructura que se define a su vez se utiliza
un elemento de datos, entonces antes descrita información semántica del elemento de datos
está disponible en la pantalla de selección. Si el campo de la estructura también se copia en un
buscar ayuda, entonces esto. Sobrescribe. la ayuda de búsqueda del elemento de datos.

En la pantalla de selección, los nombres de los campos de entrada aparecen como su

descripción de forma predeterminada. Sin embargo, puede reemplazarlos por los textos de
selección correspondientes, que luego se puede traducir a los idiomas más que usted requiere.
En tiempo de ejecución, los textos de selección son mostrados en la lengua de inicio de sesión
del usuario (automática de idioma).

Al igual que los encabezados de la lista y los símbolos de texto, textos de selección pertenecen a
los elementos de texto del programa. Desde el Editor de ABAP, seleccione el menú Ir: GoTo
→ Text Elements → Selection Texts para su mantenimiento.

Puede implementar su traducción con el menú Ir →.Traducción (GoTo → Translation.).

Si el campo de entrada se escribe directamente o indirectamente con un elemento de datos,

puede copiar el nombre del campo a largo de uno de los textos guardados en el diccionario

117
Las pantallas de selección efectuada son las variantes del programa. Después de que el
programa ha sido iniciado, el usuario puede cargar variantes a la pantalla de selección respectivo
para facilitar repetidas o casi idénticos entradas idénticas. Usted tiene que incluir una
variante cuando se programa un programa de ABAP en corrida de fondo, si el programa tiene
una pantalla de selección, como entradas de usuario no son posibles en el fondo.

Para definir las variantes específicas-programa por iniciar el programa, completando la pantalla
de selección y guardarlo (botón de disco). También puede definir los diferentes atributos de la
variante.

Si las variantes ya han sido definidas para un programa, a continuación, un pulsador adicional
aparece en la pantalla de selección con la bandera de texto. Variante conseguir..... Este botón se
enumera las variantes definidas para la selección.

Con el fin de poder definir sus propias variantes, el usuario debe contar con la autorización
correspondiente (en el sistema de producción). Pero también puede definir variantes en el
sistema de desarrollo y luego los han transportado al sistema de producción. Variantes con el
prefijo de nombre 'CUS &' son variantes del sistema. Son transportados como objetos del
repositorio común y no específico del cliente. Todas las otras variantes son específica del
cliente y debe ser transportado por separado. Desde el Editor de ABAP, seleccione el menú Ir

→ variantes (GoTo → Variants) para ir a la variante de la gestión de su programa, donde

se puede realizar en marcha para su mantenimiento siga variantes con respecto a los valores y
atributos. Allí, elija el menú Herramientas → Transporte Solicitud (Tools → Transport Request)
para especificar las variantes para ser transportado, así como solicitar una. El transporte pasa
cuando la solicitud se libera.

Para obtener más información sobre las variantes, elija el botón de información sobre atributos de la
variante en la pantalla a fin de mantener sus atributos de la variante.

118
 Opciones de entrada en la pantalla de selección

Lo anterior muestra el uso de gráficos y el comportamiento en tiempo de ejecución de una

variable de entrada se define mediante una instrucción PARÁMETROS. Una vez más, la
definición de dicha variable de entrada crea una variable en el sistema e, implícitamente, genera
una pantalla de selección con una opción de entrada correspondiente.

Una variable de entrada se define en la misma forma que una variable ordinaria. La única
diferencia es que la palabra clave Parámetros se utiliza en lugar de datos.

Usted tiene que considerar tres características:

 El nombre de la variable de entrada puede ser de hasta ocho caracteres de longitud.

 No puede ser escrita con la F tipos estándar, cuerda y XSTRING.

 La asignación de un valor predeterminado no se implementa con la adición de valor, pero con la

adición DEFAULT.

Una asignación de valores por defecto por medio de la adición DEFAULT o el valor de
asignación antes de mostrar la pantalla de selección (inicialización) se muestra en la pantalla de
selección como un valor predeterminado que se puede sobrescribir. Si el usuario introduce un
valor y elige Ejecutar, los valores de entrada se transfieren a la validez interna y, por ejemplo, se
puede utilizar para restringir la selección de base de datos.

119
 Puede utilizar la sentencia SELECT-OPTIONS <name> FOR <data object> para definir una
opción de selección para indicar selecciones complejas, donde <name> es el nombre de la
opción de selección y <data object> es una variable predefinida. Dicha definición crea una tabla
interna del nombre especificado dentro del programa (so_car) y genera una pantalla de selección
con una opción de entrada para limitar la variable especificada (gs_spfli-carrid).

El sistema transporta las entradas del usuario a la tabla interna que se generó automáticamente
cuando el usuario selecciona el botón Ejecutar. La tabla interna tiene cuatro columnas: sign,
option, low y high.

Entradas creadas para entrada de usuario:

En la imagen se muestran las siguientes entradas creadas para la entrada de usuario:

• Si se introduce LH, se genera una fila con los valores I (incluido), EQ (igual), LH y espacio.

• Si se introduce el intervalo AA a DL, se genera una fila con los valores I (incluido), BT (entre), AA
y DL.

• Si se introduce BA como único valor para excluir, se genera una fila con los valores E (excluido),
EQ (igual), BA y espacio.

Después de que la tabla interna se haya rellenado con los criterios de selección, se puede utilizar
para limitar la selección de contenido de la base de datos.

120
Declarando Campos con Select Options

The SELECT-OPTIONS keyword is a declarative language element with the same eight- character
naming restriction as PARAMETERS. Unlike thePARAMETERS

keyword, SELECT- OPTIONS permits a range of values and complex selections instead of
just a single input- ready field.

La palabra clave SELECT-OPTIONS genera una tabla interna <seltab> con una estructura
estándar y una línea de encabezado. Esta tabla tiene cuatro columnas: signo, opción, bajo y alto.
Al igual que con los PARÁMETROS, puede mantener el texto de selección utilizando la ruta del
menú Ir a → Elementos de texto

→ Textos de selección.

Use la adición FOR para especificar el campo contra el cual el sistema debe verificar las
entradas de selección. Este campo debe declararse en una declaración DATA o TABLES. Los
campos alto y bajo heredan los atributos del campo referenciado.

Cada línea de la tabla de selección <seltab> formula una condición utilizando uno de los
siguientes operadores relacionales:

• SIGNO: I (Incluir), E (Excluir)

• OPCIÓN: EQ, NE, LE, LT, GE, GT, BT (entre), NB (no entre), CP (contiene el patrón), NP (no
contiene el patrón)

El conjunto de selección es la unión de todas las inclusiones (I1, ..., In) menos la unión de todas
las exclusiones (E1, ..., Em). Si no se ingresan valores en el objeto SELECT-OPTIONS, todas las
filas se devuelven de la base de datos.

121
Cuando el usuario realiza entradas en un objeto SELECT-OPTIONS, el sistema llena
automáticamente la tabla interna.

Para cambiar las entradas predeterminadas para los campos de tabla SIGN y OPTION, elija el
menú Editar → Opciones de selección., El sistema ofrece alternativas apropiadas para la
selección. Si el ícono de la señal de tráfico es verde durante la Selección, hay un (I) nclusivo en
la columna de señal. Una luz roja indica (E) xclude.

Para eliminar una entrada de la tabla, use el menú Editar → Eliminar criterio de selección.

Cada criterio de selección se puede usar para hacer selecciones múltiples a menos que se
defina lo contrario. Si hay varias selecciones, el color de la flecha cambia de blanco a verde.

122
 Las adiciones a las declaraciones SELECT-OPTIONS son:

DEFAULT le permite establecer valores predeterminados para parámetros bajos o bajos y altos.
Puede usar OPTION y SIGN para establecer los valores predeterminados para la opción y el
signo, que difieren de la adición de <valor> predeterminada normal.

Puede establecer un valor predeterminado para una palabra clave SELECT-OPTIONS con la
adición DEFAULT <value>. Si asigna una ID DE MEMORIA <pid>, el sistema recupera el valor
actual de la memoria del sistema SAP y lo muestra automáticamente. CASO INFERIOR suprime
la conversión de

La entrada a mayúsculas. Esta adición no está permitida para los campos del Diccionario,
porque el atributo establecido en el Diccionario tiene prioridad.

 OBLIGATORIO genera un campo obligatorio. Se muestra un signo de interrogación en el campo

de entrada en la pantalla de selección y el usuario debe ingresar un valor.
 SIN EXTENSIÓN suprime múltiples selecciones de rango simple o múltiple.
 NO INTERVALS suprime la entrada seltab-high (límite de intervalo superior) en la pantalla de
selección. Puede usar la pantalla adicional, SELECCIÓN MÚLTIPLE, para especificar rangos.

Diseño de pantallas de selección con Selection Screen

Puede usar la palabra clave SELECTION-SCREEN para diseñar el diseño de la pantalla de

selección. Puede agrupar elementos de pantalla que lógicamente pertenecen juntos usando la
extensión BEGIN OF BLOCK <bloque>. Puede colocar un marco alrededor de los elementos de
la pantalla usando WITH FRAME. Puede anidar marcos a una profundidad máxima de cinco.

123
Puede asignar un título al bloque solo si usa un marco. Puede declarar el título como text-xxx o
un nombre de campo con una longitud máxima de ocho caracteres. En el segundo caso,
establece el texto en tiempo de ejecución en el evento INITIALIZATION. Antes de diseñar una
pantalla de selección, debe familiarizarse con las pautas de diseño de pantalla enumeradas en
las transacciones BIBS.

Puede mostrar múltiples parámetros y comentarios en la misma línea en la pantalla.

Para hacerlo, debe incluir los parámetros entre las instrucciones SELECCIÓN-PANTALLA
PRINCIPIO DE LÍNEA y SELECCIÓN-PANTALLA FINAL DE LÍNEA. El parámetro COMMENT le
permite incluir texto en la línea.

El texto del comentario siempre debe tener un formato (posición y longitud de salida). La posición
se puede establecer usando un campo de datos o pos_low o pos_high. Estas últimas son
posiciones baja y alta para el campo SELECCIONAR OPCIONES en la pantalla de selección.

Agregar COMENTARIO ... PARA CAMPO <f> asegura que la Ayuda F1 para el campo <f> se
muestre para el texto del comentario y el parámetro. Si oculta el parámetro (variante de
selección: atributo invisible), el texto del comentario también se oculta.

Puede usar POSITION <pos> para establecer el cursor para la siguiente posición de salida (solo
dentro de ... BEGIN OF LINE ... END OF LINE).

124
Authority-Check

En la pantalla de la selección EN el acontecimiento AT SELECTION-SCREEN están ambos

accionados cerca el elegir Enter tan bien como ejecute (F8). Después de que se haya
procesado el bloque de proceso correspondiente, se acciona el acontecimiento siguiente de
START-OF-SELECTION y el proceso relevante comenzado, si ejecute fue utilizado. Sin
embargo, si Enter fue elegido, la pantalla de la selección se exhibe otra vez.

Inmediatamente antes de procesar el AT SELECTION-SCREEN bloque, las entradas de usuario

se transfieren automáticamente a las variables correspondientes en el programa. Por lo tanto,
tiene sentido para la aplicación requiere comprobaciones de autorización de entrada y en este
bloque de tratamiento. Si el resultado de verificación es negativo, sólo tiene que enviar un
mensaje de error al usuario y tener la pantalla de selección de muestra de nuevo. El usuario
tiene entonces la opción de hacer nuevas entradas. Por el contrario, un mensaje de error en el
START-OF-SELECTION bloque se mostrará en el programa de terminación.

El siguiente gráfico ilustra un simple programa de ejemplo con el cheque de autorización y de

diálogo de error en la pantalla de selección.

125
126
 Capítulo 9 Sentencias útiles – ABAP

Capítulo 9 - Sentencias útiles ABAP

CONCATENATE
Definición

Se utiliza para concatenar varios campos alfanuméricos en uso solo.

Sintaxis:

CONCATENATE <c1> ... <cn> INTO <campo> [ SEPARATED BY <s> ].

Esta sentencia concatena los campos campos <c1> ... <cn> en el campo <campo>. Los
espacios en blanco se ignoran

durante la operación.

Con la cláusula SEPARATED BY se puede especificar un campo alfanumérico (el campo <s>)

que será utilizado

como separador entre los campos <c1> ... <cn>. Si el resultado de la concatenación entra en el
campo <campo>, SY-SUBRC = 0, si por el contrario, es necesario el truncamiento, SY-SUBRC =
4.

Ejemplo 1:

DATA:
ONE(10) VALUE 'Ivan',
TWO(3) VALUE 'Rodrigo',
THREE(10) VALUE ' Baños',
NAME(20).

CONCATENATE ONE TWO THREE INTO NAME.

La variable NAME valdría: IvanRodrigoBaños

Ejemplo 2:

DATA: ONE(10) VALUE 'Ivan',

TWO(3) VALUE 'Rodrigo',
THREE(10) VALUE 'Baños',

127
NAME(20),
SEPARATOR(4) VALUE 'GAUSS'.

CONCATENATE SPACE ONE TWO THREE INTO

NAME SEPARATED BY SPACE.

La variable NAME valdría: Ivan Rodrigo Baños.

SPLIT
Definición

Divide un campo alfanumérico en varios campos, gracias a algún separador.

Sintaxis:

SPLIT <campo> AT <delimitador> INTO <c1> ... <cn>.

Esta sentencia utiliza el campo indicado en <delimitador> para separar los campos <c1> ...

<cn> el contenido del campo <campo>. Si no hay especificado los suficientes campos para
poder separar todo el contenido del campo <campo>, sobre el último se rellena el resto del
campo <campo>. Si todos los campos destino son lo suficientemente grandes como para
almacenar las partes de <campo>, SY-SUBRC vale 0. En caso contrario SY-SUBRC vale 4.

También se puede situar las partes del campo que se quiere separar en una tabla interna con el
siguiente formato:

SPLIT <campo> AT <delimitador> INTO TABLE <tabla>.

Por cada parte del campo <campo el sistema añade una nueva línea en la tabla interna

<tabla>.

Ejemplo 1:

DATA: NAMES(30) VALUE 'Charly, John, Peter',

ONE(10),
TWO(10),
DELIMITER(2) VALUE ','.
SPLIT NAMES AT DELIMITER INTO ONE TWO.

ONE valdrá "Charly" y TWO tendrá el valor "John ".

Ejemplo 2:

DATA: BEGIN OF ITAB OCCURS 10,

WORD(20),
END OF ITAB.

128
SPLIT 'STOP Two STOP Three STOP ' AT 'STOP' INTO TABLE ITAB.

La tabla interna tendrá tres líneas, la primera en blanco, la segunda contiene "Two" y la tercera
contiene "Three".

COMMIT WORK
Definición

A veces es necesario asegurarse que los cambios en la base de datos se han realizado, antes
de continuar con el proceso. Por el contrario, a veces es necesario deshacer algunos cambios
realizados en la base de datos. Para confirmar los cambios realizados sobre la base de datos se
utiliza la sentencia COMMIT WORK

Sintaxis:

COMMIT WORK [ AND WAIT ].

para deshacer los cambios realizados en la base de datos se utiliza la sentencia ROLLBACK
WORK. Estas sentencias tienen un papel importante en la programación de transacciones de
diálogo.

Con la cláusula AND WAIT, el programa se para hasta que la tarea de actualización termina. Si
la actualización es satisfactoria, SY-SUBRC vale 0, en caso contrario, SY-SUBRC toma un valor
distinto de 0.

TRANSLATE
Definición

Se utiliza para convertir caracteres de mayúscula a minúscula o viceversa, o para realizar

sustituciones de caracteres a través de ciertas reglas.

Sintaxis:

TRANSLATE <campo> TO { UPPER | LOWE } CASE.

Con la opción UPPER, las letras minúsculas de <campo> se convierten en mayúsculas. Y con la
opción LOWER las letras mayúsculas se convierten en minúsculas.

Para utilizar reglas de conversión se utiliza la siguiente sintaxis. TRANSLATE <campo> USING
<regla>.

129
Esta sentencia reemplaza todos los caracteres de <campo> que cumplan la regla de sustitución
<regla>. La regla de la sustitución contiene pares de letras, la primera de ellas indica el carácter
a sustituir, la segunda indica el carácter de sustitución.
<regla> puede ser una variable.

CONDENSE
Definición

Para borrar espacios en blanco superfluos en campos alfanuméricos.

Sintaxis:

CONDENSE <campo> [ NO-GAPS ].

Borra cualquier secuencia de espacios en blanco, dejando sólo uno que exista entre palabras
existentes en <campo>.

Los espacios en blanco por la izquierda también deSAParecen.

Con la cláusula NO-GAPS todos los espacios en blanco deSAParecen.

Ejemplo 1:

DATA: BEGIN OF NAME,

TITLE(8), VALUE 'DR.',
FIRST_NAME(10), VALUE 'MICHAEL',
SURNAME(10), VALUE 'HOFMANN',
END OF NAME.

CONDENSE NAME.

WRITE NAME.

La salida en pantalla sería: Dr. Michael Hofmann

Ejemplo 2:

DATA: BEGIN OF NAME,

TITLE(8), VALUE 'DR.',
FIRST_NAME(10), VALUE 'MICHAEL',
SURNAME(10), VALUE 'HOFMANN',
END OF NAME.

CONDENSE NAME NO-GAPS.

La variable NAME valdría: Dr.MichaelHofmann

130
UNPACK
Definición

Desempaqueta el contenido de un campo sobre otro.

Sintaxis:

UNPACK <campo1> TO <campo2>.

Desempaqueta el campo <campo1> en el campo <campo2>. Es la operación contraria a la

sentencia PACK.

Ejemplo:

DATA: P_FIELD(2) TYPE P VALUE

103, C_FIELD(4) TYPE C.

UNPACK P_FIELD TO C_FIELD.

P_FIELD: P'103C' -> C_FIELD:
C'0103'.

131
 Capítulo 10 Módulo de funciones

Capítulo 10 - Módulo de funciones

Módulos de función son procedimientos especiales que son visibles de forma global y que se
puede llamar desde otros programas ABAP. Sólo pueden ser definidas y aplicadas de programas
especiales de ABAP, denominados grupos de funciones.

Screens

Grupos de función puede contener pantallas, que permite encapsular los cuadros de diálogo de
usuario en los módulos de función.

Remote capability

Módulos de función se puede llamar por sistemas externos (Remote Function Call).

Update

Algunos módulos de función (módulos de actualización) puede ser utilizado para las
actualizaciones. No se ejecutan directamente cuando se le llama, sino que al final de la unidad
lógica de trabajo (LUW).

Asynchronous execution

Módulos de función se ejecuta en paralelo en un proceso de trabajo por separado. El

programa de llamada no espera hasta que la transformación del módulo de funciones se
haya completado.

Testeo módulo de funciones standard

TRX: SE37

Modulo Funciones “POPUP_TO_CONFIRM” -> Ejecutar

132
133
Presionando Si, retorna:

Presionando No, retorna:

Exporting depende de donde me encuentro. exporting es lo que mando e importing es lo que

envío, en invocación de la función es abreves.

En importing puedo declarar una tabla (TYPE tabla del diccionario). en la solapa tabla tengo el
problema que no se si es de entrada o salida.

Grupo de funciones
Es un repositorio que agrupa funciones y que se utiliza principalmente para compartir subrutinas
y declaraciones de variables entre las distintas funciones pertenecientes al grupo.

Grupos de funciones no son programas ejecutables, es decir, no se puede iniciar con los códigos
de operación o por sus nombres. Sirven exclusivamente como programas principales de los
módulos de función. En la mayoría de los casos, un grupo de funciones contiene varios módulos
de función que realizan funciones relacionadas o actuar en los mismos datos.

Cuando un programa ABAP llama a un módulo de funciones, el grupo de función

correspondiente se carga en la sesión de residente, donde permanece hasta que el programa de
llamada termina. Si el programa llama a los módulos de varias funciones del mismo grupo de
funciones (o la misma función que el módulo varias veces) de forma consecutiva, el grupo de
funciones sólo se carga durante la primera llamada.

134
 Aparte de los módulos de función, los grupos de función también puede contener los siguientes
elementos:

. Datos declaraciones (objetos de datos globales)

. Subrutinas

. Pantallas

Estos elementos pueden ser utilizados por todos los módulos de función en el grupo de
funciones.

Para crear un grupo de funciones, debemos seleccionar en el menú de la transacción SE37 la

ruta Goto/Functions Groups/Create Group

O también se puede hacer desde la TRX SE80

Aquí ingresaremos el nombre de nuestro grupo de función y presionamos el botón Save como
vemos a continuación:

135
136
Ejercicio 11 - Crear un Grupo de Funciones
Objetivos del Ejercicio

Después de completar este ejercicio usted va a poder cear un grupo de funciones

Tarea:

Crear un Grupo de Funciones

1. Crear el grupo de funciones ZBC402_##_CONN.

137
Creando Modulo de Funciones:
SE37 -> crear O tambien por SE80

Para crear un módulo de función accedemos a la transacción SE37. Allí escribiremos el nombre
de nuestra función y presionaremos el boton Create

Attributes: aquí especificamos la descripción de la función y el tipo de función que puede ser
Normal, RFC o Update module.

Import: aquí especificamos los parámetros de salida de la función

138
Export: aquí especificamos los parámetros de entrada de la función

Paso por valor: los parámetros formales son creados como copias de los parámetros actuales.
Los cambios en los parámetros formales no afectan a los parámetros actuales.

Paso por referencia: solo la dirección de los parámetros actuales se transfieren a los
parámetros formales. Dentro de la subrutina, se trabaja con el campo del programa que hace la
llamada. Si cambiamos los parámetros formales, el contenido del campo del programa que hace
la llamada también cambia.

Changing: aquí especificamos los parámetros de salida que cambiarán de valor con la ejecución
de la función.

Tables: aquí especificamos las tablas que se utilizan en la función.

Source Code: aquí pondremos el código Abap de la función.

139
Exceptions: aquí especificamos las excepciones de la función. Una excepción es un error que
se produce al ejecutar la función y que ha sido catalogado cuando se creo el módulo de función
de modo de poder identificar rápidamente el motivo del error

Documentacion

140
 Estructura del grupo de funciones

Programa principal, SAPL<fgrp>, merely contains INCLUDE statements for the following include
programs:

 TOP include
Include L<fgrp>TOP contendra las declaraciones de variable globales.

 U includes
Include L<fgrp>UXX contendra los includes L<fgrp>U01, L<fgrp>U02,

... . Estos contendran el codigo adicionado en cada modulo de funciones

 F includes
Include L<fgrp>F01, L<fgrp>F02, ... puede ser utilizado para generar subrrutinas

 includes
Include L<fgrp>O01, L<fgrp>O02, ... Utilizado para PBO

 I includes
The include programs L<fgrp>I01, L<fgrp>I02, ... Utilizado para PAI

141
142
 Ejercicio 12 - Crear un Módulo de Funciones
Objetivos del Ejercicio

Después de completar este ejercicio usted va a poder:

 Crear un Módulo de Funciones
 Definir las interfaces del módulo de funciones
 Documentar un módulo de funciones

Tarea 1:

Preparación

1. Desplegar un módulo de funciones existente con la Transacción SE37 y familiarizarse con los
tipos de parámetros de la interface.
2. Si no ha creado aun el grupo de funciones crearlo en este momento.

Tarea 2:

Crear un módulo de funciones para la lista de vuelos

1. Crear un nuevo módulo de funciones y nombrarlo Z_BC402_##_GET_CONN_LIST en el grupo

de funciones creado anteriormente.
2. Definir un parámetro de entrada para ciudades de origen y destino “departure and destination
cities”.

Elegir los mismos tipos de datos que en las tablas correspondientes. Tiene sentido crear los
parámetros opcionales?

Elija si los parámetros a transferir van a ser por parámetros o por valor?

1. Defina un parámetro de salida para la lista de vuelos. Utilice un tipo de tabla apropiada para el
parámetro.
2. Ingrese la documentación necesaria para el módulo de funciones, para los parámetros y para las
excepciones.

143
Llamado de módulo de funciones:

Botón PATTERN, llamamos POPUP_TO_CONFIRM

144
Tomando las exepciones

se borra el IF y se pone case sy-subrc.

WHEN 1.

WHEN 2.

WHEN 3.

145
 Ejercicio 13 - Uso de declaraciones globales en un grupo de funciones.

Objetivos del Ejercicio

Después de completar este ejercicio usted va a poder:

 Usar declaraciones globales

 Entender como es el procesamiento de un módulo de funciones
 Testear secuencial mente módulos de Funciones

Tarea 1:

1. Crear una tabla interna en el Top de la función y luego llenarla con un Select.
2. Crear una subrutina en la función en donde manipularemos los resultados obtenidos para solo
devolver algunos

Tarea 2: (Opcional)

Si la tabla se encuentra vacía generar una excepción para este caso.

146
Qué es un módulo de función RFC?
Un módulo de función RFC consiste en una llamada a una función que existe en un sistema
distinto al del programa que la llama. El objetivo principal de las RFC es acceder a otros
ambientes para obtener datos.

La comunicación puede darse entre sistemas SAP o entre un sistema SAP y otro sistema que no
sea SAP. Para llamar a una función RFC se debe agregar la cláusula DESTINATION al
momento de declarar la función, como vemos en el siguiente ejemplo.

Cómo crear una RFC?

Una función RFC se crea de la misma manera que se crea un función. Se accede a la transacción
SE37 y se completan los mismos parámetros que completamos para crear una función a excepción
de que se debe seleccionar en la solapa de Atributos la opción Remote Enabled Module.

Los parámetros que se crean en una función RFC no se pueden pasar por Referencia, deben
pasarse por valor. Esto se logra tildando el check Pass value para cada parámetro en las
solapas IMPORT, EXPORT y CHANGING.

147
RFC( Remote Function Call ) en SAP R/3
Esta tecnología se usa para comunicar entornos diferentes que pueden ser del mismo o de tipos
diferentes, otra forma de realizar conexión entre procesos es por medido del uso de las
tecnologías OLE.

Pasos del Proceso

1. Crear destino
2. Crear grupo de funciones
3. Crear funcion
4. Crear programa usuario de la funcion

1.- Crear Destino( se usa transaccion SM59 )

Nodo Conexiones R/3( se hace en la maquina destino )

Nombre ZUAXRFC...Conexion con maquina de

conexión produccion
Destino RFC ZUAXRFC
Tipo Conexion 3( Conexion R/3 )
Distribucion S
carga i No( marcar este )
Maquina destino Direccion IP de maquina fuente
0
No. Sistema 0

Opciones de seguridad

Trusted system: si no(marcar este) SNC act / inact(marcar este)

Descripcion: Conexion con la maquina productiva

Acceso a sistema

Idioma: ES
Mandante:
0400
Usuario: IDUSUARIO
Clave acceso: **********
Usuario actual(desmarcado )
Clave acceso no codificada( desmarcado )

2.- Crear grupo de funciones

Grupo funciones: ZUAXRFC
Descripcion: Lectura de la tabla ZUAXRFC en produccion
Aplicacion: F( contabilidad financiera )
Tablas: parametro tabla estructura referencia
TAB_ZUAXRFC
ZUAXRFC Forma de ejecucion

Remote Function Call soportado( marcar este ) Inicio inmediato( marcar este )

148
 3. Crear función( pertenece al grupo ZUAXRFC )

FUNCTION Z_UAX_RFC.

SELECT * FROM ZUAXRFC INTO TABLE TAB_ZUAXRFC.

ENDFUNCTION.

4. Crear PROGRAMA( llama la función Z_UAX_RFC )

REPORT ZUAXRFC.
* --------------------------------------------------------------------
* --------------------------------------------------------------------
* Programa : zuaxrfc
* autor : Francisco Reyes
* fecha : 13 de abril del 2000
* objetivo : Probar comunicación RFC
* --------------------------------------------------------------------
* tablas usadas por el proceso
* tabla descripción
* zuaxrfc tabla de prueba para comunicación rfc
* --------------------------------------------------------------------
* Descripción del proceso
* 1.- Crea tabla interna en función de la tabla ZUAXRFC
* 2.- Llama la función rfc z_uax_rfc que le devuelve la tabla tab_zuaxxrfc
* 3.- Actualiza la tabla zuaxrfc de la maquina destino en función de los datos recibidos de la
función rfc
* --------------------------------------------------------------------
* -------------------------------------------------------------------
DATA: BEGIN OF TAB_ZUAXRFC OCCURS 0.
INCLUDE STRUCTURE ZUAXRFC.
DATA: END OF TAB_ZUAXRFC.

CALL FUNCTION 'Z_UAX_RFC' DESTINATION

'ZUAXRFC' TABLES TAB_ZUAXRFC =
TAB_ZUAXRFC

MODIFY ZUAXRFC FROM TAB_ZUAXRFC.

149
Business Application Programming Interface (BAPI) - SAP R/3

Las BAPI's son funciones que sirven para realizar acciones sobre los objetos de negocios de SAP.
Son en realidad métodos de los objetos de negocios, y gracias a ellos podemos realizar cargas
evitando utilizar Batch Inputs por Call Transaction.

Básicamente son funciones como cualquier otra función en ABAP, así que poseen las mismas
características: parámetros de entrada, de salida, tablas, excepciones...

Por lo general cuando se hace un modificación de un objeto con una BAPI es necesario realizar
un COMMIT explícito mediante la función BAPI_TRANSACTION_COMMIT. Si quieren probar si
una función les sirve para cargar algún dato en particular, pueden utilizar la transacción SE37 e ir
al menú Módulo de Funciones->Verificar->Secuencias Test. Allí se pueden encadenar funciones,
de manera de poder ejecutar primero la BAPI y después la función
BAPI_TRANSACTION_COMMIT para probar si efectivamente el dato que necesitan cargar es
cargado por la BAPI que estén probando.

Ventajas de usar BAPI

Las BAPIs son métodos estandarizados de los Objetos de Negocio SAP R/3, que permiten la
integración de los componentes de software de los clientes y de terceros. Algunas de las
ventajas de usar BAPIs son:

. Es un Estándar de Negocio
. Es un Estándar Consensuado
. Garantiza estabilidad y compatibilidad futura
. Garantiza orientación a objetos
. Independencia de entorno (apertura)

Usar BAPIs en programas de aplicación

Actualmente una BAPI puede ser invocada de dos formas diferentes:

. Llamar la BAPI en el repositorio

. Hacer llamada RFC a la función que implementa la BAPI

Listado de BAPIs SAP:

BAPI de creación de Pedidos de Venta:

BAPI de creación de Pedidos de Compra:
BAPI de Verificación de Facturas:
BAPI de facturación:
BAPI de Movimiento de mercancías:
BAPI modificación Pedido de ventas:

150
 BAPI_BILLINGDOC_CREATEMULTIP
BAPI_SALESORDER_CREATEFROMDAT2 LE BAPI_GOODSMVT_CREATE
BAPI_PO_CREATE BAPI_SALESORDER_CHANGE
BAPI_INCOMINGINVOICE_CREATE

151
 Capítulo 11 Ampliaciones en SAP

Capítulo 11 – Ampliaciones en SAP

¿Qué son las ampliaciones? Ventajas y Desventajas

Las ampliaciones son diferentes herramientas que presenta SAP para realizar mejoras, modificaciones o
agregados a un programa, en general un programa estándar.

Algunos programas estándares están preparados como para agregarles funcionalidad nueva a la existente. En
algunos casos se puede validar campos de alguna dynpro en particular; agregar campos a una pantalla con
código que permita tratar esos datos nuevos; agregar una nueva opción dentro de un menú o agregar campos a
tablas estándares.

Las ampliaciones se generan y codifican en módulos a parte del código estándar, con lo cual no se necesita
modificarlo, manteniendo la funcionalidad original y el buen funcionamiento.

Ventajas:

 Permite modificar ciertos programas para adaptarlo a necesidades particulares de la

empresa, agregando nuevas características a las existentes.

 Permite realizar mejoras a un programa sin modificar el código original del mismo,
manteniendo el buen funcionamiento y las características que tenía.

 Los cambios toman efecto con sólo transportar los nuevos objetos.

Desventajas:
 No siempre se pueden hacer todas las modificaciones de manera satisfactoria, ya que la
mayoría de las ampliaciones están preparadas para una determinada tarea y momento dentro
de la ejecución de un programa.

 No todos los programas estándares están preparados para agregar ampliaciones.

 Por ejemplo todos los programas no tienen User Exit.

152
Tipos de ampliaciones
En SAP existen varios tipos de ampliaciones, que son utilizadas de acuerdo al tipo de mejora
que se quiera desarrollar, cada una con sus particularidades que serán explicadas en detalle
más adelante.

User Exit:
Un User Exit es un punto dentro de un programa en donde se puede invocar a un programa propio
agregando una funcionalidad nueva al programa original.

Field Exit
Los Field Exit se utilizan para relacionar un campo de una dynpro de un determinado
programa con un módulo de función, donde generalmente es utilizado para validar ciertos
campos de la pantalla.

Screen Exit
Un Screen Exit se utiliza para agregar nuevos elementos a una dynpro de un programa
estándar, ya sea campos, textos, botones, etc. Los Screen Exits son definidos en áreas
especiales llamadas Subscreens.

Menu Exit
Un Menu Exit permite agregar una transacción dentro de un menú estándar de SAP.

Business Transaction Events (BTE)

Un BTE (Business Transaction Events) es un evento dentro de una transacción que se puede
utilizar validar datos o para el agregado de Módulos de Función.

Include o Append a tablas transparentes

Los Include en tablas transparentes permiten agregar nuevos campos a tablas transparentes
estándares, como también a tablas Z.

Keyword Exit
Los Keyword Exit permiten cambiar la descripción breve de un elemento de datos, sus
etiquetas o denominaciones y la documentación que presenta SAP al presionar F1 sobre el
elemento de datos.

12

153
User Exit
Un User Exit, o también llamado Customer Exit, es un punto dentro de un programa en donde
se puede llamar a un programa propio. Los User Exit se programan en módulos de funciones
definidos de acuerdo al programa al cual va a ser referido.

Algunos programas estándares tienen dentro de su código, llamadas a módulos de funciones

que pueden ser modificados por el programador.

Los User Exit son llamados dentro de los programas estándares por un número. Este número es
la terminación del nombre del módulo de función que está asociado al programa. En la tabla
MODSAP se encuentran todos los módulos de función que se utilizan para User Exit. Los
módulos de función tienen una nomenclatura estándar: EXIT_nombre del
programa_número de función. Ejemplo: EXIT_SAPMV45A_002.

Por ejemplo el programa SAPMV45A llama al módulo de función EXIT_SAPMV45A_003

pasándole ciertos parámetros y tomando otros como resultado de la ejecución del mismo.

CALL CUSTOMER-FUNCTION '003' EXPORTING

XVBAK = VBAK XVBUK = VBUK

XKOMK = LVS_KOMK

IMPORTING

LVF_SUBRC = LVF_SUBRC TABLES

XVBKD = XVBKD XVBFA = XVBFA

XVBAP = XVBAP XVBUP =

XVBUP.

Lo importante de esto es saber si sirve para lo que se quiere hacer. Saber cuándo se ejecuta,
qué datos utiliza, qué hace luego con los datos que devuelve. No siempre pueden ser
utilizados los User Exits como se pretende ya que no cumple con todas las condiciones que
se quiere.

Ventajas

El User Exit es una buena herramienta para agregar funcionalidad nueva a un programa
estándar como puede ser una validación o la ejecución de rutinas de control sin modificar el
código original.

Para transportar y activar los User Exit es suficiente con el Include nuevo únicamente, sin
tocar el programa original.

154
Desventajas

No siempre se ajusta el User Exit a las necesidades del programador ya que los objetos que
importa o exporta son fijos y pueden no tener todos los objetos que se requieren.

No existe una búsqueda de User Exit por programa con una aclaración amplia de su
utilización, para buscarlos hay que realizar una búsqueda del string CALL CUSTOMER-
FUNCTION dentro del programa control estándar y su funcionamiento se prueba sin
saber exactamente si es el correcto para lo que se quiere hacer.

Pasos para realizar un User Exit

1°) Ejecutar la transacción SMOD, que es la que maneja las ampliaciones en SAP. En esta
transacción se debe completar el nombre de la ampliación que contiene el módulo de función a
utilizar por el USER EXIT.

Si no se conoce el nombre aún, hay que ir a la transacción SE16, con la tabla

MODSAP, campo MEMBER completar con el nombre del módulo de función a buscar (Ejemplo
EXIT_SAPMV45A_003). El campo NAME nos dirá la ampliación que la contiene.

Si tampoco se conoce el módulo de función específico, debe buscarse en el código del programa
estándar las llamadas a funciones de usuario, que generalmente están como CALL
CUSTOMER-FUNCTION ‘001’. El número del final puede ir cambiando si presenta más de una
llamada, es decir varios User Exit.

Una vez que se tiene el nombre de la ampliación, en este ejemplo V45A0003, colocarlo en el
campo Ampliación de la transacción SMOD y presionar Visualizar.

155
2°) Presionando el botón Componentes (o habiendo seleccionado la opción Componentes de la
pantalla anterior), se visualizarán todos los módulos de funciones que contiene esta ampliación.

En este caso existen dos módulos de función. Cada uno va a ser ejecutado en algún momento
determinado de la ejecución del programa al cual pertenecen, en este caso SAPMV45A.

3°) Una vez que ya se sabe qué módulo de función usar se debe hacer doble clic sobre el mismo
y derivará a otra pantalla, en la cual se puede ver qué objetos importa y exporta esta función,
como así también las tablas que importa y que pueden modificarse, los cuales se utilizarán en el
código fuente.

En la solapa Cód.fte. se encuentra un Include Z que se utiliza para agregar el código del usuario.
Si este Include no existe al hacer doble clic sobre el mismo pedirá al usuario que le asigne una
orden de transporte para poder generarlo. Una vez creado es posible codificar utilizando todos
los objetos que figuren en la solapa de Import, Modific., y Tablas, pudiendo devolver resultados
modificando los objetos que se encuentran en las solapas Export, Modif. y Tablas.

156
4°) Una vez terminada la codificación, la ampliación debe activarse e incluirse en un proyecto.
Los proyectos son creados en la transacción CMOD. Allí se debe generar un proyecto Z en el
cual se incluirán las ampliaciones que se desee.

157
5°) En la sección Asignación Ampliación se colocan todas las ampliaciones que integrarán el
proyecto. Simplemente se completa cada línea con una ampliación.

6°) El último paso a seguir es activar el proyecto con todas sus ampliaciones. Para esto
se debe presionar el botón Componentes ir al menú Proyecto y seleccionar la opción
Activar.

158
Field Exit

Los Field Exit se utilizan para relacionar un campo de una dynpro de un determinado
programa con un código de programa o mejor dicho con una función. El nexo de unión
entre la función y el campo es a través del elemento de datos de dicho campo. Los Field
Exit generalmente se utilizan para validar los campos de una dynpro sin modificar el
código fuente del programa en el cual está funcionando. Su codificación se realiza
aparte. El Field Exit se codifica por elemento de datos y luego se asocia a un programa
y a una dynpro en particular. El código es ejecutado automáticamente al dar ENTER
sobre la dynpro que tiene el campo específico, al pasar de pantalla (o salir de la
pantalla) o en algunos casos al presionar el botón Grabar de la dynpo.

En la transacción SE37, biblioteca de funciones, y colocando field_exit_* y luego

pulsando F4 nos saldrán todos los Field Exit del sistema.

Una de las desventajas del Field Exit es que no se puede hacer un DEBUG al código, la
forma de hacerlo es ir colocando mensajes (MESSAGE) dentro del código para ir viendo por
donde pasa dentro del código y qué valores está manejando.

Ventajas

Facilita la validación de campos en un programa estándar sin modificar el código

original.

Puede utilizarse el mismo código para varias transacciones.

Se puede aplicar globalmente (para todos los programas) o para determinados

programas y dynpro que se le asignen.

Desventajas

Toma de la dynpro (Import) un solo valor, que es el del campo al cual hace
referencia, por lo que no se pueden utilizar tablas internas específicas del programa
estándar en el código del Field Exit.

El mismo código del Field Exit tiene que servir para todos los programas que se
quieran utilizar, por lo que se tiene que especificar en el código que acción tomará
de acuerdo al programa en el cual se esté ejecutando.

No es posible hacer un Debug del código del Field Exit de forma directa, a través de
un Breakpoint. Para esto se utilizan mensajes de error para ir viendo que valores va
tomando los diferentes objetos (variables, tablas, etc.) y por donde va pasando
dentro del código del Field Exit.

13

159
Pasos para realizar un Field Exit

1°) El primer paso para realizar un Field Exit es ir a la transacción CMOD (Gestión de
proyectos de ampliaciones SAP) y ejecutar la transacción PRFB dentro de la CMOD, sin
anteponer /N.

2°) En esta transacción se encuentran todos los Field Exits del sistema, pudiendo
ver también si están activados a nivel Global (para todas las transacciones) o tienen
algún programa y dynpro asignados.

3°) Para crear un nuevo Field Exit se debe ir al menú Exit campo y seleccionar la
opción Crear. Allí pedirá el elemento de datos al cual estará relacionado el Field
Exit. Este elemento de datos debe ser el mismo que tiene el campo de la dynpro al
cuál se quiere relacionar.

160
Este dato se obtiene presionando la tecla F1 sobre el campo de la dynpro y luego presionando el
botón Información técnica .

4°) Al colocar el elemento de datos y dar ENTER aparece la dynpro de biblioteca

de funciones (SE37) con la función FIELD_EXIT_CHARG_D, del elemento de
datos que se quiere crear.

161
Al presionar el botón Crear aparece una nueva pantalla en la cual se debe colocar un Grupo de
funciones y un Texto breve del Field Exit.

5°) Una vez creado va a aparecer en la pantalla de la transacción PRFB. Para poder
codificar seleccionar el check box correspondiente al elemento y presionar el botón
Tratar MF. Éste derivará a la transacción SE37 para poder modificar la función.

Este módulo de función tiene la particularidad de tener un parámetro de Import o entrada

y uno de Export o salida. El parámetro de entrada es INPUT y contendrá el valor del
campo al cual se ha asignado el Field Exit (recordar que un Field Exit se relaciona con
un elemento de datos y con un programa y dynpro).

El parámetro de salida OUTPUT es el valor que tomará el campo al salir del Field Exit.

Si en la función no se quiere modificar el campo donde esta colocado el Field Exit

entonces al principio de todo se debe escribir: OUTPUT = INPUT para devolver el
mismo valor que se ingresó.

Dentro del módulo de función sólo se pueden trabajar con estos parámetros, pero si se
quiere obtener valores de otros campos de la dynpro se puede utilizar otros Field Exits
en los cuales se utilizará el comando SET PARAMETER para poder grabar en memoria
al valor del campo y utilizarlo en el Field Exit anterior tomándolo de memoria con GET
PARAMETER.

Otra opción es utilizar la Función GET_DYNP_VALUE para obtener valores de otros

campos de la dynpro.

6°) Una vez terminada la codificación se debe asignar un programa y dynpro al Field Exit
(si no se quiere hacer Global – para todos los programas).

Para eso se debe ir a la pantalla de administración de Field Exit (CMOD - PRFB),

seleccionar el Field Exit y presionar el botón Asignar proa./dynpro.

162
Este esta pantalla se solicita el nombre del programa y la dynpro. Se pueden asignar
varios programas y dynpro al mismo Field Exit.

Otra de las desventajas del Field Exit, además del que se puede hacer un Debug es que
el mismo módulo de función debe servir para todos los programas, por lo que si debe
funcionar para varios programas se debe preguntar dentro del mismo código, en qué
programa o transacción se encuentra para actuar de una forma u otra.

7°) El último paso es activar el Field Exit, para esto se debe seleccionar el elemento de
datos correspondiente, ir al menú Exit campo y presionar la opción Activar.

163
Screen Exit
Un Screen Exit se utiliza para agregar nuevos elementos a una dynpro de un programa
estándar, ya sean campos, textos, botones, etc. Los Screen Exits son definidos en áreas
especiales llamadas Subscreens.

Al igual que los User Exits, no todas las dynpro estándares tienen subscreen para poder
introducir cambios. Los Screen Exits también se incluyen dentro de ampliaciones o
enhancements.

Ventajas

Permite agregar funcionalidad a un programa incluyendo nuevos elementos a una

dynpro estándar tales como textos, campos, botones, etc.

No altera la funcionalidad del programa estándar original.

Desventajas

No todos los programas estándares tienen Screen Exit como para realizar estas
mejoras.

El espacio que se destina para la subscreen nueva es limitado, por lo que no se pueden
agregar campos indiscriminadamente en la pantalla.

Pasos para realizar un Screen Exit

1°) Crear un proyecto en la transacción CMOD. A este proyecto Z se le agregará la

ampliación que contiene el Screen Exit. Para eso se debe entrar desde la CMOD con la
opción Asignación ampliaciones cliente o presionar el botón Asignación ampliación. Por
ejemplo la ampliación QQMA0001.

Si se hace doble clic sobre la ampliación se pasa a la pantalla que detalla los
componentes del mismo. En este caso existen dos User Exit y tres Screen Exit. En la
sección Ámbitos dynpros se ubican los Screen Exits, detallando el programa, dynpro y
área que llama al Screen Exit y el programa y dynpro que va a contener la subscreen
nueva.

164
2°) Una vez que se determina cuál es la dynpro a crear se ejecuta la transacción SE80 y
se completa el nombre del programa que va a tener la subscreen. Por ejemplo
SAPLXQQM.

165
Para crear la nueva dynpro hacer clic derecho sobre el objeto principal, en este caso XQQM
y seleccionar Crear / Dynpro. Allí pedirá el número de dynpro a crear. En este caso la 0100.
Se completa la descripción de la dynpro y en Tipo de dynpro se debe colocar Subscreen.

Luego se graba, colocando una orden de transporte y así aparecerá la nueva dynpro en
la lista de objetos del programa.

3°) Dentro de esta nueva dynpro se podrán colocar nuevos elementos que integrarán la
dynpro estándar que la llamará. La programación de la misma se realizará a través del
PAI y PBO de la dynpro subscreen y en algunos casos dentro de los módulos de función
(User Exit) que contiene la ampliación que incluye el Screen Exit en cuestión. En el
ejemplo serían EXIT_SAPMIWO0_008 y EXIT_SAPMIWO0_009.

4°) Una vez terminado, se debe activar el proyecto y sus componentes para que tome
efecto la llamada al Screen Exit junto con su lógica de procesamiento. Para esto se
debe ir a la transacción CMOD, presionar el botón Componentes para ver todos los
componentes que tiene el proyecto y elegir dentro del Menú Proyecto la opción Activar.

166
Menu Exit
La ampliación de tipo Menu Exit permite agregar una transacción dentro de un menú
estándar de SAP. Estas transacciones pueden estar vinculadas a algún determinado
programa pero serán ubicadas dentro del menú SAP, en una posición específica.

Ventajas
Poder agregar programas Z dentro de un menú estándar de SAP sin tener que estar
ubicándolo dentro del menú, a través de la transacción SE43, tan sólo con crear la
transacción y asignarle un programa.

Desventajas
No se puede cambiar el código de la transacción que vincula el Menu Exit. Son limitados
los Menu Exits disponibles por SAP y ya tienen asignados lugares específicos dentro del
menú.

Pasos para realizar un Menu Exit

1°) Crear un proyecto a través de la transacción CMOD. Poner un nombre y
presionar el botón Crear.

167
2°) Al entrar, ir a la pantalla de Asignación ampliación y completar con las
ampliaciones que se desean incluir. Por ejemplo CUST6, que contiene el Menu
Exit MENUS000 con el código de transacción +C06. Luego grabar.

3°) El paso siguiente es activar el proyecto, en la sección Componentes.

4°) Luego hay que crear la transacción específica para incluirla en el menú de
SAP. Esto se hace en la transacción SE93, en este ejemplo el código de la
transacción es +C06. Todas las transacciones utilizadas para Menu Exit empiezan
con +.

168
5°) Luego aparecerá una pantalla preguntando que tipo de transacción se desea
crear. Para este ejemplo se utilizará la opción Programa y dynpro (transacción de
diálogo).

6°) Allí se deberá completar con el nombre del programa y dynpro inicial que
tendrá la nueva transacción. Luego grabarla.

169
7°) Por último queda por cambiar la descripción de la transacción para que aparezca en
el menú con un nombre apropiado. En la transacción SE43 se debe completar el Menú
ámbito al cual pertenece el Menu Exit, que se determinará del nombre del componente
de la ampliación. En el ejemplo el componente se llama MENUS000. Por lo tanto el
Menú ámbito es S000.

170
8°) Allí hay que presionar el botón Modificar y en la pantalla siguiente Modif. A
continuación se debe buscar el nuevo Menú y presionar el botón Modificar nodo para
poder cambiarle la descripción del menú.

171
9°) Una vez terminado aparecerá en el menú de SAP.

172
Include en tablas transparentes

Los Include en tablas transparentes son otro de los tipos de ampliaciones utilizados en
SAP, en este caso para poder agregar nuevos campos a tablas transparentes
estándares, como también a tablas Z.

Como SAP no permite agregar campos a las tablas transparentes estándares, se ofrece
la solución de anexar una estructura Z a la tabla. Para ello se debe crear primero una
estructura Z con los campos deseados y luego se hace un Append a la tabla. Luego de
esto se puede grabar o consultar a los nuevos campos de la tabla transparente como
cualquier otro campo estándar.

Ventajas

Permite ampliar una tabla estándar agregando nuevos campos ante la necesidad del
negocio.

Desventajas

Es un poco tedioso borra campos del Include o borra totalmente el Include a la tabla, ya
que debe adaptarse la tabla a los cambios.

Pasos para realizar un Include a Tabla Transparente

1°) Abrir la tabla transparente a la cual se quiere agregar los campos adicionales. En
este caso la tabla MARA.

2°) Luego se debe presionar el botón Estr.append> para agregar una estructura nueva a
la tabla transparente. Esta estructura va a ser completada con los campos que se desee
y la tabla transparente va a tomar todos los campos de la estructura como propios.

173
Allí aparecerá una pantalla preguntando el nombre de la estructura que se desea crear,
en este caso ZAPPENDMARA.

3°) En la pantalla siguiente se completan los campos de la estructura con sus elementos
de datos, luego debe activarse. Solicitará una clase desarrollo y una orden de
transporte. Además debe activarse la tabla transparente.

Una vez activado aparecen los nuevos campos en la tabla transparente a la cual se le
agregó la estructura.

174
De esta manera también se pueden agregar campos a la estructura sin ninguna restricción,
incorporándolos a la vez a la tabla transparente a la cual se le agregó el Append.

5°) Si se desean quitar campos de la estructura, se deben borrar de la estructura, grabarla y

luego ir a la transacción SE14 para ajustar la tabla transparente a los cambios realizados.

En la transacción SE14 se completa el campo Objeto con el nombre de la tabla a la cual

se le agregó el Include y se presiona el botón Tratar.

175
En la pantalla principal de la SE14 se debe presionar el botón Activar y adaptar base de
datos. Una vez completado el proceso se debe activar la estructura.

En el caso de que se quisiera quitar por completo el Include con todos sus campos en la
transacción SE11, se debe completar el campo Tabla base de datos con el nombre de la
estructura y presionar el botón Borrar (Icono Tacho de basura). Allí aparecerá un
mensaje de advertencia diciendo que se borrará la estructura Append y que luego se
debe adaptar la tabla en la cual se hace referencia. Para continuar presionar el botón
Borrar.

176
 Por lo tanto después se debe ir a la transacción SE14 y adaptar la tabla
transparente (MARA) como se explicó anteriormente.

Enhancement-Point
Se puede insertar código en distintos puntos del programa estandar
 Donde se declaran las tablas.
 Dentro de cada estructura de las tablas internas para insertar nuevos campos.
 En modulos de funciones.
 Al principio y al final de cada FORM.

Con todo esto se puede ver que tenemos casi a nuestra disposición todo el código
de cualquier programa.

Para ello vamos a:

Tratar -> Operaciones ampliación -> Insertar puntos de ampliación implícitos

Una vez marcados todos los puntos de ampliación, solo tenemos que ponernos encima
de la línea deseada y seleccionamos:

Tratar -> Operaciones ampliación -> Crear

177
178
Transacciones relacionadas
SMOD – Ampliaciones SAP (User Exit, Screen Exit, Menu Exit, Include en
tablas transparentes)

CMOD – Gestión de proyectos de ampliaciones SAP (User Exit, Field Exit, Screen
Exit, Menu Exit, Include en Tablas transparentes)

PRFB – Field Exit para los elementos de datos (Field Exit)

SPRO – Customizing (BTE)

SE37 – Biblioteca de funciones (Field Exit, BTE)

SE93 – Actualizar transacción (Menu Exit)

SE43 – Actualizar menú de ámbito (Menu Exit)

SE14 – Diccionario ABAP – Utilidad para base de datos (Include en tablas

transparentes)

SE80 – Object Navigator (User Exit, Screen Exit, BTE, Menu Exit)

SE11 – Diccionario ABAP

179
 Capítulo 12 IDocs

Capítulo 12 - IDOCs
Introducción
El IDOC es un paquete (o contenedor)de información diseñado para intercambiar datos
entre distintos sistemas.

Puede ser utilizado entre:

Sistema SAP -> Sistema SAP
Sistema SAP -> Sistemas externos (salida)
Sistemas externos -> Sistema SAP (entrada)

Existen Idocs estándares para transportar datos de los objetos de negocio más comunes
en SAP como por ejemplo:

• ARTMAS02 (Maestro de materiales)

• CREMAS03 (Datos de proveedores)
• ADRMAS02 (Datos de direcciones)
• ORDERS05 (Ordenes de compra o venta)

Características / Estructura
Un IDOC está compuesto por 3 partes:

180
181
IDOCs – Transacción WE02/WE05
Permite ver la lista de IDOCs recibidos y enviados y editar segmentos con error.

Transacción BD87
Nos permite reprocesar un IDOC con error

182
Transacción WE19
Similar a BD87 pero a diferencia de esta genera un nuevo IDOC a partir de uno ya
creado. Permite editar los segmentos y enviar o recibirlo según sea de salida o entrada

183
Creación – Paso 1 (segment type)

Tx WE31: Son las estructuras que definen que campos va a contener cada tipo de
segmento de datos del IDOC.
En caso de crear segmentos nuevos, estos deben comenzar con Z.
Para definir los campos que componen el segmento se deben definir los elementos de
datos correspondientes, es importante tener en cuenta solo los siguientes tipos de datos
son admitidos en segmentos de idosc:

Ejemplo:

184
Creación – Paso 2 (Idoc Type)

Tx WE30 : El Idoc Type o Tipo Base define:

• Que segmentos contendrá el IDOC (de los definidos en el paso 1)
• El orden entre los segmentos
• La jerarquía entre los segmentos
• Las repeticiones
Se puede crear un tipo base o una extensión de un tipo ya creado (esto es cuando
necesitamos por ejemplo agregar información a enviar utilizando un idoc standard)

Ejemplo:

185
Creación – Paso 3 (Message Type )

Tx WE81 : El Message Type es el tipo de mensaje a transmitir, por ejemplo orders, que
después puede estar asociado a órdenes de compras ordenes de ventas, etc. Es un
elemento agrupador y lo único que requiere es un nombre y una descripción.
Ejemplo:

186
Creación – Paso 4 (Relación Message -IDOC )

Tx WE80 : Se debe crear la relación entre el Message Type y el Idoc Type, esta
asociación permite documentar el tipo de mensaje en que está basado el tipo de IDOC:

Ejemplo:

Creación – Paso 5 (Parthner Profile)

Tx WE20 : Es el acuerdo entre interlocutores, el que emite el mensaje y el que lo recibe.

El acuerdo especifica varias de las características de los datos que se intercambian
incluyendo el modo de operación y la organización o persona responsable por el manejo
de los errores.
Los datos definidos en un acuerdo de interlocutor son:

• Acuerdo de interlocutores a utilizar.

• Tipo de Idoc y Tipo de mensaje.
• Puerta por el cual el emisor y el receptor se comunicarán.

La información a completar en el acuerdo entre interlocutores varía según el IDOC sea

de entrada o de salida.

187
Creación – Pasos adicionales

En la mayoría de los casos los siguientes elementos ya están definidos en el sistema

por el equipo de basis, pero si fuese necesario podemos crear nosotros los necesarios
para completar la configuración del IDOC, estos elementos son:

• Logical system (Sistema lógico)

• Distribution Model
• Ports

Creación – Logical System

Tx BD54. Es una definición de cada sistema en sap, identifica a un ambiente y

mandante. En general el nombre está compuesto por systemIDCLNTclient number por
ejemplo IDSCLNT800.

188
Creación – Logical System

Cada sistema lógico luego se lo asigna a cada mandante de cada ambiente para poder
identificarlo en el momento de realizar la comunicación. Para ver que sistema lógico
tiene asociado un mandante podemos hacerlo en la transacción SCC4:

189
Creación – Modelo de Distribución

TX BD64. El Modelo de distribución contiene información sobre el flujo de los IDOCs,

define sistema lógico origen y destino y el tipo de mensajes que intercambian. Solo es
necesario cuando se utilizan idocs de tipo Master Data como ARTMAS por ejemplo.

190
 Creación – Ports

Tx. WE21. La puerta de entrada/salida define el medio por el cual se va a enviar o recibir
el IDOC, los tipos de puertas más comunes son:
 File: Deja el Idoc en un archivo
 RFC: Permite la comunicación mediante una función RFC
 XML: Al igual que file, genera un archivo con el contenido del idoc pero en este caso en
formato xml

IDocs – De salida
Existen tres formas de generar Idocs:
• Desde un programa ABAP (desarrollo Z).
• Desde un puntero de modificación (Change Pointer).
• Desde mensajes de logística.

IDOCs – De salida - Programa ABAP

Los pasos a seguir para crear un Idoc desde un programa ABAP son los siguientes:
• Seleccionar la información de la base de datos de acuerdo a los parámetros de
selección ingresados.
• Completar la información correspondiente al registro de control.
• Completar una tabla interna de tipo EDIDD con los registros de datos de los segmentos
correspondientes.
• Llamar al servicio de la capa ALE (MASTER_IDOC_DISTRIBUTE) para crear los
IDOCs en la base de datos.

191
Ejemplo – Registro de control:

ls_control-tabnam = 'EDI_DC40'.
ls_control-mandt = sy-mandt.
ls_control-docrel = sy-saprl.
ls_control-direct = '2'.
ls_control-idoctyp = 'ARTMAS01'.
ls_control-mestyp = 'ARTMAS'.
ls_control-stdmes = 'ARTMAS'.
ls_control-sndprn = 'PERFIL'. "Nº int remitente
ls_control-sndprt = 'US'. "Tp int remitente
ls_control-sndpor+0(3) = 'SAP'.
ls_control-sndpor+3(3) = sy-sysid.
ls_control-rcvprn = 'XX'. “Nº int receptor
ls_control-rcvprt = 'KU'. "Tp int receptor
* Tabla que contendrá los segmentos de datos
DATA:
gt_regdd TYPE TABLE OF edi_dd40.
gs_regdd TYPE edi_dd40.
* Estructura con los datos a enviar
DATA:
ls_mathead TYPE e1bpe1mathead.
* Completo los datos en la estructura
ls_mathead-function = '004'.
ls_mathead-material = mara-matnr.
ls_mathead-matl_type = mara-mtart.
ls_mathead-matl_group = mara-matkl.
ls_mathead-matl_cat = mara-attyp.
ls_mathead-logdc_view = 'X'.
ls_mathead-logst_view = 'X'.
ls_mathead-pos_view = ' '.
ls_mathead-ck_no_rnge = ' '.
ls_mathead-all_fields = ' '.
* Paso los datos al segmento de datos
gs_regdd-segnam = 'E1BPE1MATHEAD'.
gs_regdd-mandt = sy-mandt.
gs_regdd-sdata = ls_mathead.
* Agrego el segmento de datos a la tabla de segmentos
APPEND gs_regdd TO gt_regdd.
* Declaro la estructura para el otro segmento de datos
DATA ls_marcrt TYPE e1bpe1marcrt.
* Cargo los datos en la estructura
ls_marcrt-function = '004'.
ls_marcrt-material = lv_mat.
ls_marcrt-plant = lv_plant.
ls_marcrt-sup_source = lv_sup_src.
ls_marcrt-pur_status = lv_pur_st.
ls_marcrt-pvalidfrom = lv_pvalf.
* Paso los datos al segmento de datos

192
gs_regdd-segnam = 'E1BPE1MARCRT'.
gs_regdd-mandt = sy-mandt.
gs_regdd-sdata = ls_marcrt.
* Agrego el segmento de datos a la tabla de segmentos
APPEND gs_regdd TO gt_regdd.
* Declaro la estructura para el segmento con las marcas
DATA ls_marcrtx TYPE e1bpe1marcrtx.
* Cargo los datos en la estructura
ls_marcrtx-function = '004'.
ls_marcrtx-material = lv_mat.
ls_marcrtx-plant = lv_plant.
ls_marcrtx-sup_source = ‘X’.
ls_marcrtx-pur_status = ‘X’.
ls_marcrtx-pvalidfrom = ‘X’.
* Paso los datos al segmento de datos
gs_regdd-segnam = 'E1BPE1MARCRT'.
gs_regdd-mandt = sy-mandt.
gs_regdd-sdata = ls_marcrtx.
* Agrego el segmento de datos a la tabla de segmentos
APPEND gs_regdd TO gt_regdd.

IDOCs – De salida – Punteros

Toda vez que se crean o modifican datos maestros, tal como materiales, proveedores,
etc., el sistema escribe “punteros de modificación” (change pointers) como registro de
cada una de estas modificaciones para cada documento.

Pasos para la generación de IDOCs utilizando los punteros de salida:

• Activar los punteros de modificación en forma global: BD61
• Activar los punteros de modificación para nuestro tipo de mensaje:
BD50
• Definir los campos relevantes para la generación de punteros de
modificación. BD52

193
• Relacionar el tipo de mensaje con el módulo de función. BD60
• Programar un job con el report RBDMIDOC para crear los Idocs.
• Se puede usar el concepto de Mensajes R/3 para disparar la creación de Idocs de la
misma manera que se dispara la impresión de formularios.

• La tabla utilizada para esto es la NAST. Esta tabla guarda recordatorios escritos por
aplicaciones. Estos recordatorios son llamados Mensajes.

• Se debe parametrizar el nuevo mensaje en la tx NACE

• El mensaje es procesado por el programa ABAP estándar RSNAST00, el cual lee el
mensaje desde la tabla NAST, y llama al módulo de función adecuado para crear el
Idoc, invocando a la función MASTERIDOC_DISTRIBUTE.

Ejemplo tx NACE:

194
195
196
Ejemplo acuerdo Interlocutores p/mensaje:

197
Ejercicio 14: Creacion de un IDoc
Crear un Nuevo idoc a partir de uno existente y generarlo como archivo plano en un
directorio del servidor.
1) Utilizar la tx we02 para buscar un idoc existente y tomar nota del número.
2) Ir a la tx we19 y colocar el nro de idoc identificado
3) Verificar en la tx we21 los puertos de tipo file. Si no existe uno acorde a las
necesidades, crearlo.
4) Volver a la tx we19 y cambiar el segmento de control para colocar en el destinatario el
Puerto identificado en el paso anterior. Crear un Nuevo idoc a partir de uno existente y
generarlo como archivo plano en un directorio del servidor.
1) Utilizar la tx we02 para buscar un idoc existente y tomar nota del número.
2) Ir a la tx we19 y colocar el nro de idoc identificado
3) Verificar en la tx we21 los puertos de tipo file. Si no existe uno acorde a las
necesidades, crearlo.
4) Volver a la tx we19 y cambiar el segmento de control para colocar en el destinatario el
Puerto identificado en el paso anterior

198