Objective
After completing this lesson, you will be able to declare un objeto de datos estructurado.
Objetos de datos estructurados
Hasta ahora, ha estado utilizando variables simples, cada una de las cuales puede almacenar una única información. Aquí, por ejemplo, hay dos variables, una para el aeropuerto de salida y otra para el aeropuerto de llegada.
Cuando lee un registro de la base de datos, debe mantener toda esta información junta. Las dos variables del ejemplo son completamente independientes entre sí y, por lo tanto, no son adecuadas para almacenar diferentes partes de la información que van juntas.
En ABAP, la solución es utilizar una variable estructurada, o una estructura, para abreviar.
Una estructura es un objeto de datos ABAP variable con un nombre y un tipo estructurado.
En el ejemplo, el objeto de datos connection_full es una estructura de este tipo. Se subdivide en ocho componentes, cada uno de los cuales también tiene un nombre y un tipo. Puede tratar las dos estructuras como un conjunto y los componentes individuales. Es importante destacar que puede utilizar cada componente exactamente de la misma manera que utilizaría una variable simple independiente.
Existen varias posibilidades para declarar una estructura. Puede definir tipos estructurados con la palabra clave TYPES o utilizar un objeto de repository del tipo Estructura. Las definiciones de vistas y tablas de base de datos también pueden servir como tipos estructurados. El ejemplo utiliza la vista CDS /DMO/I_Connection como un tipo estructurado.
En la perspectiva Debugger, hay dos formas de analizar la estructura y el contenido de una variable estructurada:
- Vista previa de variable (paso de ratón)
Establezca el enfoque en el editor de código fuente y coloque el puntero en un nombre de variable. Después de un momento se abre una ventana de diálogo con detalles sobre la estructura y el contenido del objeto de datos.
- Visualizar en la vista de variables (doble clic)
Para visualizar la variable en la vista Variables, introduzca el nombre de variable en <Introducir variable> o haga doble clic en el nombre de variable en algún lugar del editor de código fuente. Expanda el nodo con el nombre de estructura para ver la lista de componentes.
Cómo analizar objetos de datos estructurados mediante la perspectiva de depuración
Tipos de datos estructurados
Un tipo de estructura global es un objeto de repository que se puede utilizar como tipo de datos en cualquier lugar del sistema. En el ejemplo, el tipo estructurado SYMSG se utiliza para declarar un mensaje variable.
Al pulsar la tecla F2 para visualizar los detalles de este tipo de datos, puede ver que se trata de un tipo de estructura que consta de siete componentes. También puede ver los nombres, los tipos técnicos y las descripciones de los componentes.
Al pulsar la tecla F3 para navegar a la definición del tipo, se abre una nueva vista con el editor ADT para tipos estructurados globales.
La definición de un tipo de estructura global es muy similar a la definición de una tabla de base de datos. La parte principal de la definición consiste en una sentencia DEFINE STRUCTURE con el nombre del tipo de estructura. Le sigue la lista de componentes de estructura entre corchetes ( { , } ); cada componente con un tipo de componente. Los tipos de componente a menudo se describen mediante elementos de datos, pero también es posible utilizar tipos de estructura como tipos de componente. Las estructuras con componentes estructurados se denominan Estructuras anidadas.
Las líneas de código adicionales antes de la sentencia DEFINE STRUCTURE especifican propiedades adicionales del tipo de estructura, entre ellas una etiqueta.
También puede definir tipos estructurados en un programa ABAP mediante la sentencia TYPES. La definición de estructura comienza con la sentencia TYPES BEGIN OF <nombre de tipo de estructura> y termina con TYPES END OF <nombre de tipo de estructura>. Entre tanto, debe nombrar cada componente y especificar su tipo en una sentencia TYPES adicional.
Una forma compacta utiliza la palabra clave TYPES solo una vez, seguida de dos puntos ( :). El suplemento BEGIN OF, el suplemento END OF y las definiciones de componente intermedias se separan con comas.
Esto se conoce como sentencia de cadena.
Nota
En el pasado, las sentencias en cadena se utilizaban mucho en ABAP. Hoy en día solo se les recomienda combinar declaraciones que estén estrechamente relacionadas.
En este ejemplo, una sentencia de cadena TYPES: se utiliza para definir el tipo estructurado local st_connection que consta de los tres componentes airport_from_id, airport_to_id y carrier_name. Cada componente se tipifica con un elemento de datos que empieza por /dmo/.
El tipo estructurado local st_connection se utiliza en una sentencia DATA para tipificar conexión variable estructurada.
En este ejemplo, la variable connection tiene un tipo estructurado anidado. El tipo st_nested define 4 componentes. Tres se tipifican con elementos de datos, por lo tanto, son componentes simples. Sin embargo, el componente message se tipifica con un tipo estructurado. Por lo tanto, es un componente estructurado. Esto hace que la variable connection una estructura anidada.
ABAP no solo admite variables estructuradas, sino también constantes estructuradas. Para definir una constante estructurada, utilice BEGIN OF y END OF como parte de una sentencia CONSTANTS. El ejemplo muestra una constante estructurada que se define en la sección pública de la clase global CL_ABAP_BEHV. Los cinco componentes están tipificados con el elemento de datos SECKEYNAME. Recuerde que el suplemento VALUE es obligatorio al definir constantes.
Pruébelo: Tipos de datos estructurados
- Como en el primer ejercicio de este curso, cree una nueva clase global que implemente la interfaz IF_OO_ADT_CLASSRUN.
- Copie el siguiente fragmento de código en la parte de implementación del método if_oo_adt_classrun~main( ):
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
* Example 1 : Motivation for Structured Variables
**********************************************************************
DATA connection_full TYPE /DMO/I_Connection.
SELECT SINGLE
FROM /dmo/I_Connection
FIELDS AirlineID, ConnectionID, DepartureAirport, DestinationAirport,
DepartureTime, ArrivalTime, Distance, DistanceUnit
WHERE AirlineId = 'LH'
AND ConnectionId = '0400'
INTO @connection_full.
out->write( `--------------------------------------` ).
out->write( `Example 1: CDS View as Structured Type` ).
out->write( connection_full ).
* Example 2: Global Structured Type
**********************************************************************
DATA message TYPE symsg.
out->write( `---------------------------------` ).
out->write( `Example 2: Global Structured Type` ).
out->write( message ).
* Example 3 : Local Structured Type
**********************************************************************
TYPES: BEGIN OF st_connection,
airport_from_id TYPE /dmo/airport_from_id,
airport_to_id TYPE /dmo/airport_to_id,
carrier_name TYPE /dmo/carrier_name,
END OF st_connection.
DATA connection TYPE st_connection.
SELECT SINGLE
FROM /DMO/I_Connection
FIELDS DepartureAirport, DestinationAirport, \_Airline-Name
WHERE AirlineID = 'LH'
AND ConnectionID = '0400'
INTO @connection.
out->write( `---------------------------------------` ).
out->write( `Example 3: Local Structured Type` ).
out->write( connection ).
* Example 4 : Nested Structured Type
**********************************************************************
TYPES: BEGIN OF st_nested,
airport_from_id TYPE /dmo/airport_from_id,
airport_to_id TYPE /dmo/airport_to_id,
message TYPE symsg,
carrier_name TYPE /dmo/carrier_name,
END OF st_nested.
DATA connection_nested TYPE st_nested.
out->write( `---------------------------------` ).
out->write( `Example 4: Nested Structured Type` ).
out->write( connection_nested ).
- Pulse CTRL + F3 para activar la clase y F9 para ejecutar la aplicación de consola.
- Analice la salida de la consola. Depurar el programa, jugar con el código fuente para familiarizarse con los conceptos.