Abap en Español - Clase 001 - Declaración de Datos

ABAP (Advanced Business Application Programming) es un lenguaje de cuarta generación, propiedad de SAP, que se utiliza para programar la mayoría de sus productos (R/3, mySAP Business suite...). Utiliza sentencias de Open SQL para conectarse con prácticamente cualquier base de datos. Cuenta con miles de funciones para el manejo de archivos, bases de datos, fechas, etc. Permite conexiones RFC (Remote Function Calls) para conectar a los sistemas SAP con cualquier otro sistema o lenguaje de programación.

SAP suministra una instalación limitada de R/3 llamada MiniSAP para la práctica de la programación en ABAP.

HISTORIA

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

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

ABAP se mantuvo como el lenguaje de desarrollo para la siguiente versión cliente-servidor de SAP R/3, que fue lanzada al mercado en 1992, en el que casi todo el sistema, menos las llamadas al sistema básicas estaban escritas en ABAP. En 1999, con el lanzamiento de la versión 4.6 de R/3, SAP lanzó una extensión orientada a objetos denominada ABAP Objects. La versión más actual en estos momentos de SAP es la release 6.6.

La última plataforma de desarrollo de SAP, NetWeaver, soporta ABAP y Java como lenguajes de programación.

#

TRANSACCIONES

Una transacción en terminología SAP es la ejecución de un programa. La forma normal de ejecutar código ABAP en el sistema SAP es ingresando un código de transacción (por ejemplo, VA01 es el código de transacción para “Crear Órdenes de Venta”). Las Transacciones pueden ser llamadas a través de menús definidos por el sistema, especificados por el usuario o basados en roles. También pueden ser invocados mediante el ingreso del código de transacción directamente en el campo de comandos, el cual está presente en todas las pantallas SAP. Las transacciones también pueden ser invocadas por código mediante las sentencias ABAP “CALL TRANSACTION” y “LEAVE TO TRANSACTION”. El término “transacción” no debe ser mal interpretado, en el contexto aquí descrito una transacción simplemente significa el llamado a la ejecución de un programa. En otros contextos de programación, “transacción” se refiere a menudo a una operación indivisible sobre datos. Este último concepto también existe en SAP y es llamado LUW (Logical Unit of Work) . En el transcurso de una transacción (ejecución de un programa), puede haber diferentes LUWs.

ABAP es un lenguaje de programación lógicamente sobre la plataforma de SAP. Se recomienda instalar SAP ECC, en la modalidad de tres capas, server-presentation-database. La academia ABAP es muy recomendada para aquéllos que sean apasionados de la programación en SAP, ya que lo anteriormente comentando es sólo una pequeña parte de lo que puede abarcar el sistema SAP.

TIPOS DE PROGRAMAS ABAP

Como en otros lenguajes de programación, un programa ABAP no es simplemente una unidad ejecutable o una biblioteca, sino que proporciona código ejecutable para otros programas no ejecutado independientemente.

ABAP distingue entre dos tipos de programas:

• Informes
• Module pool

Los informes siguen un modelos de programación relativamente simple, donde el usuario introduce una serie de parámetros y el programa los usa para producir un informe en forma de lista interactiva. El término informe puede llevar a equívoco puesto que los informes pueden ser diseñados para modificar datos, la razón por la que estos programas se llaman informes es la “lista-orientada” que estos producen como salida.

Los module pools definen unos patrones más complejos de interacción con el usuario a través de una colección de pantallas. El término “pantalla” se refiere a la actualidad, la imagen física que los usuarios pueden ver. Cada pantalla también tienen un “flujo lógico”, el cual se refiere a código implícito de ABAP invocado por las pantallas. Cada pantalla tiene su propio flujo lógico, el cual se divide en “PBO”(Process Before Output) y PAI (Process after Input). En la documentación de SAP el término “dynpro” (programa dinámico) se refiere a la combinación entre las pantallas y el flujo lógico.

Los tipos de programas no ejecutables son:

• INCLUDE modules
• Subroutine pools
• Function groups
• Object clases
• Interfaces
• Type pools

Un Include module incluye en tiempo de generación en la unidad de llamada; Esto es usado en ocasiones para subdividir programas muy largos. Subroutine pools contienen subrutinas ABAP (bloques de código cerrados por FORM/ENDFORM e invocados por PERFORM). Las Functions groups son librerías de modulos de funciones(encerradas entre FUNCTION/ENDFUNCTION e invocadas por CALL FUNCTION). Los object clases e interfaces son similares a las clases e interfaces de java; las primeras definen una serie de métodos y atributos y las segundas contienen la definición de los métodos, para cada una de las clases implementadas se debe ofrecer el código de la misma. Las Type pools definen una colección de datos, tipos y constantes.

PLATAFORMA DE TRABAJO ABAP

La plataforma de trabajo de ABAP contiene diferentes herramientas para la edición de programas. La más importante son(Los códigos de transacción¹ aparecen entre paréntesis):

• Editor para escribir informes, module pools, includes y subroutine pools (SE38)
• Diccionario de base de datos para el procesamiento de las definiciones de tabla y recuperar tipos globales.(SE11)
• Menú Painter para el diseño de la interfaz de usuario (barras de menú, de aplicaciones, asignación de teclas)(SE41)
• Screen Painter para diseñar pantallas y flujos lógicos(SE51)
• Constructor de funciones para los módulos de funciones(SE37)
• Constructor de clases para las clases de objetos de ABAP e interfaces(SE24)

El navegador de objetos(SE80) proporciona una interfaz integrada simple para todas estas herramientas.

DICCIONARIO ABAP

El diccionario ABAP contiene todos los metadatos acerca del sistema SAP. Está muy ligado con la plataforma de trabajo de ABAP en el que cualquier referencia a los datos se obtiene del diccionario (por ejemplo, tablas, vistas, tipos de datos ) . Los desarrolladores usan el diccionario de transacciones de ABAP(directamente o a través del objeto navegador dentro de la plataforma de trabajo SE80) para mostrar y mantener los metadatos.

Cuando un objeto del diccionario es modificado, un programa que lo referencie automáticamente cambia su referencia al nuevo estado del objeto la próxima vez que se ejecute. Ya que ABAP es interpretado, no es necesario recompilar programas que referencien a objetos que se modifiquen dentro del diccionario

A continuación una breve descripción de los tipos de datos más importantes del diccionario:

• Tablas: son contenedores de datos que existen en la base de datos relacional subyacente. En la mayoría de los casos hay una relación 1 a 1 entre la definición de la tabla en el diccionario ABAp y la definición de la misma tabla en la base de datos(mismo nombre, mismas columnas…). Estas tablas se conocen como “transparentes”. Hay dos tipos de tablas no transparentes: “pooled”, que son las que existen como entidades independientes dentro del diccionario pero que se agrupan juntas en una largas tablas físicas (“pools”) a nivel de base de datos. Las tablas combinadas son normalmente pequeñas tablas que mantienen por ejemplo datos de configuración. Las tablas clustered están físicamente agrupadas en clusters, basados en claves primarias;.

• Índices, proporcionan accesos rápidos a los datos de las tablas para aquella selecciones usadas con mayor frecuencia. Todas las tablas de SAP tienen un índice primario, el cual se crea implícitamente a lo largo de que la tabla es usada forzando así que estos sean únicos, otros índices tienen que definirse y se llaman: “índices secundarios”
• Vistas: tienen el mismo propósito que en la base de datos subyacente: estas definen un subconjunto de columnas desde una o más tablas usando condiciones join. Una vista es una tabla virtual que no contiene ningún dato físicamente. Ocupan muy poco espacio puesto que solo contienen la definición del dato.
• Estructuras: son tipos de datos complejos que contienen varios campos(como los strutct en C/C++)
• Elementos de datos: proporcionan contenido semántico a una tabla o campo estructurado. Por ejemplo, una docena de tablas y estructuras pueden contener un campo que da un precio. Todos estos campos pueden tener el mismo elemento “PRECIO”.
• Dominios: definen las características estructurales de los elementos anteriormente mencionados. Por ejemplo, el elemento “precio” puede poseer un dominio que lo define como un campo numérico con dos decimales. Los dominios también pueden proporcionar contenido semántico proporcionando una posible lista de valores.
• Búsquedas de ayuda: proporciona una estrategia de búsqueda avanzada cuando un usuario quiere ver el posible valor que tiene un campo. El runtime de ABAP proporciona asistencia implícita pero dicha ayuda puede refinar esta funcionalidad
• Objetos bloqueados implementan bloqueos a nivel de aplicación cuando se modifican datos.

Sintaxis

Una breve descripción acerca de la sintaxis de ABAP comienza inevitablemente por el conocido “Hola mundo”

"Hola Mundo"

REPORT TEST.
WRITE 'Hola Mundo'.

Este ejemplo contiene dos declaraciones: REPORT y WRITE. El programa muestra una lista en pantalla. En este caso, la lista consiste en una simple línea donde pondrá “Hola Mundo”. La declaración REPORT indica que este programa es un informe. Alternativamente se podría usar PROGRAM para los ‘module pool’

Dando formato a las reglas

El formato básico de las reglas ABAP es simple:

• cada declaración ABAP debe terminar en un punto
• Los elementos dentro de cada declaración deben estar separados por lo menos por un espacio
• El final de línea es equivalente al espacio
• las declaraciones y palabras clave no distinguen entre mayúsculas y minúsculas

Para asegurar que un código sea legible, el editor de ABAP proporciona una pequeña función de edición, que se encarga de colocar correctamente el sangrado(identación). Esta también ofrece la posibilidad de escoger entre algunos modelos estandarizados acerca de las mayúsculas (por ejemplo todo mayúsculas, todo minúsculas, mayúsculas para declaraciones y palabras clave… etc).

Si un texto en una declaración ABAP ocupa más de una línea, podemos usar el carácter & para combinar la sucesión de las mismas como si fuera una sola.

USERPROMPT = 'Por favor doble clic en la lista de salida ' &



             'para ver la información completa de la transacción.'.

La regla de que los elementos deben estar separados al menos por un espacio, incluye también a los paréntesis, operadores y otros símbolos, por ejemplo el siguiente código seria incorrecto:

X=(A+B)-(C+2).

Los nombres de las variables (A,B,C,X) son constantes numéricas, los operadores "=", "+" y "-" y el paréntesis deben estar delimitados por un espacio en blanco. La forma correcta seria:

X = ( A + B ) - ( C + 2 ).

Declaraciones encadenadas

declaraciones consecutivas que posean una idéntica primera parte, se pueden combinar en una declaración “encadenada” usando el operador de cadenas “:”. La parte común de las declaraciones se escribe a la izquierda de los dos puntos y las diferentes a la derecha separadas por comas. El operador dos puntos está unido directamente con el elemento anterior, sin un espacio. El encadenamiento se usa normalmente con WRITE. Este acepta solo un argumento, con el operador dos puntos podremos encadenar por ejemplo 3 campos.

WRITE FLIGHTINFO-CITYFROM.


WRITE FLIGHTINFO-CITYTO.

WRITE FLIGHTINFO-AIRPTO.

Encadenar los campos hace que el código sea más legible y tenga una forma más intuitiva

WRITE: FLIGHTINFO-CITYFROM, FLIGHTINFO-CITYTO, FLIGHTINFO-AIRPTO.

En una declaración encadenada, la primera parte no se limita al nombre del comando sólo. Toda la parte común de las declaraciones se pueden colocar antes de los dos puntos. Por ejemplo:

REPLACE 'A' WITH 'B' INTO LASTNAME.


REPLACE 'A' WITH 'B' INTO FIRSTNAME.

REPLACE 'A' WITH 'B' INTO CITYNAME.

Se puede reescribir como:

REPLACE 'A' WITH 'B' INTO: LASTNAME, FIRSTNAME, CITYNAME.

Comentarios

ABAP posee dos formas de definir comentarios:

• Un asterisco a la izquierda de la línea hace que toda la línea sea un comentario
• Las doble comillas en cualquier lugar en una línea hace que el resto de la misma se convierta en un comentario

REPORT BOOKINGS.


* Leer libros de vuelo de la base de datos

SELECT * FROM FLIGHTINFO

  WHERE CLASS = 'Y'       "Y = precio



  OR    CLASS = 'C'.      "C = clase


(...)

Variables y tipos de datos

ABAP proporciona un conjunto de tipos de datos de serie. A demás, cada estructura, tabla, vista o elemento definido en el diccionario de ABAP puede ser usado como tipo de variable. También las interfaces y las clases de objetos.

Tipo	Descripción
I	Entero (4-bytes)
P	decimal
F	punto flotante
N	carácter numérico
C	carácter
D	fecha
T	tiempo
X	Hexadecimal (raw byte)
STRING	Cadena de caracteres
XSTRING	Variable-length raw byte array

Las variables y constantes del tipo D contienen un número de días desde el 1 de enero de año 1. Las variables de tipo T contienen el número de segundos desde media noche. Una característica especial de estos tipo es que se puede acceder a ellos como enteros y como cadenas de caracteres(poseen el formato interno “YYYYMMDD” pata los tipo fecha y “hhmmss” para las variables de tipo T) lo que hace que sea muy sencillo manejar fechas. Por ejemplo el código a continuación calcula el último día del mes anterior.

DATA LAST_EOM    TYPE D.  "Último día del pasado mes


* empezando desde hoy



  LAST_EOM = SY-DATUM.



* tomamos 6 de los 7 caracteres de YYYYMMDD como cadenas a "01",

* da el primer día del mes actual

  LAST_EOM+6(2) = '01'.



* restamos 1 día

  LAST_EOM = LAST_EOM - 1.



  WRITE: 'el último día del mes anterior fue', LAST_EOM.

Todas las variables en ABAP tienen que declararse explícitamente para que puedan usarse. Normalmente todas las declaraciones se colocan en la parte superior del código antes de la primera sentencia de ejecución; este lugar es por convención no una regla de sintaxis. La declaración consiste en el nombre, tipo, longitud(cuando corresponda), modificadores adicionales (como número de decimales) y el valor inicial de la variable:

DATA: COUNTER      TYPE I,



      VALIDITY     TYPE I VALUE 60,



      TAXRATE(3)   TYPE P DECIMALS 1,



      LASTNAME(20) TYPE C,



      DESCRIPTION  TYPE STRING.


* Tipo del diccionario:



DATA: ORIGIN       TYPE COUNTRY.

* Tablas internas:



DATA: T_FLIGHTS    TYPE TABLE OF FLIGHTINFO,

      T_LOOKUP     TYPE HASHED TABLE OF FLT_LOOKUP.


* Objetos:



DATA: BOOKING      TYPE REF TO CL_FLT_BOOKING.

Recuerde usar los dos puntos para encadenar sentencias.

Actualmente es muy complicado encontrar información sobre programación en Abap, por ello unos amigos de LIMA - PERU han tomado la iniciativa de compartir sus conocimientos, he creado el Blog para centralizar la información que he encontrado en la WEB incluyendo lo videos, sin mas les coloco la primera clase.

 Video Tutoria: Clase 001 - Declaración de Datos

Aprenderemos a declarar Datos, e iniciaremos con el popular Hola Mundo.

Ir a la Clase 002 - Tablas internas Part. 1 

La declaración de datos debe ser la primera parte de todo report que escribamos en ABAP. A continuación  describiré cómo declarar variables, constantes, tablas internas… y en general, diferentes estructuras de datos globales que serán utilizadas en tiempo de ejecución del programa.

Tablas de diccionario

En primer lugar debemos declarar las tablas de diccionario. Serán aquellas tablas de las que vamos a extraer información y que vamos a utilizar posteriormente. La sentencia que utilizamos para ello es la sentencia tables.

Ejemplo de la sentencia tables:

***********************************************************************
Tablas
***********************************************************************

TABLES:  
  sflight,
  saplane,
  scarr.

En este ejemplo declaramos tres tablas del diccionario (sflight, saplane y scarr) a través de la sentencia tables. En ABAP una sentencia seguida por dos puntos (:) sirve para enumerar una serie de componentes y éstos siempre deben estar separados por coma. Finalmente todas las sentencias ABAP acaban en punto (.).

Además podéis ver que hemos añadido un título con asteriscos (*). Todo literal que vaya precedido por un asterisco en ABAP será interpretado como un simple comentario para que el programador entienda lo que sigue a continuación. Son muy útiles para que otros programadores que “lean” vuestro programa entiendan mejor lo que habéis escrito. En este caso sirve para estructurar mejor el report.

Variables globales

Son aquellas variables visibles desde cualquier punto del programa y que contienen un único dato. Se declaran mediante la sentencia data seguida del tipo de dato.

Ejemplo:

************************************************************************
*Variables globales
************************************************************************

DATA:  
  g_vuelo(4) TYPE n,               "Número de vuelo
  g_fecha    TYPE s_date,          "Fecha del vuelo
  g_precio   LIKE sflight-price.   "Precio del vuelo

Podemos declarar estos objetos de datos de distintas formas:

• A través del tipo de datos predefinido en ABAP (caso de la variable g_vuelo). Utilizamos type para definir el tipo. Los tipos ABAP predefinidos más comunes que podemos encontrar son:
  • c: carácter o alfanumérico.
  • d: fecha. ABAP los guarda internamente como AAAAMMDD, es decir, cuatro dígitos para el año, dos dígitos para el mes y dos dígitos para el día.
  • t: para la hora.
  • i: para números enteros.
  • n: para variables que contendrán textos exclusivamente numéricos.
  • f: numéricos con coma flotante.
  • p: numéricos empaquetados.
• A través de un elemento de datos que ya exista en el diccionario ABAP (caso de la variable g_fecha). También utilizamos type para definir el tipo de dato.
• A través de un campo que ya exista en una tabla de diccionario (caso de la variable g_precio). No utilizamos type sino like.  SAP entenderá la variable como el dato que se contiene en ese campo del diccionario.

En el ejemplo también hemos introducio otro concepto, el de las comillas (“). Escribir unas comillas después de cualquier sentencia ABAP indica a SAP que lo que sigue a continuación es un simple comentario que puede ser leído pero no se tiene en consideración a la hora de ejecutar el programa. Son muy importantes, al igual que los asteriscos, para introducir comentarios útiles que ayuden a entender mejor el programa.

Constantes

Al contrario que una variable, las constantes que se declaran al principio del programa nunca podrán modificar su valor durante la ejecución del programa. En un programa se utilizan para evitar escribir valores literales. La sentencia utilizada es la sentencia constants.

Ejemplo de la sentencia constants:

************************************************************************
*Constantes
************************************************************************

CONSTANTS:  
  c_vuelo(5) TYPE c VALUE 'Vuelo',
  c_fecha    TYPE d VALUE '20121231'.

En este caso vemos que la declaración de constantes y variables es igual, la diferencia radica en la cláusula value. Así dotamos de contenido a nuestra constante durante toda la ejecución del programa. No intentéis asignar nunca un valor a una constante durante la ejecución del programa (hacedlo sólo en la declaración de la constante) ya que ABAP no lo va a aceptar.

Estructuras

Son matrices de datos unidimensionales. En palabras sencillas, una estructura es un encadenamiento de variables. En lugar de declarar, diferentes variables por separado, una estructura es una declaración de variables o campos conjunta.

Ejemplo:

************************************************************************
*Estructuras
************************************************************************

DATA:  
  BEGIN OF e_aerolinea,
    carrid    LIKE scarr-carrid,      "Código de aerolinea
    carname   TYPE s_carrname,        "Nombre de aerolínea   
    url(255)  TYPE c,
  END OF e_aerolinea.

El ejemplo declara una estructura de tres campos (carrid, carname y url) juntos. Para declarar una estructura utilizamos la sentencia data, luego abrimos la estructura con la cláusula begin of nombre_de_la_estructura. Una vez declarados los campos cerramos la sentencia con la claúsula end of nombre_de_la_estructura.

Tablas internas

Para acabar (por el momento) tenemos las tablas internas. Sirven básicamente para almacenar la información que extraemos de las tablas de la base de datos. Una tabla interna es también una matriz de datos, pero bidimensional. Al contrario que las estructuras que sólo pueden contener un valor para cada campo, las tablas internas contendrán muchos registros. Cada registro llevará un valor diferente en el mismo campo a la manera que tiene una tabla transparente de diccionario.

Podemos declarar tablas internas de diferentes maneras:

Ejemplo de declaración de tablas internas:

************************************************************************
*Tablas internas
************************************************************************
* Tabla de vuelos: primera forma de declaración de tablas internas

DATA:
  BEGIN OF i_vuelos occurs 0,
    carrid    LIKE sflight-carrid,
    connid    LIKE sflight-connid,
    fldate    LIKE sflight-fldate,
    planetype LIKE sflight-planetype,
  END OF i_vuelos.

* Tabla de aviones: segunda forma de declaración de tablas internas

TYPES:
  BEGIN OF ty_aviones,
    planetype  LIKE saplane-planetype,
    seatsmax   LIKE saplane-seatsmax,
  END OF ty_aviones.

DATA:
  i_aviones TYPE STANDARD TABLE OF ty_aviones.

• La primera forma de declarar una tabla interna es muy parecida a la declaración de estructuras, pero añadiendo la cláusula occurs 0. Al declarar una tabla interna de este modo también estamos diciendo a SAP que nuestra tabla interna tendrá una cabecera.
• La segunda forma se realiza mediante sentencia types, que permite la declaración de tipos de datos. Esta segunda forma parece más complicada y más larga, pero es preferible utilizarla ya que la primera no es útil en ciertos entornos ABAP como en programación de queries, smartforms o ABAP orientado a objetos. Al declarar una tabla interna de este modo también estamos diciendo a SAP que nuestra tabla interna tendrá una cabecera. En otro artículo veremos qué implicaciones tiene esto.
  
  

Resumen de sentencias

• Tables.
• Data.
• Constants.
• Data: begin of   nombre_estructura     … end of nombre_estructura.
• Data: begin of   nombre_tabla_interna … end of nombre_tabla_interna.
• Types: begin of nombre_tipo              … end of nombre_tipo.

Por supuesto, existen más tipos de datos y objetos de datos en SAP. Sin embargo, para un tutorial básico ABAP como es éste y para empezar a aprender a programar conocer estos tipos es más que suficiente.

Ir a la Clase 002 - Tablas internas Part. 1  

Saludos amigos.