Você está na página 1de 80

Introducción ABAP IV

ABAP IV para funcionales

Fecha : 03-09-2008 Versión : V1.0

20/06/2013 1 de 80
ABAP IV para funcionales.doc

FICHA DEL CURSO

Nombre del formador: Maria Plaza


Fecha del curso: 03/10/2008
Material adjunto: z_user_trans.txt
z_user_report.txt
Ejercicios_ABAP IV para funcionales

CONTROL VERSIONES

Fecha Versión Comentarios

LISTA DE DISTRIBUCIÓN

Departamento Nombre Cargo

20/06/2013 2 de 80
ABAP IV para funcionales.doc

CONTENIDOS

1 ALCANCE Y OBJETIVOS ......................................................................................................................5

1.1 ALCANCE ..........................................................................................................................................5


1.2 OBJETIVOS........................................................................................................................................5

2 INTRODUCCIÓN ABAP IV.....................................................................................................................6

2.1 QUE ES ABAP IV ..............................................................................................................................6


2.2 ARQUITECTURA EN TRES CAPAS .........................................................................................................6
2.3 ESTRUCTURA DE PROGRAMAS ABAP .................................................................................................7
2.3.1 Report ...................................................................................................................................7
2.3.2 Funciones .............................................................................................................................7
2.3.3 Dynpros .................................................................................................................................9

3 PROGRAMACIÓN ABAP IV.................................................................................................................10

3.1 INSTRUCCIONES BÁSICAS DE PROGRAMACIÓN ...................................................................................10


3.1.1 Asignación de valores .........................................................................................................10
3.1.2 Asignación de estructuras y tablas internas .......................................................................10
3.1.3 Borrado de variables ...........................................................................................................11
3.1.4 Cálculo aritmético ...............................................................................................................11
3.1.5 Condiciones ........................................................................................................................12
3.1.6 Proceso de bucles ..............................................................................................................13
3.2 DECLARACIÓN DE DATOS .................................................................................................................14
3.3 TABLA INTERNA ...............................................................................................................................15
3.3.1 Declaración tablas internas ................................................................................................15
3.3.2 Modificación tabla interna ...................................................................................................16
3.3.3 Instrucciones básicas para tablas internas .........................................................................17

4 DICCIONARIO ABAP ...........................................................................................................................18

4.1 TABLA BASE DE DATOS.....................................................................................................................18


4.1.1 Crear tabla Z .......................................................................................................................19
4.1.1.1 Elemento de datos...............................................................................................20
4.1.1.2 Dominio ...............................................................................................................21
4.1.2 Crear vista de actualización ................................................................................................21
4.1.3 Ampliación de tabla de base de datos ................................................................................22
4.2 INSTRUCCIONES SQL DE ABAP/4 ....................................................................................................22
4.2.1 Select ..................................................................................................................................23
4.2.2 Insert ...................................................................................................................................24
4.2.3 Update ................................................................................................................................24
4.2.4 Modify .................................................................................................................................24
4.2.5 Delete ..................................................................................................................................25

5 DEBUGGING ........................................................................................................................................26

5.1 DEBUGGING CLÁSICO.......................................................................................................................26


5.1.1 Activar / Desactivar debbug ................................................................................................26
5.1.2 Variables de sistema ..........................................................................................................28

20/06/2013 3 de 80
ABAP IV para funcionales.doc

5.1.3 Breakpoint ...........................................................................................................................28


5.1.4 Watchpoint ..........................................................................................................................32
5.1.5 Visualizar pila de llamadas .................................................................................................37
5.2 DEBUGGING SAPSCRIPT ...............................................................................................................37

6 AMPLIACIONES DE ESTÁNDAR ........................................................................................................40

6.1 FUNCTION EXIT ...............................................................................................................................40


6.1.1 Buscar function exit.............................................................................................................40
6.1.2 Activar function exti .............................................................................................................41
6.2 USER EXIT ......................................................................................................................................44
6.2.1 Buscar user-exit ..................................................................................................................45
6.3 RUTINAS .........................................................................................................................................45
6.3.1 Crear rutinas .......................................................................................................................46
6.4 BADI’S ...........................................................................................................................................49
6.4.1 Buscar BADI’s .....................................................................................................................49
6.4.2 Implementar una BADI .......................................................................................................54
6.5 BTE’S.............................................................................................................................................56
6.5.1 Buscar BTE’s ......................................................................................................................57
6.5.2 Activar BTE’s ......................................................................................................................58
6.6 PREGUNTAS FRECUENTES SOBRE AMPLIACIONES DE ESTÁNDAR ........................................................61

7 ANÁLISIS DE ERRORES .....................................................................................................................62

7.1 DUMPS ...........................................................................................................................................62


7.1.1 Interpretación de dumps .....................................................................................................62
7.2 ERROR DE ACTUALIZACIÓN...............................................................................................................63

8 VARIOS ................................................................................................................................................65

8.1 MENSAJES DE ERROR ......................................................................................................................65


8.1.1 Búsqueda de mensajes de error.........................................................................................65
8.1.2 Creación de clase de mensaje ...........................................................................................67
8.2 CREAR TRANSACCIONES ..................................................................................................................68

ANEXO I – TRANSACCIONES MÁS USADAS ...........................................................................................71

ANEXO II – PROGRAMA DE BÚSQUEDA FUNCTION-EXIT.....................................................................72

ANEXO III – PROGRAMA DE BÚSQUEDA USER-EXIT ............................................................................74

20/06/2013 4 de 80
ABAP IV para funcionales.doc
1. Alcance y objetivos

1 Alcance y objetivos

1.1 Alcance
El curso “ABAP IV para funcionales” trata de asentar unas mínimas bases de programación y a
la vez proporcionar una serie de herramientas que ayuden al consultor a poder realizar
pequeñas tareas de análisis técnico. En concreto se pretende que el consultor pueda detectar
fallos, debugar fragmentos de código y analizar las ampliaciones de estándar necesarias para
cubrir los requerimientos exigidos por el cliente.

1.2 Objetivos
Al finalizar el curso se pretende:
 Haber asentado las bases de programación necesarias para un consultor funcional.

 Poder debugar programas tanto estandar como no, entendiendo la ejecución que se está
realizando.

 Aprender a detectar las ampliaciones de estándar e incluso implementar aquellas que


sean sencillas.

 Intentar familiarizar al consultor funcional con el lenguaje técnico básico para facilitar la
comunicación entre programadores y consultores funcionales.

 NO se pretende que el consultor aprenda a programar con este curso, se pretende que el
consultor pueda detectar fallos y analizar las razones de estos.

20/06/2013 5 de 80
ABAP IV para funcionales.doc
2. Introducción ABAP IV

2 Introducción ABAP IV

2.1 Que es ABAP IV


ABAP (Advanced Business Application Programming) es un lenguaje de cuarta generación
orientado tal como su definición especifica, al desarrollo de aplicaciones de negocio. Todos los
módulos disponibles en SAP han sido programados en este lenguaje de programación. Además
es un lenguaje que permite escribir nuevas aplicaciones como complemento a las ya existentes
o como apoyo a la configuración del sistema.

Es un lenguaje orientado a eventos, es decir la secuencia de la ejecución va marcada por los


eventos y no por orden secuencial.

2.2 Arquitectura en tres capas


El sistema SAP R/3 se basa en una arquitectura cliente/servidor. La idea fundamental de la
filosofía cliente/servidor es la distribución de las tareas que debe realizar el sistema. Cada una
de las capas es la encargada de proporcionar unos servicios en concreto.

 Capa de presentación: la capa de presentación está prácticamente formada por el


SAPgui. Los usuarios del sistema introducen los datos y las peticiones a través de esta
capa.

 Capa empresarial / aplicación: es la capa encargada de recibir las peticiones de la capa


de presentación, tratar la información y lanzar las peticiones de a la capa de base de
datos en las consultas. También la encargada de recibir los datos de la base de datos y
enviarlos de nuevo a la capa de presentación. Es donde se ejecutan los programas en
ABAP IV.

20/06/2013 6 de 80
ABAP IV para funcionales.doc
2. Introducción ABAP IV

 Capa de datos: se encarga de acceder a la BD física a través de llamadas SQL. Se


comunica tan solo con la capa empresarial.

Resumiendo: el usuario hace una petición a través del SAPgui que automáticamente se procesa
en la capa de aplicación. Esta capa, posiblemente necesitará acceder a la base de datos, para
ello, lanzará una petición a la capa de datos. La capa de datos convertirá el código ABAP IV en
código SQL nativo y leerá los datos devolviéndolos a la capa de aplicación. La capa de
aplicación recibe los datos, los termina de tratar y finalmente devuelve la información a la capa
de presentación.

La capa de presentación y la de base de datos nunca estarán en contacto directo.

ATENCIÓN: cuando se habla de tres capas NO se habla de los tres entornos de implantación de
un sistema típicos (Desarrollo, Integración y Producción), sino del tipo de arquitectura del
sistema SAP.

2.3 Estructura de programas ABAP

2.3.1 Report
A grandes rasgos un programa escrito en ABAP tiene las siguientes partes:

REPORT <nombre>  Nombre del programa


TABLES:  Definición de las tablas tanto internas como de
diccionario
DATA:  Definición de variables internas
EVENTOS:  Etiquetas que indican una sección de código. La
sección de código asociado con un evento, empieza
con un nombre de evento y termina cuando el
siguiente evento es llamado.
CÓDIGO  Ejecución de instrucciones en general dentro del
programa.
SUBRUTINAS  Sección de código que puede ser usada varias
veces. Son mini-programas que pueden ser
llamados desde otros programas.

El report es el programa básico de SAP. La mayoría de transacciones ejecutan un report.

2.3.2 Funciones
Los módulos de funciones son objetos que realizan operaciones que pueden ser utilizadas en
varios programas. Al crear un módulo de función con el código que realiza una operación, se
evita tener que repetirlo en todos los programas que realicen esa operación añadiendo en ellos
una llamada a la función que se haya creado.

Los módulos de funciones o simplemente, funciones, se agrupan en grupos de funciones.

20/06/2013 7 de 80
ABAP IV para funcionales.doc
2. Introducción ABAP IV

Módulo función 1 (Transacción se37)

Módulo función 2
Grupo funciones
(Transacción se80) Módulo función 3

Módulo función 4

Tanto los grupos de funciones no estándar como los módulos de función no estándar, deben
empezar por Z.

Un módulo de funciones recibe una serie de parámetros de entrada, otros de salida y tablas
internas de entrada y salida.

Parámetros entrada Parámetros salida


(import) Módulo (export)
funciones
Tabla interna Tabla interna
(tables) (tables)
Parámetros entrada/salida Parámetros entrada/salida
(modif) (modif)

Parámetro de entrada: un parámetro de entrada es un parámetro que dentro de la función no se


puede modificar (aunque se modifique dentro de la función, cuando acaba la función y sigue el
flujo del programa, esta tendrá el mismo valor que tenía antes de entrar a la función).

Parámetro de salida: un parámetro de salida es un parámetro que utilizará la función para


devolver los resultados esperados. El valor que entra a la función se pierde dentro y debería
entrar sin valor. Los parámetros de salida se deben declarar como parámetros de “Export”.

Parámetros de entrada / salida: un parámetro de e/s es un parámetro que debería tener valor al
entrar a la función y se modificará durante la ejecución. Se deben declarar como parámetros de
“Modificación”.

Tablas internas: las tablas internas se comportan como los parámetros de entrada / salida. Se
deben declarar como “Tablas”.

Excepciones: en caso de que se produzca algún error durante la ejecución de la función, se


lanzará una excepción. Es MUY IMPORTANTE que todas las excepciones de todas las
funciones que se utilizan en los programas estén descomentadas, en caso contrario, si sucede
un error, la ejecución del programa se parará provocando un dump.

20/06/2013 8 de 80
ABAP IV para funcionales.doc
2. Introducción ABAP IV

2.3.3 Dynpros

Una dynpro no es más que una pantalla con toda la lógica que le acompaña (dynamic
programming).

Una dynpro está formada por el proceso de diseño de la pantalla y carga de datos, la muestra de
la pantalla y la recepción de los eventos y tratamiento de los datos. Una vez se han tratado los
datos y el evento, se debe volver a cargar la pantalla, por tanto volverá al primer punto.

PBO (Process Before Output)

Muestra de la pantalla

PAI (Procees After Input)

En ABAP este dibujo se representa de la siguiente manera:

La pantalla de la dynpro 4001, se carga con los procesos declarados en el Process Before
Output, en este caso seria el MODULE STATUS_4001 y se tratan los datos en el Process Alter
Input, en el MODULE USER_COMMAND_4001.

En una dynpro no se puede llamar a una rutina ni a una función, tan solo se pueden llamar a
MODULE’s que son igual que subrutinas. Dentro de esa subrutina ya se puede utilizar cualquier
tipo de llamada y de declaración.

20/06/2013 9 de 80
ABAP IV para funcionales.doc
3. Programación ABAP IV

3 Programación ABAP IV

3.1 Instrucciones básicas de programación


Existen diferentes instrucciones de programación que son necesarias en todos los lenguajes.
Aunque la forma de escribir la instrucción sea diferente, la finalidad siempre es la misma. Por
tanto, es importante conocer estas instrucciones y entenderlas de manera ágil. Existen muchas
más de las que se presentan en este manual, pero son mucho menos usadas.

3.1.1 Asignación de valores


Para asignar un valor a una variable o asignar una variable a otra variable se debe utilizar una de
las dos sentencias:

 MOVE <origen> TO <destino> // MOVE <f1> TO <f2>


o
 <destino> = <origen> // <f2> = <f1>

Existen asignaciones múltiples:

 <destino final // f4> = <f3> = <f2> = <f1>


o
 MOVE <f1> TO <f2>
MOVE <f2> TO <f3>
MOVE <f3> TO <f4>

En la asignación de valores pueden darse tres casos:

 El objeto <f1> y <f2> son totalmente compatibles. Tienen el mismo tipo de datos, misma
longitud, y el número de decimales es exactamente el mismo. No existirá ningún
problema en la ejecución.

 El objeto <f1> y <f2> son incompatibles. Quizás exista el sistema de SAP sea capaz de
adaptar los objetos pero la asignación no tiene porque ser correcta. Puede ser debido a
diferentes tipos de datos y a diferentes longitudes. Ej. La variable de origen tiene el valor
“incompatible”, y la variable de destino es de tipo carácter pero de longitud 2. El valor de
f2 después de la asignación será “in”. No dará un error de compilación, ni un dump en el
momento de la ejecución pero el valor de la variable puede que no sea el correcto.

 El objeto <f1> y <f2> son totalmente incompatibles. O bien por el tipo de datos o bien por
la longitud. Normalmente al activarse el programa, aparecerá un error de sintaxis, pero
existe algunos casos en que el compilador no detecta este fallo y será en tiempo de
ejecución cuando aparezca un dump por elemento de datos incompatibles

3.1.2 Asignación de estructuras y tablas internas


Siempre y cuando las dos estructuras sean exactamente iguales, es podrá utilizar la sentencia:
 <struct2> = <struct1>

20/06/2013 10 de 80
ABAP IV para funcionales.doc
3. Programación ABAP IV

En el resto de casos, se debe utilizar la siguiente:

 MOVE-CORRESPONDING <struct1> TO <struct2>.

La asignación se realizará campo entre las diferentes estructuras pero de manera transparante
para el programador.

Ejemplo:

DATA: BEGIN OF wa_cliente_origen,


kunnr LIKE kna1-kunnr VALUE “12345”,
name1 LIKE kna1-name1 VALUE “Caixa”,
telfx LIKE kna1-telfx VALUE “0034932334456”,
ort01 LIKE kna1-ort01 VALUE “Barcelona”,
land1 LIKE kna1-land1 VALUE “ES”,
END OF wa_cliente

DATA: BEGIN OF wa_cliente_destino,


kunnr LIKE kna1-kunr,
land1 LIKE kna1-land1,
telfx LIKE kna1-telfx,
ciudad LIKE kna1-ort01,
END OF wa_cliente

MOVE-CORRESPONDING wa_cliente_origen TO wa_cliente_destino

El resultado del siguiente ejemplo es el siguiente:


wa_cliente_destino-kunnr = ‘12345’
wa_cliente_destino-land1 = ‘ES’
wa_cliente_destino-telfx = ‘0034932334456’
wa_cliente_destino-ciudad = ‘’  aunque el elemento de datos sea el mismo que el
wa_cliente_origen-land1, el nombre de la variable es diferente y por tanto no
se realizará la asignación.

3.1.3 Borrado de variables


Según el tipo de variables se deberá resetear el valor de una manera u otra:
 CLEAR para variables, estructuras y cabeceras de tabla interna.
CLEAR <f1>.
CLEAR <estruct1>.
CLEAR <int_tabla1>.  SOLO se elimina la cabecera

 REFRESH para eliminar el contenido de las tablas internas.


REFRESH <int_tabla1>  Se elimina el contenido, NO la cabecera

3.1.4 Cálculo aritmético


Para realizar operaciones aritméticas básicas se debe utilizar la siguiente nomenclatura:

20/06/2013 11 de 80
ABAP IV para funcionales.doc
3. Programación ABAP IV

Operación Inst. matemática Ins. textual


Suma <p> = <n> + <m>. ADD <n> TO <m>.  <m> = <m> + <n>.
Resta <p> = <m> - <n>. SUBTRACT <n> FROM <m>. 
<m> = <m> - <n>.
Multiplicación <p> = <m> * <n>. MULTIPLY <m> BY <n>. 
<m> = <m> * <n>.
División <p> = <m> / <n>. DIVIDE <m> BY <n>. 
<m> = <m> / <n>.
División de Enteros <p> = <m> DIV <n>. --
Resto de la división <p> = <m> MOD <n>. --
Exponentes <p> = <m> ** <n>. --

Igual que a la hora de asignar el valor de una estructura, teníamos la instrucción MOVE-
CORRESPONDING, existen las siguientes instrucciones aritméticas para estructuras
 ADD-CORRESPONDING <struct1> TO <struct2>.
 SUBTRACT-CORRESPONDING <strct2> FROM <struct1>.
 MULTIPLY-CORRESPONDING <struct2> BY <struct1>.
 DIVIDE-CORRESPONDING <struct2> BY <struct1>.

3.1.5 Condiciones
En los programas estructurados se necesitan instrucciones para subdividir el programa en varios
bloques que se irán ejecutando según cuando se cumpla uno u otra condición.

Para introducir las condiciones se utiliza la sentencia IF … ELSE…. ENDIF que puede aparecer
de las siguientes maneras:

- IF <cond>.  Si se cumple condición se ejecuta el código sino no.




ENDIF.

- IF <cond>.  Si se cumple la condición se ejecuta el código1, sino el código2


Código1
ELSE.
Código2
ENDIF.

- IF <cond1>.  Si se cumple la condición1 se ejecuta el código 1, sino se


Código1 se cumple valida la condición2. Si esta se cumple, se
ELSEIF <cond2>. Se ejecuta el código 2, sino, sigue con la siguiente.
Código2
ELSEIF <cond3>.
Código3
ELSE.
Código4
ENDIF.

20/06/2013 12 de 80
ABAP IV para funcionales.doc
3. Programación ABAP IV

Los operadores condicionales que se pueden utilizar en este tipo de condiciones son los
siguientes:

Operador Significado Ejemplo


=, EQ Igual IF a = 1 // IF a EQ 1.  se cumple la condición si el valor de “a” es 1
<>, NEQ Distinto IF a <> 1. // IF a NEQ 1  se cumple la condición si el valor de “a” es
diferente de 1.
>, GT Mayor IF a > 1. // IF a GT 1  se cumple la condición si el valor de “a” es
mayor a 1.
<, LT Menor IF a < 1. // IF a LT 1  se cumple la condición si el valor de “a” es
menor a 1.
>=, GE Mayor o IF a >= 1. // IF a GE 1  se cumple la condición si el valor de “a” es
igual mayor o igual a 1
<=, LE Menor o IF a <= 1. // IF a LE 1  se cumple la condición si el valor de “a” es
igual menor o igual a 1
AND Y IF a = 1 AND b = 2  se cumple la condición si a = 1 y b = 2
OR O IF a = 1 OR b = 2  se cumple la condición si a = 1 o b = 2.
CO Contains IF <f1> CO <f2>  se cumple la condición si f1 sólo contiene
Only caracteres de f2
CN Contains IF <f1> CN <f2>  se cumple la condición si f1 no sólo contiene
Not Only caracteres de f2.
CA Contains IF <f1> CA <f2>  se cumple la condición si f1 contiene algún
Any carácter de f2.
NA Contains IF <f1> NA <f2>  se cumple la condición si f1 no contiene ningún
Not Any carácter de f2.
CS Contains IF <f1> CS <f2>  se cumple la condición si f1 contiene exactamente
String el string f2. Es decir no solo tiene que tener los mismos caracteres
sino en el mismo orden
NS Contains IF <f1> NS <f2>  se cumple la condición si f1 contiene exactamente
No String el string f2.

Si se desea ejecutar diferentes instrucciones según el valor de una variable en concreto se


puede utilizar la sentencia CASE … ENDCASE.
- CASE <variable>.
WHEN <valor1>.
Código1.
WHEN <valor2>.
Código2.
WHEN <valor3>.
….
WHEN OTHERS.
ENDCASE.

3.1.6 Proceso de bucles


Para realizar procesos repetitivos se utilizan las sentencias DO y WHILE.

- La instrucción DO … ENDDO permie ejecutar un bloque de instrucciones tantas veces


como se especifique.

20/06/2013 13 de 80
ABAP IV para funcionales.doc
3. Programación ABAP IV

DO <n> TIMES.
….
….
ENDDO.

Dentro del bucle, en la variable sy-index se mostrará el número de repeticiones.


Se pueden anidar DO’s y el valor del sy-index será del bucle más interno. La forma de un
bucle anidado sería el siguiente.
DO <n> TIMES.
….
DO <n> TIMES.
….
ENDDO.
….
ENDDO.

- La instrucción WHILE permite ejecutar un bloque de instrucciones mientras se cumpla


una condición.
WHILE <cond>.

ENDWHILE.

Existen unas sentencias de control que se utilizan para terminar bucles en procesos.
- CHECK <cond>: realiza un chequeo de la condición de forma que si dentro del bucle la
condición del check es falsa, el bucle se saltará todas las instrucciones que siguen al
check y se iniciará la siguiente iteración.

- EXIT. Dentro de un bucle, si se ejecuta la sentencia EXIT se detendrá la ejecución de la


iteración y saldrá del bucle.

- CONTINUE. Dentro de un bucle, si se ejecuta la sentencia CONTINUE, se detendrá la


ejecución de la iteración y continuará con la siguiente iteración del bucle.

3.2 Declaración de datos


Las variables de un programa se deben declarar antes de poder utilizarlas. Declarar una variable
significa indicar el tipo y la longitud de la variable. Existen diferentes tipos de variables y cada
uno de estos tipos se declara de maneras diferentes.

 Variables simples:
DATA v1 [TYPE t] [DECIMALS d] [VALUE ‘xxx’]
o
DATA v1 LIKE v2 [VALUE ‘xxx’]

v1 es el nombre de la variable
v2 es el nombre de la variable previamente definida en el programa o es el nombre de un
campo que pertenece a una tabla o a una estructura en el Diccionario de Datos.
t es el tipo del dato. Los tipos de datos simples más utilizados son:
C  Texto
F  Punto flotante
I  Entero

20/06/2013 14 de 80
ABAP IV para funcionales.doc
3. Programación ABAP IV

N  Texto numérico
P  Número empaquetado
X  Hexadecimal
D  Fecha YYYYMMDD
T  Hora HHMMSS

d es el número de dígitos después del punto decimal (máximo 14 y únicamente usado


con un dato de tipo p).
‘xxx’ valor inicial de la variable

 Registro de datos: un registro de datos es un conjunto de variables que están


relacionadas ya que se desea que se comporten como un grupo.

DATA: BEGIN OF proveedor,


lifnr LIKE lfa1-lifnr,
name1 LIKE lfa1-name1,
ciudad(20),
END OF proveedor.

Para acceder al nombre del proveedor  proveedor-name1.

 Constantes: una constante se define igual que una variable únicamente cambiando la
palabra DATA por la sentencia CONSTANTS.
CONSTANTS: c_constante [(longitud)] [tipo t] [decimals d] [valor ‘xxx’]

3.3 Tabla interna


Las tablas internas son estructuras fijas donde se almacenan datos de la base de datos en la
memoria ABAP. Se almacenan los datos con la misma estructura que tiene en la base de datos
física línea a línea.

El acceso a una base de datos siempre es muy lento, por ello, se utilizan tablas internas de
manera que con un solo acceso a la BD física, se carguen gran parte de los datos que se deben
utilizar posteriormente.

Las tablas internas pueden crearse con cabecera o sin ella. La cabecera de una tabla es una
línea de la tabla (se mostrará la primera), que sirve para poder realizar las lecturas y
modificaciones de la tabla interna.

3.3.1 Declaración tablas internas


Las tablas internas se pueden declarar de varias maneras, a continuación se mostrarán las más
frecuentes:

 Tabla interna con la misma estructura que una tabla de diccionario:

DATA: <internal_table> LIKE <dictionary table> occurs 0 ( with header line )


DATA: <internal_table> TYPE TABLE <dictionary table> occurs 0 (with header line)

20/06/2013 15 de 80
ABAP IV para funcionales.doc
3. Programación ABAP IV

La tabla interna tendrá exactamente la misma estructura que la tabla de


diccionario. Si se añade “with header line” se estará creando la tabla interna con
cabecera para poder trabajar con ella directamente.

 Tabla interna con variedad de campos:


DATA: BEGIN OF <internal_table> occurs 0,
<nom_campo> LIKE <dictionary table field>,

END OF <internal_table>.

3.3.2 Modificación tabla interna


En una tabla interna se pueden añadir registros, modificar registros y eliminarlos. Para cada una
de estas acciones existe una instrucción diferente.

Añadir registros:
 APPEND: añade un registro en la tabla interna. Si la tabla interna tiene cabecera se
añadirá la cabecera y en caso que no tenga se deberá añadir un área de trabajo
(estructura de un registro del mismo formato que la tabla interna). También es posible
añadir una tabla interna en otra siempre y cuando sean del mismo formato.

APPEND <internal_table>  se añade la cabecera de la <internal_table>


APPEND <line> TO <internal_table>  se añade una línea con el mismo formato de la
tabla interna definido anteriormente.

 COLLECT: añade o suma la línea de cabecera. Sumará los campos de tipos numéricos,
si existe una línea en la tabla interna con los campos de tipo CHAR idénticos a los que
se intentan insertar. Si no coinciden todos los campos de tipo C, se añadirá una nueva
línea.
COLLECT <internal_table>  se añade o suma la cabecera de la tabla

Modificar registros:
 MODIFY: si desea modificar un registro de la tabla interna, primero debe dejar este
registro en la cabecera, modificar los campos que se desee y posteriormente ejecutar la
instrucción MODIFY.
MODIFY <internal_table> INDEX <index>  se modifica la línea “index” con el valor de
la cabecera de la tabla interna.

Eliminar registros:
 DELETE: para eliminar una entrada de la tabla interna, debe utilizar la sentencia
“delete”.
DELETE <internal_table> INDEX <index>  se eliminará la línea “index”.

 CLEAR: elimina el valor de la cabecera de la tabla interna.


CLEAR <internal_table>  se eliminará la cabecera de la tabla interna
 REFRESH: inicializa (borra) el contenido de toda la tabla interna pero NO el de la
cabecera.
REFRESH <internal_table>  se eliminarán todas las entradas de la tabla

20/06/2013 16 de 80
ABAP IV para funcionales.doc
3. Programación ABAP IV

3.3.3 Instrucciones básicas para tablas internas


Para trabajar con tablas internas existen varias sentencias que se deben conocer:

 Ordenar tabla interna: si se desea ordenar una tabla interna se debe utilizar la sentencia
SORT. Si no se indica lo contrario, la ordenación se realiza de forma ascendente.
SORT <internal_table> ( ASCENDING o DESCENDING )

Si se desea ordernar según unos campos en concreto deberá utilizar la instrucción de


la siguiente manera:
SORT <internal_table> BY <campo1> <campo2> … .

 Procesamiento tabla interna: para recorrer las entradas de una tabla interna se utilizará
la sentencia LOOP.
LOOP AT <internal_table> (WHERE <cond>)
…..
ENDLOOP.

Si se desea recorrer todas las entradas de la tabla interna no se deberá intrducir


ninguna restricción, en cambio si se desean recorrer solo las entradas que cumplan
alguna característica se utilizará la cláusula “where”.

En el procesamiento de la tabla interna son muy importantes dos variables de sistema:


sy-subrc: si NO se realiza ninguna iteración ya sea porque la tabla está vacía o
porque ninguna entrada cumple la condición especificada en el
WHERE, el valor será diferente de 0.
sy-tabix: dentro del loop, la variable sy-tabix contiene el índice de la entrada que
está procesándose en ese momento.

 Lectura de entradas en tabla: si se desea leer una entrada de una tabla interna en
concreto no se deberá utilizar la sentencia LOOP, ni la sentencia SELECT (sólo se
puede utilizar para diccionario de datos, es decir accesos a base de datos), sino que se
debe utilizar la sentencia READ TABLE.
READ TABLE <internal_table>.

Si sabe en que posición se encuentra la entrada que quiere leer, utilice la sentencia de
la siguiente manera:
READ TABLE <internal_table> INDEX <num>.

Por el contrario, si quiere el primer registro que cumpla una condición, utilice la
sentencia así:
READ TABLE <internal_table> WITH KEY <clave>.

La variable de sistema sy-subrc será muy útil para este tipo de lecturas.
Si sy-subrc = 0, la búsqueda ha sido positiva
Si sy-subrc <> 0, no se ha encontrado ningún registro

20/06/2013 17 de 80
ABAP IV para funcionales.doc
4. Diccionario ABAP

4 Diccionario ABAP
El diccionario ABAP centraliza y gestiona todas las definiciones de datos utilizadas en el sistema.

Los tipos de objetos más importantes del diccionario de datos ABAP son:
 Tablas
 Vistas
 Tipos (elementos de datos, estructuras)
 Dominios
 Ayuda de búsqueda
 Objetos de bloqueo

No todos los objetos serán tratados en este curso, por tanto, si desea más información, acceda a
la url de SAP:
http://help.sap.com/saphelp_47x200/helpdata/EN/cf/21ea31446011d189700000e8322d00/frame
set.htm

4.1 Tabla base de datos


Una tabla de diccionario ABAP es la réplica de una tabla de la base de datos física del sistema.
Se utilizan estas tablas para de manera transparente al programador, almacenar los datos en la
BD de SAP.

20/06/2013 18 de 80
ABAP IV para funcionales.doc
4. Diccionario ABAP

Una estructura es un tipo de datos de SAP que contiene una serie de campos. Una estructura
puede estar incluida dentro de una tabla, o utilizarse como “conjunto” de campos en un programa
ABAP o en la definición de pantallas.

Cuando se utiliza una estructura como tal (sin formar parte de una base de datos), ésta no se
guarda en la BD de SAP, sino que cada campo de la estructura estará mapeado con un campo
de alguna tabla de SAP, ya que son estás las que se almacenan en la BD física.

4.1.1 Crear tabla Z


Para crear una tabla Z seguir los siguientes pasos:
1. Transacción se11
2. Introducir el nombre de la tabla que se desea crear. La tabla debe empezar con Z. Pulse
crear.
3. La clase de entrega de la tabla puede variar según para que se necesite. Normalmente,
se utilizará como tabla de datos maestros, por tanto, se deberá poner una A.
4. Para actualizar la tabla se puede realizar mediante vista de actualización, o a través de
programas Z o user-exits. Según lo que se desee se deberá elegir:

20/06/2013 19 de 80
ABAP IV para funcionales.doc
4. Diccionario ABAP

En caso de que queramos realizar una vista de actualización sin restricciones, es decir,
accesible para todos los usuarios, seleccionar ‘X’.

5. Introducir los campos de la tabla. Se pueden introducir campos estándar y campos Z.


6. Decida cuales serán los campos clave de la tabla. SIEMPRE debe haber un campo clave
como mínimo.
7. Una vez haya finalizado pulse el botón de “Opciones técnicas”.
 Clase de datos: seleccione la opción más adecuada a sus necesidades.
Normalmente será “APPL0”
 Categ. Tamaño: según la cantidad de datos que estima que su tabla contendrá
seleccione el valor.
Estos son los datos mínimos que debe introducir, una vez haya finalizado, grabe.

8. Active la tabla.

4.1.1.1 Elemento de datos


Cada campo de la base de datos tiene un elemento de datos, que es el que nos define el tipo del
campo. Se pueden crear desde la transacción se11.

Existen diferentes tipos de elementos de datos:


 Dominio: crear un dominio donde poner los valores posibles de un campo
 Tipo instalado: seleccionar un tipo de los preestablecidos por SAP estándar
 Tipo referencia: el elemento de datos hace referencia a algún campo de las tablas ya
creadas en SAP

Si desea que tenga una ayuda de búsqueda añádala aquí.

Es importante introducir la denominación de campo ya que cuando se utilice la estructura, por


defecto saldrá los textos que usted indique.

Seleccione el que desea y active la estructura

NOTA: Traducción de elemento de datos. Si se accede al sistema en diferentes idiomas, debe


traducir los textos a estos estos idiomas. Para realizar esto debe pulsar Pasar a  Traducción.
Introduzca el idioma al cual desea traducir.

20/06/2013 20 de 80
ABAP IV para funcionales.doc
4. Diccionario ABAP

4.1.1.2 Dominio
Para crear un dominio debe acceder a la transacción se11.
 Introduzca el tipo de datos y la cantidad de posiciones.
 Ámbito valores: si desea que en el campo que utilice el dominio solo se puedan introducir
una serie de valores o unos intervalos debe introducirlos en este momento.

Una vez haya finalizado active el dominio.

4.1.2 Crear vista de actualización


Cuando se desea que los usuarios puedan modificar los datos de una tabla se debe crear una
vista de actualización. Para ello, siga los siguientes pasos: transacción se11  Utilidades 
Generador actualizador tablas.

Si desea que cualquier usuario pueda modificar los datos, seleccione como “Grupo de
autorizaciones” el “&NC&”; en caso contrario, seleccione el que desee.

En el campo grupo de funciones debe introducir la función ABAP que realizará la acción de la
actualización de la tabla. Esta función no la debe implementar, ya que se genera sola, pero en
caso de que desee modificar el funcionamiento estándar de la vista de actualización, debe
modificarlo en esta función. Se recomienda utilizar como grupo de funciones el mismo nombre
de la tabla creada para no tener confusiones.

El tipo de actualización indica como desea que se visualice la actualización de los datos. Si no
tiene ningún requerimiento, seleccione “Un nivel”. Pulse el botón y finalmente
el icono de creación.

20/06/2013 21 de 80
ABAP IV para funcionales.doc
4. Diccionario ABAP

Una vez haya finalizado la creación de la vista de actualización, pruébela a través de la


transacción SM30.

4.1.3 Ampliación de tabla de base de datos


Cuando se deben añadir campos Z a una tabla (sólo se debe realizar en casos extremadamente
necesarios ya que esos campos se tienen que mantener a través de user-exit y siempre por
programación), se deben realizar los siguientes pasos: Transacción SE11  Pasar a 
Estructura Append  Crear Append.

Los campos de una estructura append debería empear siempre por ZZ para diferenciarlo tanto
de los campos estándar (no empiezan por Z), como de campos de tablas Z (los campo de las
tablas Z, deberían empezar por Z).

Una vez se hayan introducido los campos deseados, activar la estructura. Consultar los logs que
aparecen y en caso de que todo sea correcto, la estructura APPEND ya formará parte de la tabla
seleccionada.

4.2 Instrucciones SQL de ABAP/4


Para realizar las lecturas, escrituras sobre la BD, el lenguaje ABAP/4 utiliza instrucciones SQL.
Cada instrucción SQL tiene u na función diferente. A continuación se mostrarán las principales.

20/06/2013 22 de 80
ABAP IV para funcionales.doc
4. Diccionario ABAP

4.2.1 Select
Es la instrucción básica para leer información de la base de datos.

Las variables de sistema que mostrarán la información más relevante son las siguientes:
- sy-subrc: si sy-subrc = 0  registro encontrado
si sy-subrc <> 0  no existen registros que cumpla las condiciones

- sy-dbcnt: indica la cantidad de registros seleccionados.

Si se desea leer un solo registro se utilizará la condición SINGLE:


SELECT SINGLE * FROM <tab>
WHERE <cond>

Si se desea leer más de un registro se puede utilizar la sentencia SELECT de las siguientes
maneras:

 Lectura iterativa: selección de un conjunto de registros y posiblemente tratamiento de


cada uno de estos registros.

SELECT * FROM <tab> INTO <lugar>


WHERE <cond>.

...
Posible tratamiento de “lugar”
ENDSELECT.

 Lectura masiva de datos: se seleccionan un conjunto de registros de la BD y se


almacenan directamente en una table interna que debe tener el mismo tipo que los
datos que se van a seleccionar.

SELECT * FROM <tab> INTO TABLE <internal_table>


WHERE <cond>.

La tabla internal_table y <tab> deben ser exactamente igual. En caso de que no sean
iguales, sino que solo coincidan algunos campos de las tablas, se debe utilizar la
sentencia SELECT de la siguiente manera:

SELECT * FROM <tab>


INTO CORRESPONDING FIELDS OF TABLE <internal_table>
WHERE <cond>.

En los dos casos expuestos anteriormente, se almacenan los datos hallados en la


selección en la tabla interna <internal_table> eliminando los posibles registros que ya
existiesen antes de la selección. Si no se desean eliminar, sino que se desea añadir
registros en lugar de utilizar la sentencia INTO TABLE, utilice APPENDING TABLE y
en lugar de INTO CORRESPONDING FIELDS, utilice APPENDING
CORRESPONDING FIEDLS.

20/06/2013 23 de 80
ABAP IV para funcionales.doc
4. Diccionario ABAP

4.2.2 Insert
La sentencia INSERT permite introducir registros sencillos o el contenido de una tabla interna en
una base de datos SAP.

INSERT <tabla>.

La variable de sistema sy-subrc es la que reflejará el correcto funcionamiento de la instrucción.


sy-subrc = 0  Registro/s insertado/s
sy-subrc <> 0  La clave de registro que se deseaba insertar ya existe.

Si se desea insertar los datos de una tabla interna, utilice la sentencia INSERT de la siguiente
manera:
INSERT <tabla> FROM TABLE <internal_table>.

La tabla interna debe tener la misma estructura que la tabla de la BD.

4.2.3 Update
La sentencia UPDATE permite modificar el contenido de uno o varios registros.

UPDATE <tabla>.

Por defecto modifica el registro de la base de datos que está especificado en el registro de
cabecera.

Si se desea modificar el contenido de más de un registro a la vez se debe utilizar la sentencia


UPDATE con un SET.

UPDATE <tabla> SET <campo> = <valor> WHERE <cond>.

Si se desea modificar una tabla a través de una tabla interna se utilizará la sentencia de la
siguiente manera:

UPDATE <tabla> FROM TABLE <internal_table>.

La variable de sistema que indicará el éxito o no de la modificación en la BD será: sy-subrc.


SI sy-subrc = 0  Todos los registros fueron modificados
Si sy-subrc = 4  No todos los registros fueron modificados

4.2.4 Modify
La sentencia MODIFY se debe utilizar cuando no se está seguro si el registro que deseamos
tratar está insertado o no en la BD. Si ya está insertado, se modificará (UPDATE) y si no existe
se insertará (INSERT).

MODIFY <tabla>.
MODIFY <tabla> FROM TABLE <internal_table>.

20/06/2013 24 de 80
ABAP IV para funcionales.doc
4. Diccionario ABAP

4.2.5 Delete
Para realizar borrado de datos, se utiliza la sentencia DELETE.

DELETE <tabla>.

Por defecto se eliminará el registro que está en la cabecera. Si se desea eliminar más de un
registro, se utilizará la sentencia de la siguiente manera:

DELETE FROM <tabla> WHERE <cond>.

La variable de sistema que mostrará la información más relevante es la sy-subrc.


Si sy-subrc = 0  Todos los registros han sido eliminados
Si sy-subrc = 4  No todos los registros han sido eliminados

20/06/2013 25 de 80
ABAP IV para funcionales.doc
5. Debugging

5 Debugging

5.1 Debugging clásico


La pantalla de debug aparecerá en el mismo modo que está ejectuando el programa o
transacción. Le permitirá ver el valor de las variables y tablas internas, y modificarlas en tiempo
de ejecución.

Las teclas básicas para el debug son las siguientes:


 F5: pulsando F5 pasamos a la siguiente instrucción ABAP.
 F6: si se pulsa F6 en una instrucción simple, actua igual que F5, sin embargo si se
presiona F6 en la llamada a una subrutina o función, la ejecución de esta se
realizará de forma transparente y no se verá la ejecución por dentro.
 F7: si está dentro de una función o rutina o no desea debugarla hasta el final, sino
que desea volver al programa principal o al programa anterior, pulse F7.
 F8: ejecuta todo el código sin ser debugado. Si existe otro break-point se detendrá
la ejecución en ese punto.

5.1.1 Activar / Desactivar debbug


Se puede activar el debugging de dos maneras diferentes:

1. Fijando breakpoints sobre la línea de código donde deseamos que se detenga la


ejecución. En el momento que estemos utilizando la transacción y pase por este punto, el
programa se detendrá y podrá empezar su debug.

2. En ejecución: si no desea fijar breakpoints deberá ejecutar la función de debug de una


de las siguientes maneras:

a. Des del editor de ABAP (Transacción se38), pulsar: Programa  Ejecutar 


Debugging

b. Des de cualquier pantalla de la transacción que se está ejecutando pulsando:


Sistema  Utilidades  Debugging ABAP

20/06/2013 26 de 80
ABAP IV para funcionales.doc
5. Debugging

c. En cualquier momento de la ejecución de la transcción escribiendo en el campo


de comandos la sentencia /h y pulsando INTRO. Cuando realice la siguiente
acción aparecerá la pantalla de debugging.

Para desactivar el debug y continuar con el flujo normal de la transacción pulse:

Para desactivar el debug y parar la transacción en ese momento (es decir salir de la transacción
sin guardar los cambios)

20/06/2013 27 de 80
ABAP IV para funcionales.doc
5. Debugging

5.1.2 Variables de sistema


Las variables de sistema se almacenan en una estructura denominada: SYST. Dentro de la
ejecución de un programa puede consultar estas variables. Las más utilizadas son las
siguientes:

 sy-subrc  explicada anteriormente


 sy-tabix:  iteración actual dentro de un bucle
 sy-datum  fecha actual del servidor
 sy-uzeit  hora actual del servidor
 sy-langu  clave de idioma en que está logado el usuario
 sy-ucomm  código recogido por el modulo PAI donde indica el evento que se ha
producido
 sy-msgid  indica la clase de mensaje que se ha lanzado
 sy-msgno  indica el nº de mensaje dentro de la clase de mensajes
 sy-msgty  tipo de mensaje (E: Error, W: Warning, I: Information).

5.1.3 Breakpoint
Un breakpoint es una señal de detección que se debe colocar en los puntos en que se desea
que el proceso del código ABAP se detenga y se ejecute la función “debug”. El debug se activa
cuando el programa alcanza el punto señalado con un breakpoint.

Existen diferentes tipos de breakpoints:


1. Estáticos: se deben poner en el código ABAP y pueden ser dependientes de usuario o
independientes.
 Independientes de usuario: la sentencia ABAP utilizada es:
IF mara-matnr = ‘0000000001234567890’.
break-point.
ENDIF.

 Dependiente de usuario: la ejecución del programa tan solo se verá alterada


cuando el usuario SAP que está ejecutando el programa es el que aparece en la
sentencia ABAP: break “usuario SAP”.

IF mara-matnr = ‘0000000001234567890’.
break STRBCN .
ENDIF.

Los break-points estáticos deben ser eliminados antes de pasarse a producción. Son un
tipo de break-points que deberían utilizarse solo en la fase de implementación de un
proyecto.

NOTA: en aplicaciones BSP (sesiones http) los break-points estáticos provocan una
interrupción del programa y generan un log de error, por tanto no deberían utilizarse
nunca en este tipo de programas.

2. Break-points dinámicos: son específicos de usuarios. Se fijan/eliminan pulsando doble


clic sobre la línea de código ABAP en el editor de programa o sobre la ejecución de

20/06/2013 28 de 80
ABAP IV para funcionales.doc
5. Debugging

debug. Todos los break-points dinámicos se eliminan en el momento que sale del
sistema.

3. Break-point en sentencia: el debug se detiene justo inmediatamente antes de llegar a


esta sentencia. Se puede activar en el mismo momento del debug.

Introduzca la sentencia (ej. Parar en todas las llamadas a funciones  call function; todas
las veces que se ejecute un acceso a la base de datos  select; … ).

El siguiente mensaje aparecerá:

4. Break-point en subrutinas: si desea parar la ejecución cuando llegue a la llamada de una


subrutina en concreto debe introducir el nombre del report y el nombre de la subrutina.

20/06/2013 29 de 80
ABAP IV para funcionales.doc
5. Debugging

Nombre report

Nombre
subrutina

5. Break-point en módulos de funciones: si desea parar la ejecución cuando llegue a la


llamada de una función en concreto debe introducir el nombre de la función. Pulse enter
y posteriormente F8. La ejecución se detendrá en el momento que se encuentre con el
primer break-point.

20/06/2013 30 de 80
ABAP IV para funcionales.doc
5. Debugging

6. Break-point en métodos: si desea parar la ejecución cuando llegue a la llamada de un


método en concreto debe introducir el nombre del método y de la clase a la que
pertenece. Pulse enter y posteriormente F8. La ejecución se detendrá en el momento
que se encuentre con el primer break-point.

Se recomienda utilizar el matchcode para buscar el nombre de la clase deseado y de los


métodos que pertenecen a esa clase.

20/06/2013 31 de 80
ABAP IV para funcionales.doc
5. Debugging

5.1.4 Watchpoint
Al igual que los breakpoints, los watchpoints son indicadores de parada durante la ejecución de
un proceso ABAP. La mayor diferencia entre los breakpoints y los watchpoints es que los
segundos solo se activan cuando el valor de una determinada variable (sobre la que decida
colocar el watchpoint) se modifique.

Solo se pueden definir durante del debugging y se pueden colocar un máximo de 5 en un


programa.

Se pueden colocar watchpoints a nivel local o global. Si lo define a nivel global, actuará sobre la
ejecución de cualquier programa que ejecute, en cambio si lo activa a nivel local, sólo se
detendrá cuando el valor de la variable cambie en la ejecución del programa especificado.

Activar watchoint
Para activar un watchpoint debe seguir los siguientes pasos:

1. Crear watchpoint. Recuerde que sólo podrá crear un watchpoint cuando este debugando.

2. Introducir la variable que provocará la detención de la ejecución del programa.

3. Si se desea que la detención de la ejecución no se realice con todas las modificaciones


que sufra la variable, se pueden introducir condiciones.

Los operadores que se pueden utilizar son los siguientes:

20/06/2013 32 de 80
ABAP IV para funcionales.doc
5. Debugging

Operador Significado
< Menor que
<= Menor o igual que
= Igual
<> No Igual
>= Mayor o igual que
> Mayor que

Para utilizar estos operadores, en la pantalla donde debe introducir la variable añada la
condición.

Si se utiliza el debugging clásico, la pantalla que aparecerá será la siguiente:

Visualizar watchpoint
Si desea visualizar los watchpoints que tiene activos, vaya a la pestaña “Watchpoints” durante el
debug y aparecerán listados.

Debug clásico:

20/06/2013 33 de 80
ABAP IV para funcionales.doc
5. Debugging

Nuevo debug:

Modificar watchpoints
Nuevo debug: vaya a la pestaña “Break/Watchpoints”, seleccione el watchpoint que desea
modificar y pulse el icono .

20/06/2013 34 de 80
ABAP IV para funcionales.doc
5. Debugging

La información del watchpoint aparecerá. Modifique lo que desee y pulse aceptar.

Si desea modificar un watchpoint en el debug clásico, vaya a la pestaña “Watchpoints” y pulse el


botón de modificar.

20/06/2013 35 de 80
ABAP IV para funcionales.doc
5. Debugging

Modifique lo que desea y pulse aceptar.

Borrar / Desactivar Watchpoints


Para borrar un watchpoint tanto en el nuevo debug como en el clásico, siga los mismos pasos
que para la modificación pero en lugar de pulsar el botón de modificar, pulse el de eliminar .

El nuevo debug ofrece la posibilidad de desactivar un watchpoint. Es decir, en la actual ejecución


del programa, el watchpoint no intervendrá mientras esté desactivado, pero automáticamente
cuando vuelva a realizar otra ejecución se tendrán en cuenta.

Para desactivarlo pulse el botón cuando tenga seleccionado el watchpoint que desea. Para
volver a activarlo pulse .

20/06/2013 36 de 80
ABAP IV para funcionales.doc
5. Debugging

5.1.5 Visualizar pila de llamadas


Como ya se ha visto en capítulos anteriores, una report puede llamar a una subrutina, función…
éstas pueden llamar a otras y así sucesivamente. Un posible esquema sería el siguiente:

Form tratar_cliente Function val_nif Function val_letra


…. ...
…. ...
call function val_nif … Perform cifrar
…. call function val_letra ….
…. …. ….
Endform Endfunction ….
Endfunction

Si está debugando la rutina “cifrar” dentro de la función val_letra, puede ver los datos de la
función val_nif y los datos de la rutina tratar_cliente. Para ello debe utilizar la pila de llamadas.

La apariencia de esta pila en el sistema será la siguiente:

5.2 Debugging SAPSCRIPT


Para activar el debug de un formulario en Sapscript lo deberá hacer de la siguiente manera:
1. Vaya a la transacción se71 e introduzca el formulario que desea debugar

20/06/2013 37 de 80
ABAP IV para funcionales.doc
5. Debugging

2. Activar el debug pulsando: Utilidades  Activar debugger

3. El siguiente mensaje aparecerá:

4. Vaya a la transacción desde donde desea visualizar el formulario.

20/06/2013 38 de 80
ABAP IV para funcionales.doc
5. Debugging

La siguiente pantalla aparecerá:

Si desea debugar acotar la búsqueda ponga los parámetros que desea. Sino pulse “OK”. Ya
podrá empezar a debugar.

20/06/2013 39 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

6 Ampliaciones de estándar
El código estándar de SAP NO se puede modificar, ya que en caso de modificación se perdería
el soporte que SAP proporciona.

A pesar de que SAP es un sistema estándar parametrizable, muchas veces las


parametrizaciones son insuficientes para cubrir los requerimientos del cliente. Por este motivo,
SAP deja puntos de código abiertos para una mayor adaptación cliente-sistema. Sólo en estos
puntos del estándar se puede introducir código.

No todas las ampliaciones de estándar están disponibles en todos los módulos de SAP. A
continuación se mostrará la relación que hay módulo-ampliación.

FI / CO MM SD PP PS PM / CS
Function-Exit      
User-Exit 
Rutinas 
BADI’s    
BTE’s    f

6.1 Function Exit


Buscar todo tipo de user-exit, o en este caso function exit no es tarea fácil ni mecánica, por tanto
se irán mostrando diferentes técnicas que pueden ayudar a encontrar el punto concreto en que
desea introducir código.

Cuando desde el código estándar se llama a una function exit, se utiliza la siguiente
nomenclatura:
CALL CUSTOMER-FUNCTION<3 digit suffix>

El nombre standard de la function_module es:


EXIT_<programName><3 digit suffix>

Las function-exti aplican a todos los módulos de SAP.

6.1.1 Buscar function exit


- Lo primero que se debe hacer para buscar una ampliación de estándar es mirar la ayuda del
customizing para ver si muestra información. Se recomienda poner un breakpoint en todas las
ampliaciones que muestre el help y simular el caso en que se desea que actue la ampliación.
Mediante debug se podrá validar cual de todas ellas es la correcta.

- En caso de que por la transacción SPRO no se encuentre el caso concreto que se desea, se
recomienda utilizar un programa Z que listará todas las function exit por las que pasa el código

20/06/2013 40 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

estándar de SAP al ejecutar una transacción en concreto. El código de este programa Z está en
el anexo II de este tutorial.

- Si no puede copiar el programa en el sistema, puede buscar las function exits a través de la
transacción SMOD. Ponga “*descripción*” y aparecerán todas las function exits relacionadas con
la descripción introducida.

Cualquiera de las tres opciones nos llevarán a la pantalla de la transacción SMOD con la
“Ampliación” seleccionada.

6.1.2 Activar function exti


Para que el código estándar de SAP ejecute el código de una function exit, ésta debe estar
activa. Para ello se deberán realizar los siguientes pasos (se mostrarán a través de un ejemplo):

- Des de la transacción SMOD pulse Visualizar y aparecerá la descripción de la function


exit.

- Una ampliación puede contener varias function exit que estarán las relacionadas. Estas
function exit son los componentes de la ampliación. Pulse el botón “Componentes” para
continuar.

- Aparecerán los módulos de funciones (function exit) de esta ampliación. Elija el que crea
que se adapta a sus requerimientos y pulse doble click sobre él.

20/06/2013 41 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

- La definición de la función aparecerá en su pantalla. En este momento puede ver los


datos de entrada de la función y, muy importante, los datos que se pueden modificar. Si
usted desea modificar un campo que es de entrada, pero no es modificable en la función,
cuando el flujo del código salga de la función, el valor no se habrá modificado.

Parámetros

- Pulse doble click sobre el include. En la función estádar no puede introducir código, por
ese motivo, SAP le proporciona un include Z* que si que es modificable.
La primera vez que se crea la función, aparecerá un mensaje de advertencia

Debe crear el objeto para poder implementarlo.

- Una vez esté dentro del include Z* puede introducir el código que desea. Se recomienda
poner un break-point para ver si es la function exit que se desea. Active el include .

20/06/2013 42 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

- Llegados a este punto tendrá activo el código de la function exit pero no la ampliación.
Para ello, deberá acceder a la transacción CMOD.

En la pantalla principal debe introducir un proyecto. Un proyecto sirve para agrupar un


conjunto de function exit. Antes de crear uno nuevo, compruebe que no hay ninguno que
contenga su function exit o que agrupe otras con características funcionales similares. Si
no existe ninguna, cree un proyecto siguiendo los pasos que se muestran a continuación.
Si no debe crear el proyecto siga al punto siguiente.

o Introduzca el nombre del proyecto y pulse “Crear”.

o Introduzca una descripción y pulse Grabar.

- Una vez esté dentro del proyecto, pulse “Asignación ampliación”.

20/06/2013 43 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

- Introduzca la ampliación que desea unir al proyecto que está creando.

- En este punto ya tiene unida la ampliación con el proyecto, pero no tiene activados los
componentes. Para ello, pulse el botón “Componentes”. Aparecerá el estado de todos los
componentes (de todas las ampliaciones asignadas) que tiene el proyecto.

Pulse el botón y activará el proyecto y la ampliación (con sus componentes).

- A partir de este momento, cuando el código estándar pase por la function exit asignada al
proyecto, se ejecutará el código de esta.

6.2 User Exit


Las user-exit son otras ampliaciones de estándar que, a pesar de que se implementan de
diferente manera, tienen exactamente la misma utilidad.

Se utilizan para el módulo de SD.

Tienen dos diferencias respecto a las anteriores:


- No deben ser activadas. Sólo se debe activar el código que usted implemente.
- Necesitan un código de registro SAP para implementarse.
- No son funciones, son subrutinas definidas dentro de un include.

20/06/2013 44 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

6.2.1 Buscar user-exit


Como todas las ampliaciones, existen varias maneras de encontrar la que se necesita. Se
detallarán las dos más utilizadas.

- Customizing: a través de la SPRO, igual que las function exit, se encontrará información
del conjunto de user-exit implementadas para cada acción del flujo estándar.

Se mezclarán las function-exits con las user-exits en las descripciones.

- Existe un report Z (igual que para la búsqueda de function-exits) donde introduciendo el


nombre del programa sobre el que la transacción deseada se ejecuta, le mostrará todas
las user-exits que intervienen.

ATENCIÓN: piense que varias transacciones pueden correr bajo el mismo programa, por
tanto, el hecho de que en la búsqueda aparezca una user-exit no garantiza al 100% que
el flujo de la transacción que usted desea, también pase por esa ampliación.

6.3 Rutinas
Las rutinas son subrutinas más breves que llevan a cabo diversas verificaciones en el
tratamiento de documentos.

Las rutinas se utilizan en el módulo de SD a través de la transacción VOFM para las siguientes
acciones:
- Condiciones de copia y transferencia de datos: se definen para varias clases de
documentos comerciales y textos. Siempre se deberá una condición de copia y de

20/06/2013 45 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

transferencia de datos al parametrizar el flujo de documentos, pero pueden utilizarse las


rutinas estándar o rutinas desarrolladas a medida.

La condición de copia sirve para determinar que campos deben copiarse o no.

La transferencia de datos permite realizar un control detallado de los campos que se van
a copiar y determinar como se van a copiar.

- Condiciones y fórmulas de las técnicas de condiciones: Se utilizan en el esquema de


cálculo y clase de condición.

Las condiciones en la determinación de precios se utiliza para evaluar si según las


características deseadas, una condición determinada debe considerarse en el esquema o
no.

Las fórmulas se utilizan en la determinación de precio para definir diferentes factores


para la determinación de precio.

Para todas estas acciones, SAP utiliza unas rutinas estándar. Si se desea modificar el flujo del
estándar se debe crear una rutina del mismo tipo de la que se utiliza durante la ejecución
estándar y añadir el código deseado.

La nomenclatura de las rutinas estándar son 3 dígitos del 000 al 599 (existen algunas rutinas de
dos dígitos que van del 00 al 59).

En el momento que se desee crear una rutina nueva, se debe utilizar la nomenclatura reservada
para las modificaciones, es decir se deberá crear una subrutina con numeración a partir del 600
hasta 999 (o en su defecto, del 60 al 99).

6.3.1 Crear rutinas


Una rutina estándar se puede sobrescribir pero NO se debería realizar a no ser que exista una
nota de SAP que así lo diga. En caso contrario, se debe crear una nueva.

Ej. Se desea una nueva rutina de control de copia entre una oferta y un pedido de ventas.
 Transacción VOFM:

20/06/2013 46 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

 Aparecerá la siguiente pantalla:

Para el ejemplo con el que se trabaja, el estándar utiliza la rutina de copia 51 pero esta rutina no
se adapta a nuestras necesidades, por tanto, se deberá crear otra.

 Para crear una nueva rutina, añada el código siguiente a la última rutina creada (siempre a
partir del 600) y pulse Intro.

 Deberá registrar la rutina.

20/06/2013 47 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

 Implemente la condición de copia que desee. Se recomienda copiar el estándar y añadir o


eliminar el código que desee.

 Una vez lo haya implementado. Active el código pulsando el botón

 Active la rutina

20/06/2013 48 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

6.4 BADI’s
Las BADI’s (Bussiness Ad-ins) son unas herramientas de programación abap orientada a objetos
que ayuda a adaptar el sistema a los requerimientos del cliente. Este tipo de ampliaciones se
pueden utilizar a partir de la versión 4.6c.

Existen diferencias a nivel técnico entre las BADI’s y las demás ampliaciones, pero no se
tratarán ya que no se consideran parte del alcance de este curso.

6.4.1 Buscar BADI’s


- Customizing: La primera manera que se debe utilizar es a través del customizing
(SPRO). Se debe navegar por el menú hasta la carpeta que trate del problema que se
desea resolver. La mayoría de veces, aparecerá la siguiente opción:

Si desplega la carpeta aparecerán todas las badis que afectan a esos puntos de
customizing.

Vaya leyendo las descripciones de aquellas que se aproximen a sus requerimientos y


ponga un break-point para posteriormente asegurarse de cual de todas las posibles
badi’s es la que usted realmente desea.

- Trace: Si a través de la SPRO no encuentra la BADI, se podrán detectar a través del


trace de SAP. Todas las badi’s están almacenadas en tablas de SAP y cada llamada a
sistema recorre estas tablas, por tanto, a partir de las llamadas a estas tablas, se podrá
listar todas las badi’s por las que pasa la ejecución de la transacción.

1. Asegúrese de que no hay nadie con su usuario ejecutando ninguna transacción ya


que si es así los resultados del trace serán más complicados de interpretar.

20/06/2013 49 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

2. Ejecute la transacción ST05 (Performance Analysis), marque la opción “Table buffer


Trace” y pulse “Activate Trace”.

3. Ejecute la transacción donde desea buscar las badis que intervienen.

4. Una vez haya grabado el proceso vaya al modo donde estaba ejecutando el trace y
pulse “Desactivar trace”.

5. Pulse “Visualizar trace” y aparecerá un popup como el siguiente:

En los objetos introduzca los siguientes: V_EXT_IMP y V_EXT_ACT.

20/06/2013 50 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

6. Los resultados que se mostrarán por pantalla serán similares a estos:

Fijése en las entradas de la vista V_EXT_IMP con el tipo de operación OPEN. Todas
estas entradas empiezan con IF_EX (prefijo estándar de SAP para las clases de
interfaz de las BADI’s. El nombre real de la badi es la parte posterior del string.

Ejemplo: el nombre de la clase IF_EX_BADI_MATERIAL_CHECK es


BADI_MATERIAL_CHECK.

20/06/2013 51 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

7. Todas las badis que aparezcan en el trace son las que se ejecutan durante la
transacción que usted utiliza, por tanto las que podrían ser útiles para sus
requerimientos. Para visualizarlas vaya a la transacción se18.

Pulse visualizar y podrá ver los métodos de la badi.

Lea las descripciones y entre dentro de los métodos (pulse doble click) para ver los
parámetros que recibe la badi (parámetros de entrada, salida o entrada/salida).

20/06/2013 52 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

8. Si desea poner un break point para que al ejecutar la transacción se detenga, vaya a
la transacción se80.

Como tipo de objeto seleccione “Clase/Interface” y introduzca la interfaz a la que


pertenece la badi (es decir, la que empieza por IF_EX_*).

Siga el siguiente menú: Clases implementadotas  CL_EX_ + el nombre de la badi


donde desea colocar el break-point  Métodos  IF_EX_*  el método que desea
visualizar. Pulse doble click.

20/06/2013 53 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

6.4.2 Implementar una BADI


Las transacciones necesarias para la implementación de BADI’s son las siguientes:
 se18  Definición de BADIS
 se19  Implementación de BADIS

Como ejemplo se tomará la BADI hallada para la validación del maestro de materiales
(BADI_MATERIAL_CHECK).

Debe asegurarse que los parámetros que tiene de entrada y de salida son los que usted
necesita. Para ver los parámetros, vaya a la transacción se18. Antes de implementar una badi,
asegúrese mediante el debug que será la que finalmente utilizará.

Para realizar la implementación de la badi, vaya a la transacción se19 e introduzca el nombre de


la badi (no el de la clase ni la interfaz).

20/06/2013 54 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

Pulse el botón “Implement” y aparecerá un pop-up donde debe crear una nueva implementación
para la definición seleccionada. El nombre de la implementación debe empezar por Z.

Introduzca la descripción y el nombre de la clase a implementar.

20/06/2013 55 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

Una vez haya finalizado, active la ampliación.

Una vez ha definido la badi, tan solo debe introducir el código que desee. Para ello, vaya a la
transacción se80 y seleccione “Clase/Interface”. Introduzca la clase y pulse enter. Abra los
siguientes directorios: IF_EX_BADI_MATERIAL_CHECK  ZCL_IM_BADI_MATERIAL_CHECK
 Métodos  IF_EX_BADI_MATERIAL_CHECK  Método que desee implementar.

6.5 BTE’s
Los Business Transaction Events (BTE) son ampliaciones que fueron desarrolladas para el
módulo FI de R/3 a pesar de que en las últimas versiones ya se pueden utilizar en otros
módulos. También se conocen como Open FI Interfaces.

Existen dos tipos de BTE’s:

 Interfases de Publicación y Suscripción: estas interfases informan sobre eventos


particulares en la aplicación estándar SAP y hacen que los datos creados/modificados
sean accesibles para software externo. Es como si se lanzase un evento en el momento
en que se crea o modifica un registro maestro, o se crea/anula un nuevo documento o
algún item de estos.

 Interfases de proceso: se utilizan para modificar el flujo estándar de ejecución del sistema
SAP. Es decir, este tipo de BTE’s serían las que entrarían dentro de las ampliaciones que
se están estudiando.

Las BTE’s se denominan a través de un código de 8 dígitos. Por estándar el 5º y 6º dígito


siempre serán el mismo cuando sean BTE’s que aplican sobre el mismo programa. De esta
manera se pueden agrupar más fácilmente.

20/06/2013 56 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

Estos eventos se deben registrar y tienen asociados un módulo de función base que sigue la
siguiente nomenclatura:
sample_interface_<n> donde <n> es el número de 8 dígitos.

Por otro lado los módulos de funciones específicos para cada uno se denominan:
OPEN_FI_PERFORM_<n>_E  Interfase de Publicación y Suscripción
OPEN_FI_PERFORM_<n>_P  Interfase de Procesos

6.5.1 Buscar BTE’s


Para buscar BTE’s existen diferentes métodos. A continuación se mostrarán los más utilizados:

 Customizing: a través de la transacción SPRO, se pueden buscar las ampliaciones de


sistema que sean necesarias. Para acceder a las BTE siga el siguiente path: Gestión
Financiera  Parametrizaciones básicas de Gestión financiera  Business Transactions
Events. La transacción a la que se accede es la FIBF.

Cuando se trata de BTE’s para ampliaciones de estándar (son las que se tratarán en este
documento) debe realizar una búsqueda de BTE por procesos.

Ejecute el listado y aparecerán todas las BTE’s implementadas en el sistema con una
breve descripción. Seleccione la que se adecue a sus requerimientos.

20/06/2013 57 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

 Programa: si a través de la transacción FIBF no encuentra la BTE que necesita, mire cual
es el nombre del report que ejecuta la transacción donde desea que intervenga la
ampliación. Con el nombre del programa vaya a la transacción se38 y visualícelo. Busque
la cadena de caracteres: “OPEN_FI_PERFORM”. Aparecerán todas las BTE’s que son
llamadas en el código. Ponga un breakpoint y decida cual de todas ellas es la más
adecuada.

6.5.2 Activar BTE’s


Para poder implementar una bte, se debe activar siguiendo una serie de pasos. Es importante
que cada paso quede activo. A continuación se mostrará un ejemplo de activación indicando
cada paso que se debe seguir.

1. Identificar la BTE que se desea implementar. Para buscar la BTE que se ajusta a los
requerimientos solicitados vaya al punto anterior.

Imagine que desea realizar una sustitución de un campo de cabecera en el momento de


contabilizar un documento. La BTE seleccionada sería:
00001130 – CONTAB.DOC: Sustitución de campo interna de SAP

2. Con la interfase seleccionada pulse el botón “Módulo de funciontes tipo”


.

Tal y como se ha explicado en la introducción el nombre de la función tipo será


“SAMPLE_PROCESS_00001130”.

20/06/2013 58 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

3. A continuación debe crear una módulo de funciones Z con copia al estándar. Recuerde
que NUNCA debe modificar funciones estándar, siempre debe crear una Z.

Aparecerá la siguiente pantalla:

Cambie el nombre del módulo de funciones destino por uno Z y seleccione el grupo de
funciones donde desea introducirlo. Si es la primera BTE que crea y debe crear un grupo
de funciones, sigas los siguientes pasos; sino vaya al paso 4.

a. Desde la transacción donde se encuentra (se37), siga el menú:

20/06/2013 59 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

b. Introduzca un nombre. Recuerde que debe empezar por Z y pulse “Grabar”.

c. El grupo de funciones ya está creado.

4. Introduzca el nombre del módulo de funciones y del grupo de funciones y pulse el botón
de “Grabar”.

5. Introduzca el código que desee en el módulo de funciones ZZ_SAMPLE_PROCESS* y


sobre todo, active tanto el módulo de funciones como el grupo de funciones.

6. Ahora, asigne el módulo de funciones al grupo de BTE’s del sistema. Para ello, vaya a la
transacción FIBF y siga el menú:

20/06/2013 60 de 80
ABAP IV para funcionales.doc
6. Ampliaciones de estándar

7. Introduzca una nueva entrada:


 Proceso: el nº de interfase
 Ps: sobre el cual se desea que actue la BTE. Si desea que actue siempre, no
introduzca nada
 IndAp: indica sobre que módulos/aplicaciones SAP actua la BTE. Si desea
que actue siempre, no introduzca nada.
 Módulo de funciones: Indique el módulo de funciones Z que ha creado en los
pasos anteriores.

Pulse Intro y posteriormente grabe la entrada.

8. La BTE ya está activa, si desea comprobarlo, ponga un breakpoint en el módulo de


funciones que ha creado y ejecute la transacción.

6.6 Preguntas frecuentes sobre ampliaciones de estándar


¿Qué pasa cuando de migra a otra versión de SAP con las user-exit? Hay que
transportarlas, volver a escribir las user-exit dentro de los programas estándar?

Las user-exit no se pierden cuando realizas la migración. Como mucho pueden quedar
desactivadas y deberemos volver a activarlas. El procedimiento exacto depende de a que
modulo pertenecen las user-exit y de la versión SAP que se tenga.

Necesito un dato en un user-exit que no está, ¿cómo lo consigo?

Lo mejor para conseguir datos que no están en la user-exit es utilizar field-symbols (punteros a
memoria).

20/06/2013 61 de 80
ABAP IV para funcionales.doc
7. Análisis de Errores

7 Análisis de Errores
Existen errores de programación que el compilador no detecta. Estos errores no se detectan
hasta el momento de la ejecución, por tanto es importante saber interpretarlos para poder
resolver cuanto antes este tipo de incidencias.

Los principales errores que pueden suceder en tiempo de ejecución son los dumps y los errores
de actualización que se detallan a continuación.

7.1 Dumps
Un dump o error de ejecución es un log de terminación anormal de ejecución de cualquier
programa. Esto se produce por una cancelación del programa que se está actualmente
ejecutando; el sistema muesta una pantalla con el log de terminación donde se pueden analizar
el error que ha producido la interrupción y las posibles soluciones.

Las causas más comunes de las terminaciones anormales de programas son:


 Errores de sintaxis en programas hechos a medida
 Referencias obsoletas a objetos de Workbench hechos a medida que han sido eliminados.
 Cancelación manual de un modo actualmente en ejecución.

Cuando se produce una terminación anormal de este tipo, el log del dump aparece
automáticamente en la pantalla para que se pueda analizar. Si después de cerrar la pantalla
desea volver a analizar el error, vaya a la transacción st22 donde podrá ver todos los dumps
producidos en los periodos que usted desee.

7.1.1 Interpretación de dumps


Desde la transacción st22 aparecerán el listado de dumps que se han producido en el intervalo
de fechas introducido. Para analizar el que usted desea, pulse doble click sobre él.

El log de error se divide en varias partes. Para realizar un primer análisis debe fijarse en las que
se mostrarán en negrita.

1) Texto breve
2) ¿Qué ha sucedido?
Suele explicarse el error de manera breve. Puede dar mucha información.
3) ¿Que se puede hacer?
Posibles soluciones
4) Análisis del error.
Extensión del punto 2. Se explica con más detalle las causas del error.
5) Notas para corregir errores
Si el error se produce en un programa Z, este punto no tiene sentido, en cambio si se
produce en un programa estándar, en este punto se mostrará como buscar la nota que
corresponde al error producido.
6) Entorno sistema
Aparecen los datos más importantes a nivel de administración de sistemas.
7) Usuario, transacción
Información de usuario, transacción, programa e idioma
8) Información lugar de terminación
Punto exacto del programa donde se ha producido el fallo.
9) Detalle código fuente

20/06/2013 62 de 80
ABAP IV para funcionales.doc
7. Análisis de Errores

Sección que muestra un intervalo del código fuente donde se ha producido el error. La
línea exacta aparece marcada con una flecha.
Pulsando doble click accederemos al programa al que pertenece el código.
10) Contenido campos de sistema
Se muestra el valor de las variables de sistema en el momento del dump.
11) Llamadas/Eventos activos
Muestra el programa o evento al que pertenece el detalle del código mostrado
anteriormente.
….

El resto de apartados del log de error son demasiado técnicos para entrar en ese nivel de
detalle.

NOTA: el título del error aparece en el idioma de conexión pero las descripciones de los errores
solo existen en inglés y alemán. Si al conectarse en español aparecen los textos en inglés
significará que durante la instalación se ha indicado que en caso de que existan textos que no
estén en español, se utilice en inglés. Si esto no se ha configurado los textos aparecerán en
alemán. Se recomienda hacer login en el sistema en idioma EN para asegurarnos de la
comprensión de los textos.

7.2 Error de actualización


Existen errores durante la grabación de documentos o datos maestros que no producen un
dump, sino un error de actualización ya que son errores que se producen en la grabación en la
base de datos. Estos errores de actualización aparecen con un mensaje como el que se muestra
a continuación después de unos segundos de que “aparentemente” se hayan grabado los datos
de la transacción.

Este tipo de errores tienen que estar producidos por una ampliación de estándar en el caso de
transacciones estándar. También puede aparecer el mismo mensaje durante la ejecución de un
programa Z cuando se utiliza una bapi.

Con la información que muestra el error, no se puede determinar que está sucediendo. Para ello,
vaya a la transacción sm13. Pulse doble click sobre el error y aparecerá algo similar a esto:

20/06/2013 63 de 80
ABAP IV para funcionales.doc
7. Análisis de Errores

En color rosa se muestra donde se ha producido el error. Pulse doble click y se mostrarán más
detalles e incluso podrá ver el código de programa donde se produce el error.

20/06/2013 64 de 80
ABAP IV para funcionales.doc
8. Varios

8 Varios

8.1 Mensajes de error


Los mensajes de error (e)/ warning (w)/ información (i) se tratan a través de la transacción se91.

Los mensajes de error son llamados desde un programa ABAP. Las nomenclaturas más utilizada
para lanzar un mensaje de error son las siguientes:

- Indicar la clase de mensajes al inicio del report. Todo el programa utilizará la misma clase
de mensajes.

REPORT rep MESSAGE-ID sabapdocu.


...
MESSAGE i014.

La clase de mensajes es “sabapdocu” y el nº de mensaje el 014. Todos los mensajes que


se envien des del programa “REP”, serán de la clase de mensajes “sabapdocu”.

- Indicar la clase de mensaje en el momento de la llamada del mensaje.


REPORT rep ...
...
MESSAGE i014(sabapdocu).

La clase de mensajes es “sabapdocu” y el nº de mensaje el 014. El report “REP” no tiene


asignada ninguna clase de mensajes por defecto, por tanto, siempre que se lance un
mensaje se debe indicar a que clase pertenece.

Otra manera de indicar el mismo mensaje es la siguiente:


MESSAGE ID ‘sabapdocu’ TYPE ‘I’ NUMBER ‘014’.

Si el mensaje que se desea lanzar permite la recepción de variables, se deberán pasar de la


siguiente manera:
MESSAGE i001(zcurso00) WITH <variable> ‘Texto fijo’.

Para poder lanzar este mensaje, en la definición del mensaje 001 de la clase de mensajes
ZCURSO00, deben aparecer dos símbolos & que representa la variable que en la llamada
aparece con el prefijo WITH. Como se puede comprobar con el ejemplo anterior, se puede pasar
una variable o un texto fijo (entre comillas simple).

8.1.1 Búsqueda de mensajes de error


Para ver un mensaje de error se debe conocer la clase de mensaje y, si es posible, el nº de
mensaje.

20/06/2013 65 de 80
ABAP IV para funcionales.doc
8. Varios

La clase de mensaje será un texto, y en la mayoría de los casos empezará por las siglas del
módulo en que se está trabajando.

Seleccione la clase de mensajes y aparecerá todos los mensajes que pertenecen a esa clase.
Cada mensaje estará identificado con el “nº de mensaje”.

NOTA: el símbolo “&” representa el valor de una variable o texto que al llamar al mensaje desde
el código se introduce.

Si se desea buscar en que punto del código SAP puede ocurrir un error en concreto (puede
facilitar mucho un debug, poner un breakpoint en el punto donde ocurre el error), siga los
siguientes pasos:

1. Seleccione el mensaje que desea buscar:

20/06/2013 66 de 80
ABAP IV para funcionales.doc
8. Varios

2. Pulse el botón y la siguiente pantalla aparecerá:

Seleccione donde quiere buscar el mensaje de error. Se recomienda marcar: Programas,


clases y aplicaciones BSP, ya que son los más utilizados, pero puede marcar todas las
opciones si en el sistema que está utilizando se utilizan errores en campos de tabla, o
eCATTs.

3. Una vez haya realizado la búsqueda aparecerán todos los puntos del sistema donde
aparece el mensaje seleccionado.

8.1.2 Creación de clase de mensaje


Es útil crearse una clase de mensajes para los desarrollos a medida que se realicen o las user-
exits que se utilizan. Creando una clase de mensajes Z se conseguirá identificar rápidamente si
un mensaje de error/advertencia/información es propio del estándar o es de alguna ampliación
realizada a medida.

Para crear una clase de mensajes siga los siguientes pasos:


- Introduzca el nombre que desea darle a la clase de mensajes. Recuerde que debe
empezar por Z.

- Introduzca la descripción de la clase de mensajes.

- Cree los mensajes que necesita para la clase de mensajes. Para crear un mensaje sólo
tiene que introducir la descripción.

20/06/2013 67 de 80
ABAP IV para funcionales.doc
8. Varios

Si desea describir con más detalle el error, selecciónelo y pulse el botón “Texto
explicativo”.

Una vez haya finalizado de introducir el texto explicativo, pulse el botón para activar .

8.2 Crear transacciones


Cuando se crea un programa se debe crear una transacción asociada a ese programa. Es una
tarea sencilla y rápida. La transacción que debe utilizar es la se93.

1. Introduzca el nombre de la transacción que desea crear. Recuerde que siempre debe de
empezar por Z. Pulse el botón de crear.

20/06/2013 68 de 80
ABAP IV para funcionales.doc
8. Varios

2. Seleccione el tipo de transacción que desea crear:

Normalmente los programas sobre los que se crean transacciones son programas con
una pantalla de selección. En este caso seleccione la segunda opción. Si no está muy
seguro de que tipo debe crearla, lea la ayuda de cada una de las opciones.

20/06/2013 69 de 80
ABAP IV para funcionales.doc
8. Varios

3. Introduzca el nombre del programa que desea que se ejecute al llamar a la transacción.

Puede introducir restricciones de ejecución a través de un objeto de autorización.

4. Una vez haya acabado de introducir las características que desee, pulse el botón de
guardar y la transacción estará lista para ser utilizada.

20/06/2013 70 de 80
ABAP IV para funcionales.doc
Anexo I – Transacciones más usadas

Anexo I – Transacciones más usadas


Las transacciones más utilizadas por un programador son:

Código Descripción
Transacción
se38
se80
se11 Diccionario ABAP (tablas, estructuras…)
se18 Definición de Badi’s
Se19 Implementación de Badi’s
se37 Grupo de funciones
st22 Errores en tiempo de ejecución ABAP
sm13
se71 Sapscript
cmod Gestión de proyectos de ampliaciones SAP
smod Ampliaciones SAP
se93 Actualizar transacción
se91 Actualización de mensajes

20/06/2013 71 de 80
ABAP IV para funcionales.doc
Anexo II – Programa de búsqueda Function-Exit

Anexo II – Programa de búsqueda Function-Exit


Pulsando doble click sobre cualquiera de las function-exit que devuelva la ejecución del
programa, llevará automáticamente a la transacción SMOD desde donde se podrá activar.

*&---------------------------------------------------------------------*
*& Report Z_USER_EXIT_TRANS *
*& *
*&---------------------------------------------------------------------*

REPORT Z_USER_EXIT_TRANS.

tables : tstc, tadir, modsapt, modact, trdir, tfdir, enlfdir.


tables : tstct.
data : jtab like tadir occurs 0 with header line.
data : field1(30).
data : v_devclass like tadir-devclass.
parameters : p_tcode like tstc-tcode obligatory.

select single * from tstc where tcode eq p_tcode.


if sy-subrc eq 0.
select single * from tadir where pgmid = 'R3TR'
and object = 'PROG'
and obj_name = tstc-pgmna.
move : tadir-devclass to v_devclass.
if sy-subrc ne 0.
select single * from trdir where name = tstc-pgmna.
if trdir-subc eq 'F'.
select single * from tfdir where pname = tstc-pgmna.
select single * from enlfdir where funcname =
tfdir-funcname.
select single * from tadir where pgmid = 'R3TR'
and object = 'FUGR'
and obj_name eq enlfdir-area.

move : tadir-devclass to v_devclass.


endif.
endif.
select * from tadir into table jtab
where pgmid = 'R3TR'
and object = 'SMOD'
and devclass = v_devclass.
select single * from tstct where sprsl eq sy-langu and
tcode eq p_tcode.
format color col_positive intensified off.
write:/(19) 'Transaction Code - ',
20(20) p_tcode,
45(50) tstct-ttext.
skip.
if not jtab[] is initial.
write:/(95) sy-uline.
format color col_heading intensified on.
write:/1 sy-vline,
2 'Nombre Exit',
21 sy-vline ,
22 'Descripcion',
95 sy-vline.
write:/(95) sy-uline.
loop at jtab.
select single * from modsapt
where sprsl = sy-langu and
name = jtab-obj_name.
format color col_normal intensified off.

20/06/2013 72 de 80
ABAP IV para funcionales.doc
Anexo II – Programa de búsqueda Function-Exit

write:/1 sy-vline,
2 jtab-obj_name hotspot on,
21 sy-vline ,
22 modsapt-modtext,
95 sy-vline.
endloop.
write:/(95) sy-uline.
describe table jtab.
skip.
format color col_total intensified on.
write:/ 'Número de Exits:' , sy-tfill.
else.
format color col_negative intensified on.
write:/(95) 'No existe ninguna user exit'.
endif.
else.
format color col_negative intensified on.
write:/(95) 'El código de transacción no existe'.
endif.

at line-selection.
get cursor field field1.
check field1(4) eq 'JTAB'.
set parameter id 'MON' field sy-lisel+1(10).
call transaction 'SMOD' and skip first screen.

20/06/2013 73 de 80
ABAP IV para funcionales.doc
Anexo III – Programa de búsqueda User-exit

Anexo III – Programa de búsqueda User-exit


Para buscar las user-exit’s utilizadas en un report, se puede ejecutar el siguiente código.

*&---------------------------------------------------------------------*
*& Report Z_USER_EXIT *
*& *
*&---------------------------------------------------------------------*

REPORT Z_USER_EXIT.

*======================================================================*
* PROGRAMA...: Z_VERIFICA_USER_EXIT
*----------------------------------------------------------------------*
* OBJETIVO...: REVISA USER-EXITS EN UNA DETERMINADA TRANSACCION O
* PROGRAMA. *
*----------------------------------------------------------------------*
* PARAMETROS.: P_PROG = NOMBRE DE PROGRAMA A SER REVISADO
* P_TCODE = NOMBRE DE TRANSACCION A SER REVISADA
* OBS.: UM DOS DOIS PARÂMETROS ACIMA DEVE SER ESPECIFICADO
*
* P_INCL = DETERMINA SI LA REVISION DEBE TENER EN
* CONSIDERACION LOS INCLUDES.
* P_FUNC = DETERMINA SI LA REVISION DEBE TENER EN
* CONSIDERACION LAS FUNCIONES.
* P_SUBMIT= DETERMINA SI LA REVISION DEBE TENER EN
* CONSIDERACION LOS DEMAS PROGRAMAS LLAMADOS
* POR SUBMIT.
*
* P_NIVEL = DETERMINA EL NIVEL DE LA REVISION HECHA DENTRO
* DE LOS INCLUDES, FUNCIONES Y DEMAS PROGRAMAS.
* EN EL NIVEL 1 SOLAMENTE SERA TOMADOS EN
* CONSIDERACION EN EL PROGRAMA RAIZ. EN EL NIVEL
* 2 SE REVISARAN LOS INCLUDES, FUNCIONES DENTRO
* LOS INCLUDES, FUNCIONES DEL NIVEL 1 Y ASI
* SUCESIVAMENTE.
*
* OBS.: EN EL PARAMETRO P_NIVEL INFORMAR VALORES BAJOS,
* YA QUE A MAYOR NUMERO, MAYOR CANTIDAD DE CODIGO
* SERA ANALIZADO
*----------------------------------------------------------------------*
*======================================================================*
*----------------------------------------------------------------------*
* CONSTANTS
*----------------------------------------------------------------------*
constants: c_user_exit(22) type c value 'USEREXIT',
c_enhance(22) type c value 'CALL CUSTOMER-FUNCTION',
c_funcao_1(13) type c value 'CALLFUNCTION''',
c_funcao_2(13) type c value 'CALL FUNCTION',
c_include(07) type c value 'INCLUDE',
c_submit(06) type c value 'SUBMIT',
c_comentario type c value '*',
c_ponto type c value '.',
c_aspa type c value '''',
c_x type c value 'X'.

data: begin of ti_programa occurs 0,


codigo_fonte like rssource-line,
end of ti_programa.

data: begin of ti_includes occurs 0,


nome like sy-repid,
nivel(2) type n,

20/06/2013 74 de 80
ABAP IV para funcionales.doc
Anexo III – Programa de búsqueda User-exit

end of ti_includes.
data: begin of ti_user_exit occurs 0,
programa like sy-repid,
linha(10) type n,
codigo_fonte like rssource-line,
nivel(2) type n,
end of ti_user_exit.

data: vg_caracter type c,


vg_palavra(50) type c,
vg_inicial like sy-index,
vg_conta_aspa type n,
vg_pname like tfdir-pname,
vg_texto(50) type c,
vg_contador like sy-tfill,
vg_nivel(2) type n,
vg_ini_contagem type c," INDICA QUE DEVE SER INICIADA A CONTADOR
vg_conta_espaco type n." TOTAL DE ESPACIOS ( MÁXIMO 2 )

selection-screen begin of block bl01 with frame title text-001 .


parameters: p_prog like sy-repid,
p_tcode like sy-tcode.
selection-screen end of block bl01.

selection-screen begin of block bl02 with frame title text-002.


parameters: p_incl as checkbox,
p_func as checkbox,
p_submit as checkbox,
p_nivel(2) type n.
selection-screen end of block bl02.

start-of-selection.
perform consisti_parametros.

perform inicializa_tabela.

perform verifica_include_funcao_submit.

perform procura_user_exit.

perform procura_enhancements.

perform exibe_user_exit.
end-of-selection.

form procura_user_exit.

loop at ti_includes.
refresh ti_programa.
read report ti_includes-nome into ti_programa.
loop at ti_programa.
search ti_programa-codigo_fonte for c_user_exit.
if sy-subrc eq 0
and ti_programa-codigo_fonte+0(1) ne c_comentario.
clear ti_user_exit.
shift ti_programa-codigo_fonte left deleting leading space.
move: ti_includes-nome to ti_user_exit-programa,
sy-tabix to ti_user_exit-linha,
ti_programa-codigo_fonte to ti_user_exit-codigo_fonte,
ti_includes-nivel to ti_user_exit-nivel.
append ti_user_exit.
endif.
endloop.
endloop.
endform.

20/06/2013 75 de 80
ABAP IV para funcionales.doc
Anexo III – Programa de búsqueda User-exit

form procura_enhancements.

loop at ti_includes.
refresh ti_programa.
read report ti_includes-nome into ti_programa.

loop at ti_programa.
search ti_programa-codigo_fonte for c_enhance.
if sy-subrc eq 0
and ti_programa-codigo_fonte+0(1) ne c_comentario.
clear ti_user_exit.
shift ti_programa-codigo_fonte left deleting leading space.
move: ti_includes-nome to ti_user_exit-programa,
sy-tabix to ti_user_exit-linha,
ti_programa-codigo_fonte to ti_user_exit-codigo_fonte,
ti_includes-nivel to ti_user_exit-nivel.
append ti_user_exit.
endif.
endloop.
endloop.
endform.

form exibe_user_exit.
perform cabecalho.
perform user_exit_nao_encontrada.
perform lista_user_exit_encontrada.
perform rodape.
endform." EXIBE_USER_EXIT

form procura_include.
clear vg_palavra.
search ti_programa-codigo_fonte for c_include.
if sy-subrc eq 0
and ti_programa-codigo_fonte+0(1) ne c_comentario.
do 72 times.
vg_inicial = sy-index - 1.
move ti_programa-codigo_fonte+vg_inicial(1) to vg_caracter.
if not vg_caracter is initial.
if vg_caracter eq c_ponto.
exit.
endif.
concatenate vg_palavra vg_caracter into vg_palavra.
translate vg_palavra to upper case.
if vg_palavra eq c_include.
clear vg_palavra.
endif.
endif.
enddo.
read table ti_includes with key nome = vg_palavra.
if not sy-subrc is initial.
if vg_nivel le p_nivel.
move: vg_palavra to ti_includes-nome,
vg_nivel to ti_includes-nivel.
append ti_includes.
endif.
endif.
endif.

endform.

20/06/2013 76 de 80
ABAP IV para funcionales.doc
Anexo III – Programa de búsqueda User-exit

form procura_funcao.

clear: vg_conta_aspa,
vg_palavra.

search ti_programa-codigo_fonte for c_funcao_2.


if sy-subrc eq 0
and ti_programa-codigo_fonte+0(1) ne c_comentario.
do 72 times.
vg_inicial = sy-index - 1.
move ti_programa-codigo_fonte+vg_inicial(1) to vg_caracter.
if not vg_caracter is initial.
if vg_caracter eq c_aspa.
add 1 to vg_conta_aspa.
if vg_conta_aspa eq 2.
exit.
endif.
endif.
concatenate vg_palavra vg_caracter into vg_palavra.
translate vg_palavra to upper case.
if vg_palavra eq c_funcao_1.
clear vg_palavra.
endif.
endif.
enddo.
clear vg_pname.
select single pname
into vg_pname
from tfdir
where funcname eq vg_palavra.
if sy-subrc eq 0.
read table ti_includes with key nome = vg_pname.
if not sy-subrc is initial.
if vg_nivel le p_nivel.
move: vg_pname to ti_includes-nome,
vg_nivel to ti_includes-nivel.
append ti_includes.
endif.
endif.
endif.
endif.
endform.

form verifica_include_funcao_submit.
loop at ti_includes.
add 1 to vg_contador.
describe table ti_includes.
perform evitar_time_out using sy-tfill.
move ti_includes-nivel to vg_nivel.
add 1 to vg_nivel.
refresh ti_programa.
read report ti_includes-nome into ti_programa.
loop at ti_programa.
if p_incl eq c_x.
perform procura_include.
endif.
if p_func eq c_x.
perform procura_funcao.
endif.
if p_submit eq c_x.
perform procura_submit.
endif.
endloop.
endloop.
endform.

20/06/2013 77 de 80
ABAP IV para funcionales.doc
Anexo III – Programa de búsqueda User-exit

form evitar_time_out using p_sy_tfill.

data: vl_total(10) type n,


vl_atual(10) type n.
move: p_sy_tfill to vl_total,
vg_contador to vl_atual.
concatenate 'Total:' vl_total '-' 'Atual:' vl_atual
into vg_texto
separated by space.

CALL FUNCTION 'SAPGUI_PROGRESS_INDICATOR'


EXPORTING
text = vg_texto.
endform.

form procura_submit.

clear: vg_conta_espaco, vg_palavra, vg_ini_contagem.

search ti_programa-codigo_fonte for c_submit.


if sy-subrc eq 0
and ti_programa-codigo_fonte+0(1) ne c_comentario.
do 72 times.
vg_inicial = sy-index - 1.
move ti_programa-codigo_fonte+vg_inicial(1) to vg_caracter.
if vg_ini_contagem eq c_x and vg_caracter is initial.
add 1 to vg_conta_espaco.
endif.

if not vg_caracter is initial.


move c_x to vg_ini_contagem.
if vg_caracter eq c_ponto.
exit.
endif.
if vg_conta_espaco lt 2.
concatenate vg_palavra vg_caracter into vg_palavra.
translate vg_palavra to upper case.
if vg_palavra eq c_submit.
clear vg_palavra.
endif.
else.
exit.
endif.
endif.
enddo.
read table ti_includes with key nome = vg_palavra.
if not sy-subrc is initial.
if vg_nivel le p_nivel.
move: vg_palavra to ti_includes-nome,
vg_nivel to ti_includes-nivel.
append ti_includes.
endif.
endif.
endif.

endform.

form consisti_parametros.
if p_nivel is initial.
move 1 to p_nivel.
endif.
if p_prog is initial and p_tcode is initial.
message id 'ZF' type 'I' number '000' with text-003.
stop.

20/06/2013 78 de 80
ABAP IV para funcionales.doc
Anexo III – Programa de búsqueda User-exit

endif.
if not p_prog is initial and not p_tcode is initial.
message id 'ZF' type 'I' number '000' with text-004.
stop.
endif.
endform.

form inicializa_tabela.
data vl_pgmna like tstc-pgmna.
refresh ti_includes.
if not p_prog is initial.
move: p_prog to ti_includes-nome,
'0' to ti_includes-nivel.
append ti_includes.
elseif not p_tcode is initial.
select single pgmna
from tstc
into vl_pgmna
where tcode eq p_tcode.
if sy-subrc eq 0.
move: vl_pgmna to ti_includes-nome,
'0' to ti_includes-nivel.
append ti_includes.
endif.
endif.
endform.

form cabecalho.
data vl_complemento(50) type c.
if p_tcode is initial.
concatenate 'NO PROGRAMA' p_prog
into vl_complemento
separated by space.
else.
concatenate 'EN LA TRANSACCION' p_tcode
into vl_complemento
separated by space.
endif.
format color col_key.
write: /001 sy-uline,
/001 sy-vline,
040 'RELACION DE USER-EXITS ENCONTRADAS', vl_complemento,
140 sy-vline,
/001 sy-uline.
write: /001 sy-vline,
003 'NOMBRE DEL PROGRAMA',
044 sy-vline,
046 'NIVEL',
052 sy-vline,
054 'LINEA',
065 sy-vline,
067 'TEXTO',
140 sy-vline,
/001 sy-uline.
endform.

form user_exit_nao_encontrada.
describe table ti_user_exit.
check sy-tfill is initial.
format color col_normal intensified on.

20/06/2013 79 de 80
ABAP IV para funcionales.doc
Anexo III – Programa de búsqueda User-exit

write: /003 'NINGUNA USER-EXIT FUE LOCALIZADA!',


139 ' '.
format reset.
endform.

form lista_user_exit_encontrada.
data vl_cor type c.
loop at ti_user_exit.
if vl_cor eq c_x.
clear vl_cor.
else.
move c_x to vl_cor.
endif.
if vl_cor eq c_x.
format color col_normal intensified on.
else.
format color col_normal intensified off.
endif.
write: /003 ti_user_exit-programa,
046 ti_user_exit-nivel,
054 ti_user_exit-linha,
067 ti_user_exit-codigo_fonte,
139 ' '.
endloop.
endform.

form rodape.
describe table ti_includes.
format color col_total.
write: /001 sy-uline,
/001 sy-vline,
003 'TOTAL DE PROGRAMAS ANALIZADOS:', sy-tfill,
' - NIVEL:', p_nivel,
140 sy-vline,
/001 sy-uline.
endform.

20/06/2013 80 de 80