Objective
After completing this lesson, you will be able to déclarez une table interne complexe.
Propriétés des tables internes complexes
Les tables internes que nous avons utilisées jusqu'à présent avaient un type de données scalaire comme type de ligne. Dans l'exemple illustré dans les figures, le type de ligne des numéros de table interne est le type intégré à ABAP I.
Nous appelons ces types de tables internes des tables internes simples.
Il s'agit d'une table interne complexe si le type de ligne est un type de données structuré.
Alors qu'une table interne simple n'a qu'une seule colonne sans nom, une table interne complexe se compose de plusieurs colonnes, chacune d'elles avec le nom et le type du composant correspondant du type de ligne structuré. Dans l'exemple, le type de ligne de la table interne connections est un type structuré avec cinq composants : carrier_id, connection_id, airport_from_id, airport_to_id et carrier_name. Par conséquent, la table interne connections comporte cinq colonnes avec ces noms.
Remarque
Les colonnes des exemples des figures Rappel : tables internes simples et tables internes avec type de ligne structuré ont toutes des types scalaires. Plus généralement, une colonne d'une table interne peut également être de type structuré ou même avoir un type de table. Dans ce dernier cas, on parle de table interne imbriquée.
Jusqu'à présent, nous avons traité les lignes d'une table interne par leur position. C'est ce qu'on appelle un accès à l'index.
Avec les colonnes nommées d'une table interne complexe, l'accès par clé devient plus important. Par accès par clé, on entend adresser une ligne de la table interne en recherchant des valeurs particulières dans des colonnes particulières. Les colonnes dans lesquelles vous effectuez la recherche peuvent être n'importe quelle colonne de la table interne.
L'accès par index à une table interne est toujours très rapide, même si la table interne contient de nombreuses lignes. Cependant, l'accès par clé peut devenir très lent si la table contient un grand nombre de lignes. La sélection du type d'accès approprié pour la table interne peut améliorer les performances d'un accès par clé.
Chaque table interne possède l'un des trois types d'accès. Le type d'accès détermine la manière dont les données sont stockées dans la table et, en fonction de cela, la manière dont le système lit la table pour récupérer les données.
Les différents types de tables sont les suivants :
- Table standard
- Dans une table standard, le contenu n'est pas enregistré dans un ordre de tri particulier. Par défaut, les nouveaux enregistrements sont ajoutés à la fin de la table. Pour récupérer les données par clé, le système doit les lire de manière séquentielle, ce qui peut entraîner des temps de récupération longs si la table est très volumineuse. Les tables internes simples que nous avons utilisées jusqu'à présent étaient des tables standard.
- Table triée
- Dans une table triée, le contenu de la table est toujours trié par ordre croissant en fonction des zones clés. Lorsque vous insérez un nouvel enregistrement dans la table, le système s'assure qu'il est placé à la bonne position. Étant donné que les données sont toujours triées, le système peut récupérer les enregistrements plus efficacement qu'à partir d'une table standard (tant que vous suivez des règles particulières).
- Table de hachage
- Les tables de hachage sont gérées à l'aide d'un algorithme de hachage spécial. Cela garantit que le système peut récupérer les enregistrements très rapidement, même si la table est extrêmement volumineuse. Cependant, ce gain de performance ne fonctionne que dans des cas très particuliers.
Chaque table interne possède une clé. Dans les tables standard, la clé ne joue pas un rôle particulièrement important. Pour les tables triées et de hachage, la clé est très importante car elle détermine la manière dont les données seront gérées dans la table. De manière cruciale, les tables triées et de hachage sont seulement plus rapides pour l'accès par clé qui adresse la totalité ou au moins un sous-ensemble des zones clés.
Un autre attribut de la clé de table est son unicité. Vous voudrez parfois autoriser les entrées en double dans une table interne et vous voudrez parfois vous assurer que la clé est unique. Ici, les règles suivantes s'appliquent :
- Les doublons sont toujours autorisés dans les tables standard.
- Les doublons ne sont jamais autorisés dans les tables de hachage.
- Pour une table triée, vous choisissez dans la définition si la clé doit être unique ou non.
Remarque
Les tables internes peuvent également avoir des clés secondaires. Les clés secondaires permettent d'améliorer les performances des accès par clé aux tables internes qui utilisent différentes combinaisons de zones. Vous trouverez de plus amples informations sur les clés secondaires dans la documentation de syntaxe ABAP.
Types de tables complexes
Regardez cette vidéo pour voir des exemples de déclaration de tables internes complexes.
En outre, il est bon de définir d'abord le type de données, puis de créer une variable qui fait référence au type.
Au lieu d'indiquer le type d'accès et la clé d'une table interne dans l'instruction DATA, vous devez utiliser un type de table nommé. Si vous avez besoin du type de table uniquement localement dans une méthode ou en relation avec une classe donnée, vous pouvez le définir à l'aide de l'instruction TYPES.
L'exemple définit d'abord un type structuré st_connection. Avec ce type structuré comme type de ligne, il définit alors le type de table tt_connections. Enfin, la déclaration de la table interne connections_5 fait référence au type de table.
Si vous avez besoin du type de table globalement, vous pouvez utiliser un type de table global.
Un type de table global est un objet du Repository qui peut être utilisé comme type de données n'importe où dans le système. ADT fournit un éditeur dédié pour ce type d'objet du Repository. L'outil se compose des cadres suivants :
La vidéo suivante montre comment définir des types de tables localement.
Essayer : types de tables complexes
- 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( ) :
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
TYPES: BEGIN OF st_connection,
carrier_id TYPE /dmo/carrier_id,
connection_id TYPE /dmo/connection_id,
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.
* Example 1 : Simple and Complex Internal Table
**********************************************************************
" simple table (scalar row type)
DATA numbers TYPE TABLE OF i.
" complex table (structured row type)
DATA connections TYPE TABLE OF st_connection.
out->write( `--------------------------------------------` ).
out->write( `Example 1: Simple and Complex Internal Table` ).
out->write( data = numbers
name = `Simple Table NUMBERS:`).
out->write( data = connections
name = `Complex Table CONNECTIONS:`).
* Example 2 : Complex Internal Tables
**********************************************************************
" standard table with non-unique standard key (short form)
DATA connections_1 TYPE TABLE OF st_connection.
" standard table with non-unique standard key (explicit form)
DATA connections_2 TYPE STANDARD TABLE OF st_connection
WITH NON-UNIQUE DEFAULT KEY.
" sorted table with non-unique explicit key
DATA connections_3 TYPE SORTED TABLE OF st_connection
WITH NON-UNIQUE KEY airport_from_id
airport_to_id.
" sorted hashed with unique explicit key
DATA connections_4 TYPE HASHED TABLE OF st_connection
WITH UNIQUE KEY carrier_id
connection_id.
* Example 3 : Local Table Type
**********************************************************************
TYPES tt_connections TYPE SORTED TABLE OF st_connection
WITH UNIQUE KEY carrier_id
connection_id.
DATA connections_5 TYPE tt_connections.
* Example 4 : Global Table Type
**********************************************************************
DATA flights TYPE /dmo/t_flight.
out->write( `------------------------------------------` ).
out->write( `Example 4: Global Table TYpe /DMO/T_FLIGHT` ).
out->write( data = flights
name = `Internal Table FLIGHTS:` ).
- Appuyez sur CTRL + F3 sur votre clavier pour activer la classe et 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.
