Introducción
Aplicación de técnicas y conceptos básicos
Trabajar con clases locales
Lectura de datos de la base de datos
Trabajar con objetos de datos estructurados
Trabajar con tablas internas complejas
Implementación de actualizaciones de base de datos mediante business objects
Descripción del modelo de programación de aplicaciones ABAP RESTful

Trabajar con objetos de datos estructurados

Objectives

After completing this lesson, you will be able to:
  • Trabajar con objetos de datos estructurados.
  • Utilizar objetos de datos estructurados en ABAP SQL.

Objetos de datos estructurados

Para acceder a un componente de una estructura, debe colocar un signo menos (-) entre el nombre de la estructura y el nombre del componente.

Nota

No se permiten espacios en blanco antes o después del selector de componentes.

Al acceder a un componente de estructura de este modo, puede utilizarlo en cualquier posición de operando en la que pueda utilizar una variable del mismo tipo. El componente airport_from_id de la conexión de estructura en el ejemplo anterior es del tipo /DMO/AIRPORT_FROM_ID. En consecuencia, puede utilizar este componente en cualquier posición de operando en la que pueda utilizar una variable simple del tipo /DMO/AIRPORT_FROM_ID; no solo en la parte izquierda de una valoración como en el ejemplo, sino también en la parte derecha, en el paso de parámetros de una llamada de método, en la cláusula INTO o la cláusula WHERE de una sentencia SELECT, etc.

Si el componente de una estructura es en sí mismo una estructura, accederá a los subcomponentes utilizando de nuevo el selector de componentes después del nombre del componente principal. La primera valoración en el ejemplo accede al componente MSGTY de MESSAGE, que a su vez es un componente de la estructura anidada CONNECTION_NESTED.

Consejo

Puede utilizar la terminación de código para implementar el acceso a los componentes de estructura. Sitúe el cursor inmediatamente después del selector de componentes de estructura y pulse CTRL + ESPACIO para ver una lista de todos los componentes de estructura disponibles.

La expresión VALUE #( ) es una forma elegante de asignar valores a un objeto de datos estructurado.

Si desea rellenar toda una estructura, puede dirigirse a cada componente individualmente como ha visto en el ejemplo anterior.

Sin embargo, también puede utilizar una expresión VALUE #( ) para rellenar la estructura. La expresión construye una estructura, la rellena con valores y asigna la estructura rellenada a una variable, en este caso connection. El signo de almohadilla (#) indica al entorno de tiempo de ejecución ABAP que construya una estructura con el mismo tipo que la variable de destino connection. Entre paréntesis, enumere los componentes de la estructura que desea rellenar (no tiene que ser todos ellos) y asígneles un valor.

Cuando cumplimente una estructura de este modo, el sistema de tiempo de ejecución elimina todos los valores existentes de la estructura antes de la recarga con los valores de su expresión.

Nota

Una asignación en la forma connection = VALUE #( ). con solo un espacio en blanco entre paréntesis, rellena todos los componentes de la estructura con el valor inicial específico de tipo. Esto tiene el mismo efecto que la sentencia CLEAR connection.

En ABAP, solo puede copiar el contenido de una estructura directamente en otra estructura utilizando la notación <target structure> = <source structure> si los dos tipos de estructura son compatibles. Este normalmente solo es el caso si ambas estructuras tienen el mismo tipo. Si las estructuras tienen diferentes tipos, pueden suceder dos cosas:

  • Si una de las estructuras tiene un componente que no es de carácter en una posición en la que la otra estructura tiene un componente de carácter, la asignación directa provoca un error de sintaxis.
  • Si ambas estructuras son similares a caracteres o, en otras palabras, ambas estructuras constan solo de componentes similares a caracteres, la asignación directa es técnicamente posible. Pero por lo general, el resultado será incorrecto.

En el ejemplo, la estructura de origen y la estructura de destino son similares a caracteres. Por lo tanto, la asignación directa es técnicamente posible. Pero como no son compatibles, el resultado es incorrecto: El contenido del componente carrier_name se copia en el componente message en la estructura de destino.

Debido a que no hay ningún error de sintaxis, debe tener mucho cuidado al trabajar con estructuras de caracteres no compatibles.

Cuando copia datos entre estructuras, normalmente desea copiar información de un campo en el campo correspondiente de la estructura de destino - airport_from_id a airport_from_id, airport_to_id a airport_to_id, etc. Para lograr esto en ABAP, utilice la expresión CORRESPONDING. Esto asigna valores de <source_structure> a los componentes correspondientes, es decir, componentes con el mismo nombre de <target_structure>. Debe recordar los siguientes puntos:

  • Los campos deben tener nombres idénticos.
  • Los componentes no tienen que estar en la misma posición o secuencia en las dos estructuras.
  • Si los campos tienen diferentes tipos, ABAP intenta una conversión de tipo según el conjunto de reglas predefinido.

La expresión CORRESPONDING del ejemplo crea una estructura del tipo st_connection_nested. Los valores ​​de los componentes con el mismo nombre de la estructura connection se asignan a esta estructura. Todos los demás componentes siguen siendo iniciales. La estructura así construida se asigna a la estructura connection_nested. Esto asigna values​valores iniciales al componente message.

Pruébelo: acceso a objetos de datos estructurados

  1. Como en el primer ejercicio de este curso, cree una nueva clase global que implemente la interfaz IF_OO_ADT_CLASSRUN.
  2. Copie el siguiente fragmento de código en la parte de implementación del método if_oo_adt_classrun~main( ):
    Code Snippet
    12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
    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. TYPES: BEGIN OF st_connection_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_connection_nested. DATA connection TYPE st_connection. DATA connection_nested TYPE st_Connection_nested. * Example 1: Access to structure components ********************************************************************** connection-airport_from_id = 'ABC'. connection-airport_to_id = 'XYZ'. connection-carrier_name = 'My Airline'. "Access to sub-components of nested structure connection_nested-message-msgty = 'E'. connection_nested-message-msgid = 'ABC'. connection_nested-message-msgno = '123'. * Example 2: Filling a structure with VALUE #( ). ********************************************************************** CLEAR connection. connection = VALUE #( airport_from_id = 'ABC' airport_to_id = 'XYZ' carrier_name = 'My Airline' ). " Nested VALUE to fill nested structure connection_nested = VALUE #( airport_from_id = 'ABC' airport_to_id = 'XYZ' message = VALUE #( msgty = 'E' msgid = 'ABC' msgno = '123' ) carrier_name = 'My Airline' ). * Example 3: Wrong result after direct assignment ********************************************************************** connection_nested = connection. out->write( `-------------------------------------------------------------` ). out->write( `Example 3: Wrong Result after direct assignment` ). out->write( data = connection name = `Source Structure:`). out->write( |Component connection_nested-message-msgid: { connection_nested-message-msgid }| ). out->write( |Component connection_nested-carrier_name : { connection_nested-carrier_name }| ). * Example 4: Assigning Structures using CORRESPONDING #( ) ********************************************************************** CLEAR connection_nested. connection_nested = CORRESPONDING #( connection ). " out->write( `-------------------------------------------------------------` ). out->write( `Example 4: Correct Result after assignment with CORRESPONDING` ). out->write( data = connection name = `Source Structure:`). out->write( |Component connection_nested-message-msgid: { connection_nested-message-msgid }| ). out->write( |Component connection_nested-carrier_name : { connection_nested-carrier_name }| ).
  3. Pulse CTRL + F3 para activar la clase y F9 para ejecutar la aplicación de consola.
  4. Analice la salida de la consola. Depurar el programa, jugar con el código fuente para familiarizarse con los conceptos.

Objetos de datos estructurados en ABAP SQL

La cláusula INTO de la sentencia SELECT solo funcionará correctamente si el número y los tipos de los componentes de la estructura corresponden al número y los tipos de las columnas especificadas en la cláusula FIELDS. En el ejemplo anterior, la sentencia solo puede funcionar si la conexión de estructura de destino tiene tres componentes con el mismo tipo y longitud que las columnas DepartureAirport, DestinationAirport y \_Airline-Name enumeradas en la cláusula FIELDS. Tenga en cuenta que, en este caso, los nombres no tienen que ser idénticos; el sistema rellena la estructura de destino de izquierda a derecha.

Si la lista de campos en la cláusula FIELDS no coincide con la estructura o el tipo de línea de la tabla en la cláusula INTO, se producirá un error en tiempo de ejecución.

El ejemplo muestra una técnica fácil para garantizar que la estructura de destino coincida con la selección de campos:

  • La estructura de destino se tipifica con la vista CDS /DMO/I_Connection, que es la fuente de datos en la cláusula FROM.
  • El asterisco (*) después de la palabra clave FIELDS es una notación corta para asegurarse de que todos los campos de la vista forman parte de la selección de campos. Las asociaciones expuestas se ignoran.

Nota

Esta técnica también está disponible cuando lee directamente de una tabla de base de datos. Al igual que las definiciones de vista CDS, las definiciones de tabla de base de datos también pueden servir como tipos de estructura global en ABAP.

La principal ventaja de esta técnica es que la sentencia SELECT permanece intacta sintácticamente aunque usted u otra persona realice modificaciones en la vista CDS o en la tabla de base de datos. El inconveniente más importante es que siempre lee todos los campos de la base de datos, independientemente de si realmente los necesita o no.

Nota

Utilice esta técnica solo para vistas y tablas con un pequeño número de campos y si realmente necesita todos los campos. La lectura innecesaria de datos de la base de datos es una causa importante de problemas de rendimiento.

Otra forma de evitar errores de sintaxis es la variante INTO CORRESPONDING FIELDS. Esta variante tiene el mismo efecto que el operador CORRESPONDING #( ) que aprendió anteriormente. Garantiza que los datos se copien entre componentes con el mismo nombre. Al definir el tipo de estructura según sus necesidades, puede asegurarse de que solo se lean los datos necesarios.

Nuevamente, solo los nombres deben ser idénticos. Pero para evitar problemas, debe asegurarse de que los componentes con nombre idéntico tengan tipos compatibles. De lo contrario, el sistema intenta convertir el contenido del campo fuente en el tipo del campo destino. Esto puede provocar una pérdida de datos o errores (interceptables) en tiempo de ejecución.

Si los nombres de campo en la fuente de datos y los nombres de componente en la estructura de destino no coinciden, la combinación de FIELDS * e INTO CORRESPONDING FIELDS OF no funciona.

Si desea mantener la variante EN CAMPOS CORRESPONDIENTES DE, puede definir nombres alias para los campos seleccionados en la lista de campos. Para ello, añada AS después del nombre de campo, seguido del nombre alias. En el ejemplo, el nombre alias para el campo de vista DepartureAirport es airport_from_id y el nombre alias para la expresión de ruta \_Airline-Name es carrier_name. En función de estos nombres alias, INTO CORRESPONDING FIELDS OF identifica correctamente el componente de estructura en el que se almacenan los datos recuperados.

La técnica más simple para evitar conflictos entre la selección de campos y la estructura de destino es una declaración en línea en la cláusula INTO. La secuencia, el tipo y el nombre de la estructura declarada en línea se derivan de la cláusula FIELDS. Por lo tanto, la estructura de destino siempre se ajusta a la selección de campos.

Nota

Las declaraciones en línea solo se admiten después de INTO. No puede utilizar declaraciones en línea después de INTO CORRESPONDING FIELDS OF.

En el ejemplo, no hay ningún alias para el campo DepartureAirport. El nombre del campo se utiliza como nombre de componente en la estructura connection_inline. El campo DestinationAirportasí como la expresión de ruta \_Airline-Name tienen nombres alias opcionales (ArrivalAirport y AirlineName). Aquí los nombres alias se utilizan como nombres de componente.

Al trabajar con una base de datos relacional, a menudo se enfrenta al problema de que debe leer datos relacionados de diferentes tablas de base de datos. Ya hemos aprendido que las asociaciones en las vistas CDS son una forma elegante de realizar esta tarea.

Si no existe ninguna vista CDS con asociaciones adecuadas, puede implementar joins SQL en su lugar. El ejemplo anterior ilustra el principio de combinaciones:

Nos interesan las conexiones aéreas y los aeropuertos con los que se conectan entre sí. Los ID de 3 letras de los aeropuertos se encuentran en la tabla de base de datos /DMO/CONNECTION. Los nombres completos de los aeropuertos se almacenan en la tabla de base de datos /DMO/AIRPORT.

Para recuperar una conexión con el nombre del aeropuerto de salida, en una sentencia SELECT, leemos los datos de conexión de la tabla de BD /DMO/CONNECTION y los unimos con la tabla de BD /DMO/AIRPORT.

Un join consta de los siguientes módulos:

Fuentes de datos
Las tablas y vistas de base de datos para unir entre sí. Una única combinación siempre combina una fuente de datos de la izquierda con una fuente de datos de la derecha. En el ejemplo anterior, la tabla /DMO/CONNECTION es la fuente de datos de la izquierda y la tabla /DMO/AIRPORT la fuente de datos de la derecha. ABAP SQL también admite joins de joins (joins anidados)
Condición de enlace
La condición de conexión especifica qué registros de la fuente de datos de la derecha pertenecen a un registro de la fuente de datos de la izquierda. En el ejemplo anterior, el aeropuerto de salida relacionado se identifica con el valor de las columnas CLIENT y AIRPORT_ID. La condición de conexión dice:
/DMO/CONNECTION~CLIENT = /DMO/AIRPORT~CLIENT
AND
/DMO/CONNECTION~AIRPORT_FROM_ID = /DMO/AIRPORT~AIRPORT_ID
Tipo de unión
El tipo de conexión influye en el resultado si una de las fuentes de datos no contiene registros coincidentes. ABAP SQL actualmente admite INNER JOIN, LEFT OUTER JOIN, RIGHT OUTER JOIN y CROSS JOIN. El tipo de join más común es un LEFT OUTER JOIN.

La figura muestra la sintaxis ABAP SQL para un join. En la cláusula FROM, el tipo join se especifica con las palabras clave LEFT OUTER JOIN entre la fuente de datos izquierda /dmo/connection y la fuente de datos derecha /dmo/airport. La sintaxis introduce los nombres alias c y f para las fuentes de datos. Los nombres de alias para orígenes de datos son opcionales, a menos que un origen de datos aparezca más de una vez en la combinación.

La condición de conexión sigue a la palabra clave ON. El separador entre la fuente de datos o su alias y el campo es el signo de tilde (~).

Nota

En ABAP SQL, no es necesario mencionar los campos de cliente. La interfaz de la base de datos los añade a la condición de conexión antes de que la sentencia se envíe a la base de datos. Si la cláusula FROM define una unión, puede utilizar campos de ambas fuentes de datos en las cláusulas FIELDS y WHERE.

En este ejemplo, la sentencia SELECT no solo lee el nombre del aeropuerto de salida, sino también el nombre del aeropuerto de destino. Para ello, la cláusula FROM define una combinación anidada:

El primer join es un left outer join de las tablas /dmo/connection y /dmo/airport, introduciendo el alias "f" (como "from") para la fuente de datos de la derecha. Este primer join se utiliza como fuente de datos izquierda para un segundo join externo izquierdo que tiene la tabla /dmo/airport como fuente de datos derecha. Tenga en cuenta que en este caso el alias "t" (para "a") es crucial para distinguir esta apariencia de la tabla /dmo/aeropuerto de la anterior.

La cláusula FIELDS enumera los nombres de aeropuerto de ambas fuentes de datos, introduciendo alias airport_from_name y airport_to_name para distinguirlos entre sí.

Consejo

Los paréntesis alrededor de la primera combinación son opcionales. Si se omiten, las combinaciones en la cláusula from se evalúan de izquierda a derecha.

Pruébelo: Objetos de datos estructurados en ABAP SQL

  1. Como en el primer ejercicio de este curso, cree una nueva clase global que implemente la interfaz IF_OO_ADT_CLASSRUN.
  2. Copie el siguiente fragmento de código en la parte de implementación del método if_oo_adt_classrun~main( ):
    Code Snippet
    123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113
    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. TYPES: BEGIN OF st_connection_short, DepartureAirport TYPE /dmo/airport_from_id, DestinationAirport TYPE /dmo/airport_to_id, END OF st_connection_short. DATA connection TYPE st_connection. DATA connection_short TYPE st_connection_short. DATA connection_full TYPE /DMO/I_Connection. * Example 1: Correspondence between FIELDS and INTO ********************************************************************** SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport, DestinationAirport, \_Airline-Name WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO @connection. out->write( `------------------------------` ). out->write( `Example 1: Field List and INTO` ). out->write( connection ). * Example 2: FIELDS * ********************************************************************** SELECT SINGLE FROM /DMO/I_Connection FIELDS * WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO @connection_full. out->write( `----------------------------` ). out->write( `Example 2: FIELDS * and INTO` ). out->write( connection_full ). * Example 3: INTO CORRESPONDING FIELDS ********************************************************************** SELECT SINGLE FROM /DMO/I_Connection FIELDS * WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO CORRESPONDING FIELDS OF @connection_short. out->write( `----------------------------------------------------` ). out->write( `Example 3: FIELDS * and INTO CORRESPONDING FIELDS OF` ). out->write( connection_short ). * Example 4: Alias Names for Fields ********************************************************************** CLEAR connection. SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport AS airport_from_id, \_Airline-Name AS carrier_name WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO CORRESPONDING FIELDS OF @connection. out->write( `---------------------------------------------------` ). out->write( `Example 4: Aliases and INTO CORRESPONDING FIELDS OF` ). out->write( connection ). * Example 5: Inline Declaration ********************************************************************** SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport, DestinationAirport AS ArrivalAirport, \_Airline-Name AS carrier_name WHERE AirlineID = 'LH' AND ConnectionID = '0400' INTO @DATA(connection_inline). out->write( `-----------------------------------------` ). out->write( `Example 5: Aliases and Inline Declaration` ). out->write( connection_inline ). * Example 6: Joins ********************************************************************** SELECT SINGLE FROM ( /dmo/connection AS c LEFT OUTER JOIN /dmo/airport AS f ON c~airport_from_id = f~airport_id ) LEFT OUTER JOIN /dmo/airport AS t ON c~airport_to_id = t~airport_id FIELDS c~airport_from_id, c~airport_to_id, f~name AS airport_from_name, t~name AS airport_to_name WHERE c~carrier_id = 'LH' AND c~connection_id = '0400' INTO @DATA(connection_join). out->write( `------------------------------------------` ). out->write( `Example 6: Join of Connection and Airports` ). out->write( connection_join ).
  3. Pulse CTRL + F3 para activar la clase y F9 para ejecutar la aplicación de consola.
  4. Analice la salida de la consola. Depurar el programa, jugar con el código fuente para familiarizarse con los conceptos.

Utilizar un objeto de datos estructurado

En este ejercicio, declarará un atributo estructurado, lo rellenará mediante una sentencia SELECT y accederá a los componentes de estructura.

Modelo:

  • /LRN/CL_S4D400_DBS_CDS (clase global)

Solución:

  • /LRN/CL_S4D400_STS_STRUCTURE (clase global)

Tarea 1: Copiar plantilla

Copie la clase de modelo. Como alternativa, copie la solución del ejercicio anterior.

Pasos

  1. Copie la clase /LRN/CL_S4D400_DBS_CDS en una clase de su propio paquete (nombre sugerido: ZCL_##_STRUCTURE, donde ## representa su número de grupo).

    1. Abra el código fuente de la clase global /LRN/CL_S4D400_DBS_CDS.

    2. Vincule la vista Explorador de proyectos con el editor.

    3. En la vista Explorador de proyectos, haga clic con el botón derecho en la clase /LRN/CL_S4D400_DBS_CDS para abrir el menú contextual.

    4. En el menú contextual, seleccione Duplicar ....

    5. Introduzca el nombre del paquete en el campo Paquete. En el campo Nombre, introduzca el nombre ZCL_##_STRUCTURE, donde ## representa su número de grupo.

    6. Ajuste la descripción y seleccione Siguiente.

    7. Confirme la orden de transporte y seleccione Finalizar.

Tarea 2: Declarar un objeto de datos estructurado

En la clase local, declare los detalles de un atributo estructurado para sustituir los atributos escalares airport_from_id, airport_to_id y carrier_name. Comience definiendo un tipo de estructura privada st_details dentro de la clase local.

Pasos

  1. Cambie a la clase local lcl_connection.

    1. En la clase global, seleccione Tipos locales.

  2. Defina un tipo de estructura privadast_details con los siguientes componentes:

    Componentes del tipo de estructura st_details:

    Nombre de componenteTipo de datos
    Aeropuerto de salida/dmo/airport_from_id
    DestinationAirport/dmo/airport_to_id
    AirlineName/dmo/carrier_name
    1. Después de la línea PRIVATE SECTION., añada el siguiente código:

      Code Snippet
      12345678
      TYPES: BEGIN OF st_details, DepartureAirport TYPE /dmo/airport_from_id, DestinationAirport TYPE /dmo/airport_to_id, AirlineName TYPE /dmo/carrier_name, END OF st_details.
  3. Comente o elimine los atributos airport_from_id, airport_to_id y carrier_name.

    1. Seleccione las líneas con las tres sentencias DATA.

    2. Pulse Ctrl + < para añadir un signo de estrella (*) delante de cada línea seleccionada.

  4. Declare un nuevo detalle de atributo de instancia privado y escríbalo con el tipo de estructura st_details.

    1. Ajuste el código de la siguiente manera:

      Code Snippet
      123456789
      * DATA airport_from_id TYPE /dmo/airport_from_id. * DATA airport_to_id TYPE /dmo/airport_to_id. * * DATA carrier_name TYPE /dmo/carrier_name. DATA details TYPE st_details.

Tarea 3: Acceder a componentes de estructura

Utilice los componentes de los detalles de atributo estructurados en el método get_output.

Pasos

  1. Ajuste la implementación del método get_output. Sustituya cualquier acceso a los atributos airport_from_id, airport_to_id y carrier_name por el componente correspondiente de los detalles de atributo.

    Consejo

    No escriba los nombres de los componentes manualmente. Después de escribir el selector de componentes de estructura (-), pulse Ctrl + Espacio para obtener una lista de todos los componentes.
    1. Navegue a la implementación del método get_output.

    2. Ajuste las sentencias APPEND de la siguiente manera:

      Code Snippet
      12345678910111213
      * APPEND |--------------------------------| TO r_output. * APPEND |Carrier: { carrier_id } { carrier_name }| TO r_output. * APPEND |Connection: { connection_id }| TO r_output. * APPEND |Departure: { airport_from_id }| TO r_output. * APPEND |Destination: { airport_to_id }| TO r_output. APPEND |--------------------------------| TO r_output. APPEND |Carrier: { carrier_id } { details-airlinename }| TO r_output. APPEND |Connection: { connection_id }| TO r_output. APPEND |Departure: { details-departureairport }| TO r_output. APPEND |Destination: { details-destinationairport }| TO r_output.

Tarea 4: Rellenar el atributo estructurado en la sentencia SELECT

Utilice el atributo estructurado como destino de la sentencia SELECT en el método constructor.

Pasos

  1. Ajuste la sentencia SELECT en la implementación del método constructor. Sustituya la lista de objetos de datos en la cláusula INTO por los detalles de atributo estructurados.

    1. Navegue a la implementación del constructor de métodos.

    2. Ajuste la sentencia SELECT de la siguiente manera:

      Code Snippet
      123456789
      SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport, DestinationAirport, \_Airline-Name WHERE AirlineID = @i_carrier_id AND ConnectionID = @i_connection_id * INTO ( @airport_from_id, @airport_to_id, @carrier_name ). INTO @details.
  2. Opcional: Utilice la variante de sintaxis INTO CORRESPONDING FIELDS OF @details..

    1. En la sentencia SELECT, sustituya INTO @details.por el siguiente código:

      Code Snippet
      123
        INTO CORRESPONDING FIELDS OF @details.
    2. Añada el nombre alias AirlineName para la expresión de ruta.

    3. La sentencia SELECT ahora debería tener el siguiente aspecto:

      Code Snippet
      12345678
      SELECT SINGLE FROM /DMO/I_Connection FIELDS DepartureAirport, DestinationAirport, \_Airline-Name as AirlineName WHERE AirlineID = @i_carrier_id AND ConnectionID = @i_connection_id INTO CORRESPONDING FIELDS OF @details.
  3. Active la clase. Ejecútelo y analice la salida de la consola. Verifique que la salida muestre datos para todos los atributos.

    1. Pulse Ctrl + F3 para activar la clase.

    2. Pulse F9 para ejecutar la clase.