Introduction
Application des techniques et concepts de base
Utilisation des classes locales
Lecture des données de la base de données
Utilisation d'objets de données structurés
Utilisation de tables internes complexes
Implémentation de mises à jour de base de données à l'aide d'objets de gestion
Description du modèle de programmation d'applications ABAP RESTful

Utilisation d'objets de données structurés

Objectives

After completing this lesson, you will be able to:
  • Utiliser des objets de données structurés.
  • Utilisez des objets de données structurés dans ABAP SQL.

Objets de données structurés

Pour accéder à un composant d'une structure, vous devez placer un signe moins (-) entre le nom de la structure et le nom du composant.

Remarque

Aucun espace n'est autorisé avant ou après le sélecteur de composants.

En accédant ainsi à un composant de structure, vous pouvez l'utiliser à n'importe quelle position d'opérande dans laquelle vous pouvez utiliser une variable du même type. La composante airport_from_id de la connexion de structure dans l'exemple ci-dessus est de type /DMO/AIRPORT_FROM_ID. Par conséquent, vous pouvez utiliser ce composant à n'importe quelle position d'opérande dans laquelle vous pouvez utiliser une variable simple de type /DMO/AIRPORT_FROM_ID ; non seulement à gauche d'une valorisation comme dans l'exemple, mais également à droite, dans le transfert de paramètres d'un appel de méthode, dans la clause INTO ou la clause WHERE d'une instruction SELECT, etc.

Si le composant d'une structure est lui-même une structure, vous accédez aux sous-composants en utilisant à nouveau le sélecteur de composant après le nom du composant principal. La première valorisation de l'exemple accède au composant MSGTY de MESSAGE, qui est lui-même un composant de la structure imbriquée CONNECTION_NESTED.

Astuce

Vous pouvez utiliser la saisie semi-automatique du code pour implémenter l'accès aux composants de structure. Positionnez le curseur immédiatement après le sélecteur de composants de structure et appuyez sur CTRL + ESPACE pour afficher la liste de tous les composants de structure disponibles.

L'expression VALUE #( ) est un moyen élégant d'affecter des valeurs à un objet de données structuré.

Si vous voulez renseigner une structure entière, vous pouvez adresser chaque composant individuellement comme vous l'avez vu dans l'exemple précédent.

Cependant, vous pouvez également utiliser une expression VALUE #( ) pour remplir la structure. L'expression construit une structure, la renseigne avec des valeurs et affecte la structure renseignée à une variable, dans ce cas connection. Le symbole dièse (#) indique à l'environnement d'exécution ABAP de construire une structure du même type que la variable cible connection. Dans les parenthèses, vous répertoriez les composants de la structure que vous voulez renseigner (il n'est pas nécessaire qu'ils soient tous) et leur affectez une valeur.

Lorsque vous renseignez une structure de cette manière, le système d'exécution supprime toutes les valeurs existantes de la structure avant de la renseigner avec les valeurs de votre expression.

Remarque

Une affectation sous la forme connection = VALUE #( ). avec un espace entre les parenthèses renseigne tous les composants de la structure avec la valeur initiale spécifique au type. Cela a le même effet que l'instruction CLEAR connection.

En ABAP, vous pouvez uniquement copier le contenu d'une structure directement dans une autre structure à l'aide de la notation <target structure> = <source structure> si les deux types de structure sont compatibles. Ce n'est généralement le cas que si les deux structures ont le même type. Si les structures ont des types différents, deux choses peuvent se produire :

  • Si l'une des structures a un composant autre qu'un caractère à une position où l'autre structure a un composant de type caractère, l'affectation directe entraîne une erreur de syntaxe.
  • Si les deux structures correspondent à des caractères ou, en d'autres termes, si les deux structures sont constituées uniquement de composants de type caractère, l'affectation directe est techniquement possible. Mais généralement, le résultat sera faux.

Dans l'exemple, la structure source et la structure cible sont des caractères. Par conséquent, l'affectation directe est techniquement possible. Mais comme elles ne sont pas compatibles, le résultat est erroné : le contenu du composant carrier_name est copié dans le composant message dans la structure cible.

Comme il n'y a pas d'erreur de syntaxe, vous devez être très prudent lorsque vous travaillez avec des structures de type caractères non compatibles.

Lorsque vous copiez des données entre des structures, vous voulez généralement copier des informations d'une zone dans la zone correspondante de la structure cible - airport_from_id vers airport_from_id, airport_to_id vers airport_to_id, etc. Pour ce faire, utilisez l'expression CORRESPONDING dans ABAP. Cela affecte les valeurs de <source_structure> aux composants correspondants, c'est-à-dire aux composants de nom identique de <target_structure>. Vous devez vous souvenir des points suivants :

  • Les zones doivent avoir des noms identiques.
  • Les composants ne doivent pas nécessairement avoir la même position ou séquence dans les deux structures.
  • Si les zones ont des types différents, ABAP tente une conversion de type en fonction de l'ensemble de règles prédéfini.

L'expression CORRESPONDING dans l'exemple crée une structure de type st_connection_nested. Les valeurs ​​des composants portant le même nom provenant de la structure connection sont ensuite affectées à cette structure. Toutes les autres composantes restent initiales. La structure ainsi construite est ensuite affectée à la structure connection_nested. Cela affecte des valeurs initiales ​​à la composante message.

Essayer : accès aux objets de données structurés

  1. Comme dans le premier exercice de ce cours, créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN.
  2. Copiez l'extrait de code suivant dans la partie implémentation de la méthode 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. Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour exécuter l'application console.
  4. Analysez la sortie de la console. Déboguer le programme, jouer avec le code source pour se familiariser avec les concepts.

Objets de données structurés dans ABAP SQL

La clause INTO de l'instruction SELECT ne fonctionnera correctement que si le nombre et les types des composants de la structure correspondent au nombre et aux types des colonnes spécifiées dans la clause FIELDS. Dans l'exemple ci-dessus, l'instruction ne peut fonctionner que si la connexion de la structure cible comporte trois composants avec le même type et la même longueur que les colonnes DepartureAirport, DestinationAirport et \_Airline-Name répertoriées dans la clause FIELDS. Notez que, dans ce cas, les noms ne doivent pas nécessairement être identiques - le système renseigne la structure cible de gauche à droite.

Si la liste de zones dans la clause FIELDS ne correspond pas à la structure ou au type de ligne de table dans la clause INTO, une erreur d'exécution se produit.

L'exemple illustre une technique simple pour s'assurer que la structure cible correspond à la sélection de zones :

  • La structure cible est catégorisée avec la vue CDS /DMO/I_Connection, qui est la source de données dans la clause FROM.
  • L'astérisque (*) après le mot-clé FIELDS est une notation courte pour s'assurer que toutes les zones de la vue font partie de la sélection de zones. Les associations exposées sont ignorées.

Remarque

Cette technique est également disponible lorsque vous lisez directement à partir d'une table de base de données. Tout comme les définitions de vues CDS, les définitions de table de base de données peuvent également servir de types de structure globaux dans ABAP.

Le principal avantage de cette technique est que l'instruction SELECT reste syntaxiquement intacte même si vous ou quelqu'un d'autre apportez des modifications à la vue CDS ou à la table de base de données. L'inconvénient le plus important est que vous lisez toujours toutes les zones de la base de données, que vous en ayez réellement besoin ou non.

Remarque

Utilisez cette technique uniquement pour les vues et les tables avec un petit nombre de zones et si vous avez réellement besoin de toutes les zones. La lecture inutile des données à partir de la base de données est une cause majeure de problèmes de performance.

Une autre façon d'éviter les erreurs de syntaxe est la variante INTO CORRESPONDING FIELDS. Cette variante a le même effet que l'opérateur CORRESPONDING #( ) que vous avez appris précédemment. Cela garantit que les données sont copiées entre des composants portant le même nom. En définissant le type de structure en fonction de vos besoins, vous pouvez vous assurer que seules les données requises sont lues.

Encore une fois, seuls les noms doivent être identiques. Mais pour éviter les problèmes, vous devez vous assurer que les composants de même nom ont des types compatibles. Sinon, le système tente de convertir le contenu de la zone source dans le type de la zone cible. Cela peut entraîner une perte de données ou des erreurs d'exécution (pouvant être interceptées).

Si les noms de zones dans la source de données et les noms de composants dans la structure cible ne correspondent pas, la combinaison de FIELDS * et INTO CORRESPONDING FIELDS OF ne fonctionne pas.

Si vous voulez conserver la variante INTO CORRESPONDING FIELDS OF, vous pouvez définir des noms d'alias pour les zones sélectionnées dans la liste de zones. Pour ce faire, ajoutez AS après le nom de zone, suivi du nom d'alias. Dans l'exemple, le nom d'alias pour le champ de vue DepartureAirport est airport_from_id et le nom d'alias pour l'expression de chemin \_Airline-Name est carrier_name. Sur la base de ces noms d'alias, INTO CORRESPONDING FIELDS OF identifie correctement le composant de structure dans lequel stocker les données récupérées.

La technique la plus simple pour éviter les conflits entre la sélection de zones et la structure cible est une déclaration en ligne dans la clause INTO. La séquence, le type et le nom de la structure déclarée en ligne sont dérivés de la clause FIELDS. Par conséquent, la structure cible correspond toujours à la sélection de zones.

Remarque

Les déclarations en ligne sont uniquement prises en charge après INTO. Vous ne pouvez pas utiliser de déclarations en ligne après INTO CORRESPONDING FIELDS OF.

Dans l'exemple, il n'existe aucun alias pour la zone DepartureAirport. Le nom de la zone est utilisé comme nom de composant dans la structure connection_inline. La zone DestinationAirportainsi que l'expression de chemin \_Airline-Name ont des noms d'alias facultatifs (ArrivalAirport et AirlineName). Ici, les noms d'alias sont utilisés comme noms de composants.

Lorsque vous utilisez une base de données relationnelle, vous rencontrez souvent le problème de lecture des données liées à partir de différentes tables de base de données. Nous avons déjà appris que les associations dans les vues CDS sont un moyen élégant d'effectuer cette tâche.

S'il n'existe aucune vue CDS avec des associations appropriées, vous pouvez implémenter des jointures SQL à la place. L'exemple ci-dessus illustre le principe des jointures :

Nous sommes intéressés par les liaisons aériennes et les aéroports qu'ils relient les uns aux autres. Nous trouvons les ID à 3 lettres des aéroports dans la table de base de données /DMO/CONNECTION. Les noms complets des aéroports sont archivés dans la table de base de données /DMO/AIRPORT.

Pour récupérer une connexion avec le nom de l'aéroport de départ, dans une instruction SELECT, nous lisons les données de connexion de la table de base de données /DMO/CONNECTION et les joignons à la table de base de données /DMO/AIRPORT.

Une jointure se compose des modules suivants :

Sources de données
Les tables et vues de base de données à joindre les unes aux autres. Une jointure unique combine toujours une source de données de gauche avec une source de données de droite. Dans l'exemple ci-dessus, la table /DMO/CONNECTION est la source de données de gauche et la table /DMO/AIRPORT la source de données de droite. ABAP SQL prend également en charge les jointures de jointures (jointures imbriquées).
Condition de jointure
La condition de jointure indique quels enregistrements de la source de données de droite appartiennent à un enregistrement de la source de données de gauche. Dans l'exemple ci-dessus, l'aéroport de départ associé est identifié par la valeur dans les colonnes CLIENT et AIRPORT_ID. La condition de jointure se lit comme suit :
/DMO/CONNECTION~CLIENT = /DMO/AIRPORT~CLIENT
ET
/DMO/CONNECTION~AIRPORT_FROM_ID = /DMO/AIRPORT~AIRPORT_ID
Type de jointure
Le type de jointure a une influence sur le résultat si l'une des sources de données ne contient pas d'enregistrements correspondants. ABAP SQL prend actuellement en charge INNER JOIN, LEFT OUTER JOIN, RIGHT OUTER JOIN et CROSS JOIN. Le type de jointure le plus courant est JOINTURE EXTÉRIEURE GAUCHE.

La figure illustre la syntaxe ABAP SQL pour une jointure. Dans la clause FROM, le type de jointure est spécifié par les mots-clés LEFT OUTER JOIN entre la source de données de gauche /dmo/connection et la source de données de droite /dmo/airport. La syntaxe introduit les noms d'alias c et f pour les sources de données. Les noms d'alias des sources de données sont facultatifs, sauf si une source de données apparaît plusieurs fois dans la jointure.

La condition de jointure suit le mot-clé ON. Le séparateur entre la source de données ou son alias et la zone est le signe tilde (~).

Remarque

Dans ABAP SQL, il n'est pas nécessaire de mentionner les zones du mandant. Elles sont ajoutées à la condition de jointure par l'interface de base de données avant que l'instruction ne soit envoyée à la base de données. Si la clause FROM définit une jointure, vous pouvez utiliser les zones des deux sources de données dans les clauses FIELDS et WHERE.

Dans cet exemple, l'instruction SELECT lit non seulement le nom de l'aéroport de départ, mais aussi le nom de l'aéroport de destination. Pour ce faire, la clause FROM définit une jointure imbriquée :

La première jointure est une jointure externe gauche des tables /dmo/connection et /dmo/airport, introduisant l'alias "f" (comme "from") pour la source de données de droite. Cette première jointure est ensuite utilisée comme source de données de gauche pour une deuxième jointure externe gauche qui a la table /dmo/airport comme source de données de droite. Notons que dans ce cas, l'alias "t" (pour "to") est crucial pour distinguer cette apparence de la table /dmo/aéroport de la précédente.

La clause FIELDS répertorie les noms d'aéroport des deux sources de données, en introduisant les alias airport_from_name et airport_to_name pour les distinguer l'un de l'autre.

Astuce

Les parenthèses autour de la première jointure sont facultatives. Si elles sont omises, les jointures de la clause from sont évaluées de gauche à droite.

Essayer : objets de données structurés dans ABAP SQL

  1. Comme dans le premier exercice de ce cours, créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN.
  2. Copiez l'extrait de code suivant dans la partie implémentation de la méthode 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. Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour exécuter l'application console.
  4. Analysez la sortie de la console. Déboguer le programme, jouer avec le code source pour se familiariser avec les concepts.

Utilisation d'un objet de données structuré

Dans cet exercice, vous déclarez un attribut structuré, vous le renseignez à l'aide d'une instruction SELECT et vous accédez aux composants de structure.

Modèle :

  • /LRN/CL_S4D400_DBS_CDS (classe globale)

Solution :

  • /LRN/CL_S4D400_STS_STRUCTURE (classe globale)

Tâche 1: Copier modèle

Copiez la classe de modèle. Vous pouvez également copier votre solution de l'exercice précédent.

Étapes

  1. Copiez la classe /LRN/CL_S4D400_DBS_CDS dans une classe de votre propre package (nom proposé : ZCL_##_STRUCTURE, où ## correspond à votre numéro de groupe).

    1. Ouvrez le code source de la classe globale /LRN/CL_S4D400_DBS_CDS.

    2. Liez la vue Explorateur de projets à l'aide de l'éditeur.

    3. Dans la vue Explorateur de projets, cliquez avec le bouton droit de la souris sur la classe /LRN/CL_S4D400_DBS_CDS pour ouvrir le menu contextuel.

    4. Dans le menu contextuel, sélectionnez Dupliquer ....

    5. Saisissez le nom de votre package dans la zone Package. Dans la zone Nom, saisissez le nom ZCL_##_STRUCTURE, où ## représente votre numéro de groupe.

    6. Ajustez la description et cliquez sur Suivant.

    7. Confirmez l'ordre de transport et cliquez sur Terminer.

Tâche 2: Déclarer un objet de données structuré

Dans la classe locale, déclarez des détails d'attribut structuré pour remplacer les attributs scalaires airport_from_id, airport_to_id et carrier_name. Commencez par définir un type de structure privé st_details dans la classe locale.

Étapes

  1. Passez à la classe locale lcl_connection.

    1. Dans la classe globale, sélectionnez Types locaux.

  2. Définissez un type de structure privést_details avec les composants suivants :

    Composants du type de structure st_details :

    Nom du composantType de données
    aérodrome de DepartureAirport/dmo/airport_from_id
    DestinationAirport/dmo/airport_to_id
    Nom d’une compagnie aérienne/dmo/carrier_name

    1. Après la ligne PRIVATE SECTION., ajoutez le code suivant :

      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. Commentez ou supprimez la déclaration des attributs airport_from_id, airport_to_id et carrier_name.

    1. Sélectionnez les lignes avec les trois instructions DATA.

    2. Appuyez sur Ctrl + < pour ajouter un signe étoile (*) devant chaque ligne sélectionnée.

  4. Déclarez les détails d'un nouvel attribut d'instance privé et saisissez-le avec le type de structure st_details.

    1. Adaptez le code comme suit :

      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.

Tâche 3: Accéder aux composants de structure

Utilisez les composants des détails de l'attribut structuré dans la méthode get_output.

Étapes

  1. Adaptez l'implémentation de la méthode get_output. Remplacez tout accès aux attributs airport_from_id, airport_to_id et carrier_name par le composant correspondant des détails de l'attribut.

    Astuce

    Ne saisissez pas les noms des composants manuellement ! Après avoir saisi le sélecteur de composants de structure (-), appuyez sur Ctrl + Espace pour obtenir une liste de tous les composants.

    1. Naviguez vers l'implémentation de la méthode get_output.

    2. Adaptez les instructions APPEND comme suit :

      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.

Tâche 4: Renseigner l'attribut structuré dans l'instruction SELECT

Utilisez l'attribut structuré comme cible de l'instruction SELECT dans la méthode du constructeur.

Étapes

  1. Ajustez l'instruction SELECT dans l'implémentation de la méthode du constructeur. Remplacez la liste des objets de données dans la clause INTO par les détails de l'attribut structuré.

    1. Naviguez vers l'implémentation du constructeur de méthode.

    2. Ajustez l'instruction SELECT comme suit :

      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. Facultatif : utilisez la variante de syntaxe INTO CORRESPONDING FIELDS OF @details..

    1. Dans l'instruction SELECT, remplacez INTO @details.par le code suivant :

      Code Snippet
      123
      
  INTO CORRESPONDING FIELDS OF @details.

    2. Ajoutez l'alias AirlineName pour l'expression de chemin.

    3. L'instruction SELECT doit maintenant ressembler à ceci :

      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. Activez la classe. Exécutez-la et analysez la sortie de la console. Vérifiez que la sortie affiche des données pour tous les attributs.

    1. Appuyez sur Ctrl + F3 pour activer la classe.

    2. Appuyez sur F9 pour exécuter la classe.

Learning

SAP FacebookSAP YoutubeSAP LinkedIn