Objective
After completing this lesson, you will be able to déclarer un objet de données structuré.
Objets de données structurés
Jusqu'à présent, vous utilisiez des variables simples, chacune pouvant stocker une seule information. Ici, par exemple, il existe deux variables, l'une pour l'aéroport de départ, l'autre pour l'aéroport d'arrivée.
Lorsque vous lisez un enregistrement de la base de données, vous devez conserver toutes ces informations ensemble. Les deux variables de l'exemple sont totalement indépendantes l'une de l'autre, et ne sont donc pas adaptées pour stocker différentes informations qui vont ensemble.
En ABAP, la solution consiste à utiliser une variable structurée ou une structure.
Une structure est un objet de données ABAP variable avec un nom et un type structuré.
Dans l'exemple, l'objet de données connection_full est une telle structure. Il est subdivisé en huit composantes, chacune ayant également un nom et un type. Vous pouvez traiter à la fois la structure dans son ensemble et les composants individuels. Il est important de noter que vous pouvez utiliser chaque composant exactement de la même manière que vous utiliseriez une variable simple autonome.
Il existe différentes possibilités pour déclarer une structure. Vous pouvez définir des types structurés avec le mot-clé TYPES ou utiliser un objet du Repository de type Structure. Les définitions de vues et de tables de base de données peuvent également servir de types structurés. L'exemple utilise la vue CDS /DMO/I_Connection comme type structuré.
Dans la perspective du débogueur, il existe deux façons d'analyser la structure et le contenu d'une variable structurée :
- Aperçu de variable (effet de survol)
Définissez le focus sur l'éditeur de code source et placez le pointeur sur un nom de variable. Au bout d'un moment, une boîte de dialogue s'ouvre avec des détails sur la structure et le contenu de l'objet de données.
- Afficher dans la vue Variables (double-clic)
Pour afficher la variable dans la vue Variables, saisissez le nom de la variable sous <Saisir variable> ou double-cliquez sur le nom de la variable quelque part dans l'éditeur de code source. Développez le nœud avec le nom de la structure pour afficher la liste des composants.
Comment analyser des objets de données structurés à l'aide de la perspective de débogage
Types de données structurées
Un type de structure globale est un objet du Repository qui peut être utilisé comme type de données n'importe où dans le système. Dans l'exemple, le type structuré SYMSG est utilisé pour déclarer un message variable.
Lorsque vous appuyez sur la touche F2 pour afficher les détails de ce type de données, vous pouvez voir qu'il s'agit d'un type de structure composé de sept composants. Vous pouvez également voir les noms, les types techniques et les descriptions des composants.
Lorsque vous appuyez sur la touche F3 pour accéder à la définition du type, une nouvelle vue s'ouvre avec l'éditeur ADT pour les types structurés globaux.
La définition d'un type de structure global est très similaire à la définition d'une table de base de données. La partie principale de la définition est constituée d'une instruction DEFINE STRUCTURE avec le nom du type de structure. Elle est suivie de la liste des composants de structure dans une paire d'accolades ( { , } ) ; chaque composant avec un type de composant. Les types de composants sont souvent décrits par des éléments de données, mais il est également possible d'utiliser des types de structures comme types de composants. Les structures avec des composants structurés sont appelées Structures imbriquées.
Des lignes de code supplémentaires avant l'instruction DEFINE STRUCTURE indiquent des propriétés supplémentaires du type de structure, parmi lesquelles une étiquette.
Vous pouvez également définir des types structurés dans un programme ABAP à l'aide de l'instruction TYPES. La définition de structure commence par l'instruction TYPES BEGIN OF <nom du type de structure> et se termine par TYPES END OF <nom du type de structure>. Entre les deux, vous nommez chaque composant et indiquez son type dans une instruction TYPES supplémentaire.
Un formulaire compact utilise le mot-clé TYPES une seule fois, suivi de deux-points ( : ). L'option BEGIN OF, l'option END OF et les définitions de composants intermédiaires sont ensuite séparées par des virgules.
On parle alors d'instruction de chaîne.
Remarque
Auparavant, les instructions de chaîne étaient beaucoup utilisées dans ABAP. De nos jours, ils ne sont recommandés que pour combiner des énoncés qui vont étroitement ensemble.
Dans cet exemple, une instruction de chaîne TYPES: est utilisée pour définir le type structuré local st_connection qui se compose des trois composants airport_from_id, airport_to_id et carrier_name. Chaque composant est catégorisé avec un élément de données commençant par /dmo/.
Le type structuré local st_connection est ensuite utilisé dans une instruction DATA pour saisir une connexion de variable structurée.
Dans cet exemple, la variable connection a un type structuré imbriqué. Le type st_nested définit 4 composants. Trois sont catégorisés avec des éléments de données, il s'agit donc de composants simples. Cependant, la composante message est catégorisée avec un type structuré. Il s'agit donc d'un composant structuré. Cela fait de la variable connection une structure imbriquée.
ABAP prend en charge non seulement les variables structurées, mais aussi les constantes structurées. Pour définir une constante structurée, utilisez BEGIN OF et END OF dans le cadre d'une instruction CONSTANTS. L'exemple montre une constante structurée définie dans la section publique de la classe globale CL_ABAP_BEHV. Les cinq composantes sont catégorisées avec l'élément de données SECKEYNAME. N'oubliez pas que l'option VALUE est obligatoire lors de la définition des constantes.
Essayer : types de données structurés
- Comme dans le premier exercice de ce cours, créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN.
- Copiez l'extrait de code suivant dans la partie implémentation de la méthode 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 ).
- Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour exécuter l'application console.
- Analysez la sortie de la console. Déboguer le programme, jouer avec le code source pour se familiariser avec les concepts.
