Types ITAB en ABAP

#

Itab type table of

#

Objectifs

#

• Comprendre ce qu’est une TABLE INTERNE en ABAP
• Déclarer un type de structure avec TYPES
• Créer une variable de type structure pour les lignes
• Créer une variable de type TABLE INTERNE
• Remplir une TABLE INTERNE avec des données structurées
• Assimiler l’analogie entre TABLE INTERNE et carnet d’adresses
• Appliquer les bonnes pratiques pour manipuler les tables internes

Définition

#

Une TABLE INTERNE est un conteneur temporaire de données dans un programme ABAP.
Elle permet de stocker plusieurs lignes de données structurées, chaque ligne pouvant être une STRUCTURE ou un simple type.

Imaginez une TABLE INTERNE comme un carnet d’adresses

• Chaque page correspond à une ligne de table (une STRUCTURE)
• Chaque champ sur la page correspond à un champ de la STRUCTURE (nom, prénom, téléphone…)
• Vous pouvez ajouter ou supprimer des pages sans toucher aux autres

Les TABLES INTERNES sont uniquement en mémoire pendant l’exécution du programme, elles ne sont pas persistantes comme une table en base de données.

Déclaration

#

1️⃣ Définir un type de structure pour une ligne :

TYPES: BEGIN OF ty_person,
         nom    TYPE char20,
         prenom TYPE char20,
         age    TYPE i,
         ville  TYPE char20,
      END OF ty_person.

2️⃣ Déclarer la TABLE INTERNE :

DATA: lt_persons TYPE TABLE OF ty_person.

3️⃣ Déclarer une structure temporaire pour ajouter des lignes :

DATA: ls_person TYPE ty_person.
" ou encore
DATA: ls_person_2 LIKE LINE OF lt_persons.

Le TYPES ty_person = fiche d’identité
La TABLE lt_persons = carnet d’adresses
La STRUCTURE ls_person = page vide à remplir avant de l’insérer

Affectation de valeur et insertion d’une ligne dans une table

#

ls_person-nom    = 'Dupont'.
ls_person-prenom = 'Jean'.
ls_person-age    = 35.
ls_person-ville  = 'Paris'.

APPEND ls_person TO lt_persons.

On remplit une fiche (STRUCTURE) et on la colle dans le carnet (TABLE INTERNE).

Toujours utiliser une STRUCTURE temporaire pour manipuler les lignes avant de les insérer dans la table.

Lorsque tu alimentes une table avec plusieurs lignes de manière automatique (dans une boucle par exemple), n’oublie pas de CLEAR la structure après tout ajout de ligne dans la table (ou avant toute affectation de valeur).

Bonnes pratiques

#

Exercices – Déclaration et insertion

#

1 – Créer une table interne de livres

#

Déclarer une TABLE INTERNE lt_livres avec une STRUCTURE ty_livre contenant

• titre (CHAR30)
• auteur (CHAR30)
• annee (I)
• genre (CHAR20)

Ajouter une ligne à la table.

TYPES: BEGIN OF ty_livre,
         titre  TYPE char30,
         auteur TYPE char30,
         annee  TYPE i,
         genre  TYPE char20,
       END OF ty_livre.

DATA: lt_livres TYPE TABLE OF ty_livre,
      ls_livre TYPE ty_livre.

ls_livre-titre  = '1984'.
ls_livre-auteur = 'George Orwell'.
ls_livre-annee  = 1949.
ls_livre-genre  = 'Dystopie'.

APPEND ls_livre TO lt_livres.

2 – Ajouter une deuxième ligne

#

Ajouter un deuxième livre dans la même table lt_livres.

ls_livre-titre  = 'Le Petit Prince'.
ls_livre-auteur = 'Antoine de Saint-Exupéry'.
ls_livre-annee  = 1943.
ls_livre-genre  = 'Conte'.

APPEND ls_livre TO lt_livres.

3 – Créer une table de clients

#

Déclarer une TABLE INTERNE lt_clients avec une STRUCTURE ty_client contenant

• nom (CHAR20)
• prenom (CHAR20)
• age (I)
• ville (CHAR20)

Ajouter deux clients différents.

TYPES: BEGIN OF ty_client,
         nom    TYPE char20,
         prenom TYPE char20,
         age    TYPE i,
         ville  TYPE char20,
       END OF ty_client.

DATA: lt_clients TYPE TABLE OF ty_client,
      ls_client TYPE ty_client.

ls_client-nom    = 'Martin'.
ls_client-prenom = 'Claire'.
ls_client-age    = 28.
ls_client-ville  = 'Lyon'.
APPEND ls_client TO lt_clients.

ls_client-nom    = 'Bernard'.
ls_client-prenom = 'Paul'.
ls_client-age    = 45.
ls_client-ville  = 'Marseille'.
APPEND ls_client TO lt_clients.

Résumé

#

• Une TABLE INTERNE contient plusieurs lignes de données structurées.
• Chaque ligne est une STRUCTURE, manipulée via une VARIABLE temporaire avant insertion.
• Schéma général : TYPES → DATA structure → DATA table → APPEND TO table.

[!TIP] carnet d’adresses pour la table, fiche d’identité pour chaque ligne.

[!IMPORTANT] utiliser des STRUCTURES claires, manipuler les lignes via une STRUCTURE temporaire et éviter les header lines.

Itab type standard table of

#

Objectifs

#

• Comprendre la différence entre TYPE TABLE OF et TYPE STANDARD TABLE OF
• Savoir déclarer un type standard de table interne
• Assimiler le comportement spécifique d’une table standard (index implicite, ordre d’insertion)
• Identifier les cas d’usage pertinents

Définition

#

Une table interne standard (TYPE STANDARD TABLE OF) est une table indexée automatiquement par ABAP.
Chaque ligne est accessible par un indice numérique (1, 2, 3, …), représentant l’ordre d’insertion.

• L’ordre d’insertion détermine l’ordre de lecture.
• L’accès à une ligne spécifique nécessite souvent une recherche séquentielle (instruction READ TABLE).
• Une table standard n’impose pas d’unicité sur les lignes.

Type de table interne	Indexée	Accès direct	Doublons autorisés	Tri automatique
STANDARD TABLE	Oui	Non	Oui	Non
SORTED TABLE	Oui	Oui (clé)	Non (clé unique)	Oui
HASHED TABLE	Non	Oui (clé)	Non (clé unique)	Non

Déclaration

#

1️⃣ Définir un type de ligne

#

TYPES: BEGIN OF ty_person,
         nom    TYPE char20,
         prenom TYPE char20,
         age    TYPE i,
         ville  TYPE char20,
       END OF ty_person.

2️⃣ Déclarer une table standard

#

DATA: lt_persons TYPE STANDARD TABLE OF ty_person.

3️⃣ Déclarer une structure temporaire

#

DATA: ls_person TYPE ty_person.

• ty_person → modèle de fiche d’identité
• ls_person → fiche en cours de remplissage
• lt_persons → carnet de fiches numérotées automatiquement

Insertion d’une ligne

#

ls_person-nom    = 'Dupont'.
ls_person-prenom = 'Jean'.
ls_person-age    = 35.
ls_person-ville  = 'Paris'.

APPEND ls_person TO lt_persons.

L’instruction APPEND ajoute la ligne à la fin de la table.
La table standard conserve l’ordre chronologique d’insertion.

Le APPEND crée implicitement un nouvel index pour la ligne ajoutée.

Accès aux données

#

Lecture séquentielle

#

• BOUCLE avec stockage des données de la ligne lue dans une structure déjà déclarée en amont

LOOP AT lt_persons INTO ls_person.
  WRITE: / ls_person-nom, ls_person-prenom.
ENDLOOP.

• BOUCLE avec stockage des données de la ligne lue dans une structure déclarée dynamiquement

LOOP AT lt_persons INTO DATA(ls_person).
  WRITE: / ls_person-nom, ls_person-prenom.
ENDLOOP.

• BOUCLE avec stockage des données de la ligne lue dans un field-symbol déjà déclaré en amont

LOOP AT lt_persons ASSIGNING <lfs_person>.
  WRITE: / ls_person-nom, ls_person-prenom.
ENDLOOP.

• BOUCLE avec stockage des données de la ligne lue dans un field-symbol déclaré dynamiquement

LOOP AT lt_persons ASSIGNING FIELD-SYMBOL(<lfs_person>).
  WRITE: / ls_person-nom, ls_person-prenom.
ENDLOOP.

Lecture par index

#

READ TABLE lt_persons INDEX 2 INTO ls_person.
IF sy-subrc = 0.
  WRITE: / 'Deuxième personne :', ls_person-nom.
ENDIF.

Une table standard ne garantit pas de tri ou d’accès direct par clé.
L’accès se fait par index ou recherche séquentielle.

Bonnes pratiques

#

Tables standard → manipulation séquentielle (boucles, appends, tri manuel).

Exemples

#

Exemple 1 – Table de livres

#

TYPES: BEGIN OF ty_livre,
         titre  TYPE char30,
         auteur TYPE char30,
         annee  TYPE i,
         genre  TYPE char20,
       END OF ty_livre.

DATA: lt_livres TYPE STANDARD TABLE OF ty_livre,
      ls_livre  TYPE ty_livre.

ls_livre-titre  = '1984'.
ls_livre-auteur = 'George Orwell'.
ls_livre-annee  = 1949.
ls_livre-genre  = 'Dystopie'.
APPEND ls_livre TO lt_livres.

ls_livre-titre  = 'Le Petit Prince'.
ls_livre-auteur = 'Antoine de Saint-Exupéry'.
ls_livre-annee  = 1943.
ls_livre-genre  = 'Conte'.
APPEND ls_livre TO lt_livres.

Exemple 2 – Tri manuel d’une table standard

#

SORT lt_livres BY auteur.

Une table standard n’est pas triée automatiquement.
SORT est nécessaire pour organiser les lignes par champ.

Exercices

#

1 – Table de clients

#

Déclarer une table standard lt_clients avec une structure ty_client contenant

• nom (CHAR20)
• prenom (CHAR20)
• age (I)
• ville (CHAR20)

Ajouter deux clients et afficher leurs noms.

TYPES: BEGIN OF ty_client,
         nom    TYPE char20,
         prenom TYPE char20,
         age    TYPE i,
         ville  TYPE char20,
       END OF ty_client.

DATA: lt_clients TYPE STANDARD TABLE OF ty_client,
      ls_client  TYPE ty_client.

ls_client-nom = 'Martin'.
ls_client-prenom = 'Claire'.
ls_client-age = 28.
ls_client-ville = 'Lyon'.
APPEND ls_client TO lt_clients.

ls_client-nom = 'Bernard'.
ls_client-prenom = 'Paul'.
ls_client-age = 45.
ls_client-ville = 'Marseille'.
APPEND ls_client TO lt_clients.

Résumé

#

• TYPE STANDARD TABLE OF → table interne indexée automatiquement.
• Ordre d’insertion conservé.
• Accès séquentiel ou par index.
• Pas de tri ni de clé unique par défaut.
• Idéale pour listes simples ou traitements linéaires.

Itab type sorted table of

#

Objectifs

#

• Comprendre la structure et le comportement d’une table triée (TYPE SORTED TABLE OF)
• Savoir déclarer une clé obligatoire avec WITH UNIQUE KEY
• Identifier les avantages et contraintes de performance
• Maîtriser l’insertion, la lecture et le tri automatique
• Appliquer les bonnes pratiques d’utilisation

Définition

#

Une SORTED TABLE est une table interne triée automatiquement selon une clé définie lors de la déclaration.
L’ordre est garanti et un index interne est maintenu pour les recherches par clé.

Un annuaire trié par nom : chaque fiche est automatiquement insérée à la bonne position.
Impossible d’avoir deux fiches avec le même nom si la clé est unique.

• Une clé (WITH UNIQUE KEY ou WITH NON-UNIQUE KEY) est obligatoire.
• L’insertion est automatiquement triée.
• Les recherches sont optimisées (accès dichotomique).
• Les insertions massives sont plus coûteuses qu’avec une STANDARD TABLE.

Déclaration

#

1️⃣ Définir une structure de ligne

#

TYPES: BEGIN OF ty_person,
         id    TYPE char10,
         nom   TYPE char20,
         age   TYPE i,
       END OF ty_person.

2️⃣ Déclarer une table triée avec la clé unique

#

DATA: lt_persons TYPE SORTED TABLE OF ty_person
                  WITH UNIQUE KEY id.

3️⃣ Déclarer la structure de travail

#

DATA: ls_person TYPE ty_person.

• SORTED TABLE maintient un ordre trié automatique.
• WITH UNIQUE KEY garantit l’unicité sur le champ clé.
• INSERT insère la ligne au bon endroit, selon la clé.

Insertion d’une ligne

#

ls_person-id  = '0003'.
ls_person-nom = 'Martin'.
ls_person-age = 28.
INSERT ls_person INTO TABLE lt_persons.

ls_person-id  = '0001'.
ls_person-nom = 'Dupont'.
ls_person-age = 45.
INSERT ls_person INTO TABLE lt_persons.

Peu importe l’ordre du code, les lignes seront triées par la clé (id).

• APPEND ne doit jamais être utilisé dans une SORTED TABLE.
• Seule l’instruction INSERT maintient le tri automatique.
• Si une clé dupliquée est insérée → erreur d’exécution (sy-subrc ≠ 0).

Bonnes pratiques

#

Une SORTED TABLE est idéale lorsque l’ordre et la recherche par clé sont prioritaires, pas la vitesse d’insertion.

Exemples

#

Exemple 1 – Table de produits triée par id

#

TYPES: BEGIN OF ty_produit,
         id   TYPE char10,
         nom  TYPE char20,
         prix TYPE i,
       END OF ty_produit.

DATA: lt_produits TYPE SORTED TABLE OF ty_produit
                      WITH UNIQUE KEY id,
      ls_produit TYPE ty_produit.

ls_produit-id   = '0002'.
ls_produit-nom  = 'Stylo'.
ls_produit-prix = 2.
INSERT ls_produit INTO TABLE lt_produits.

ls_produit-id   = '0001'.
ls_produit-nom  = 'Cahier'.
ls_produit-prix = 5.
INSERT ls_produit INTO TABLE lt_produits.

L’ordre final dans la table est :
0001 Cahier, 0002 Stylo.

Exemple 2 – Ajout d’un troisième produit

#

ls_produit-id   = '0003'.
ls_produit-nom  = 'Gomme'.
ls_produit-prix = 1.
INSERT ls_produit INTO TABLE lt_produits.

L’ordre reste automatiquement 0001, 0002, 0003.

Exercices

#

1 – Créer une table de clients triée par id

#

Déclarer une table lt_clients triée par id et y insérer trois lignes désordonnées.

TYPES: BEGIN OF ty_client,
         id     TYPE char10,
         nom    TYPE char20,
         prenom TYPE char20,
       END OF ty_client.

DATA: lt_clients TYPE SORTED TABLE OF ty_client
                     WITH UNIQUE KEY id,
      ls_client  TYPE ty_client.

ls_client-id = '003'.
ls_client-nom = 'Durand'.
ls_client-prenom = 'Alice'.
INSERT ls_client INTO TABLE lt_clients.

ls_client-id = '001'.
ls_client-nom = 'Martin'.
ls_client-prenom = 'Paul'.
INSERT ls_client INTO TABLE lt_clients.

ls_client-id = '002'.
ls_client-nom = 'Bernard'.
ls_client-prenom = 'Luc'.
INSERT ls_client INTO TABLE lt_clients.

LOOP AT lt_clients INTO ls_client.
  WRITE: / ls_client-id, ls_client-nom.
ENDLOOP.

2 – Tester une clé dupliquée

#

Essayer d’insérer une ligne avec un id déjà existant et observer le sy-subrc.

ls_client-id = '002'.
ls_client-nom = 'Dupont'.
ls_client-prenom = 'Jean'.
INSERT ls_client INTO TABLE lt_clients.

IF sy-subrc <> 0.
  WRITE: / 'Erreur : clé déjà existante.'.
ENDIF.

Résumé

#

• TYPE SORTED TABLE OF → table interne triée automatiquement selon une clé.
• Clé obligatoire (WITH UNIQUE KEY ou WITH NON-UNIQUE KEY).
• Accès par clé très rapide (binaire).
• Insertion plus lente à cause du maintien de l’ordre.
• Interdiction d’utiliser APPEND.
• Idéale pour les listes triées, les recherches rapides et la garantie d’unicité.

Type range of

#

Objectifs

#

• Comprendre le rôle d’une RANGE TABLE
• Identifier les champs prédéfinis : SIGN, OPTION, LOW, HIGH
• Comprendre la notion d’inclusion/exclusion et d’intervalles

Définition

#

Une RANGE TABLE est une table interne spéciale pour définir des intervalles de valeurs.
Elle est utilisée pour filtrer des données dans les requêtes SQL et les écrans de sélection.

Imaginez un filtre de recherche avancé

• Vous indiquez ce que vous voulez inclure ou exclure
• Vous précisez des intervalles de valeurs
• La table RANGE stocke toutes ces informations de manière structurée pour la requête

Champs prédéfinis

#

• SIGN (C, 1) → Incluse (I) ou Exclue (E)
• OPTION (C, 2) → opérateur : EQ, NE, GT, LT, BT…
• LOW → limite inférieure de l’intervalle
• HIGH → limite supérieure de l’intervalle

Chaque ligne de la RANGE TABLE correspond à une règle de filtrage.

Déclaration

#

" Déclaration d'une RANGE TABLE pour des numéros de produits (MATNR)
DATA: lr_matnr TYPE RANGE OF matnr.

La lr_matnr est directement utilisable dans des SELECT ou pour SELECT-OPTIONS.

Alimentation

#

DATA: ls_matnr TYPE LINE OF lr_matnr.

" Inclure les produits 1000 à 2000
ls_matnr-sign   = 'I'.
ls_matnr-option = 'BT'.
ls_matnr-low    = '1000'.
ls_matnr-high   = '2000'.
APPEND ls_matnr TO lr_matnr.

" Exclure le produit 1500
ls_matnr-sign   = 'E'.
ls_matnr-option = 'EQ'.
ls_matnr-low    = '1500'.
ls_matnr-high   = ''.
APPEND ls_matnr TO lr_matnr.

Le SIGN = I → inclusion, E → exclusion
Le OPTION = BT → entre deux valeurs, EQ → valeur unique

Les RANGE TABLE simplifient le filtrage complexe sans écrire de multiples conditions IF.

Exercices

#

1 – Créer une range table de produits

#

Déclarer une RANGE TABLE lr_prod pour le type matnr.
Ajouter un intervalle inclus de 500 à 1000 et une exclusion pour 750.

DATA: lr_prod TYPE RANGE OF matnr,
      ls_prod TYPE LINE OF lr_prod.

" Inclure 500 à 1000
ls_prod-sign   = 'I'.
ls_prod-option = 'BT'.
ls_prod-low    = '500'.
ls_prod-high   = '1000'.
APPEND ls_prod TO lr_prod.

" Exclure 750
ls_prod-sign   = 'E'.
ls_prod-option = 'EQ'.
ls_prod-low    = '750'.
ls_prod-high   = ''.
APPEND ls_prod TO lr_prod.

2 – Ajouter un nouvel intervalle

#

Ajouter un intervalle inclus de 1100 à 1200 et afficher la RANGE TABLE.

ls_prod-sign   = 'I'.
ls_prod-option = 'BT'.
ls_prod-low    = '1100'.
ls_prod-high   = '1200'.
APPEND ls_prod TO lr_prod.

LOOP AT lr_prod INTO ls_prod.
  WRITE: / 'SIGN:', ls_prod-sign,
           'OPTION:', ls_prod-option,
           'LOW:', ls_prod-low,
           'HIGH:', ls_prod-high.
ENDLOOP.

3 – Ajouter une exclusion

#

Exclure le produit 1120 et afficher toute la RANGE TABLE.

ls_prod-sign   = 'E'.
ls_prod-option = 'EQ'.
ls_prod-low    = '1120'.
ls_prod-high   = ''.
APPEND ls_prod TO lr_prod.

LOOP AT lr_prod INTO ls_prod.
  WRITE: / 'SIGN:', ls_prod-sign,
           'OPTION:', ls_prod-option,
           'LOW:', ls_prod-low,
           'HIGH:', ls_prod-high.
ENDLOOP.

L’ordre des lignes n’a pas d’importance. Chaque ligne est évaluée lors du filtrage.

Résumé

#

• TYPE RANGE OF → table interne pour stocker intervalles et exclusions.
• Champs : SIGN, OPTION, LOW, HIGH
• Analogie : un filtre avancé qui mémorise les inclusions, exclusions et intervalles
• Astuce : chaque APPEND ajoute une nouvelle “règle” de filtrage

Type hashed table

#

Objectifs

#

• Comprendre le fonctionnement d’une HASHED TABLE
• Identifier les différences avec une SORTED TABLE
• Savoir déclarer correctement la clé unique obligatoire (WITH UNIQUE KEY)
• Savoir insérer et lire directement des lignes via la clé

Définition

#

Une HASHED TABLE est une table interne avec accès direct par clé unique.
Elle utilise un calcul de hachage pour localiser chaque ligne instantanément.
Contrairement à la SORTED TABLE, il n’y a pas d’ordre ni d’index implicite.

Imaginez un casier à code unique dans un vestiaire

• Chaque code (clé) ouvre directement le bon casier (ligne).
• Aucun besoin de parcourir les autres casiers pour trouver le bon.
• Deux clés identiques ne peuvent pas coexister – la clé doit être unique.

• La clé unique est obligatoire (WITH UNIQUE KEY).
• L’ordre des lignes n’est jamais garanti.
• Les insertions massives et les lectures par clé sont très performantes.

Déclaration

#

1️⃣ Définir un type de structure pour les lignes :

TYPES: BEGIN OF ty_tab,
         obj1 TYPE char10,
         obj2 TYPE char20,
         obj3 TYPE i,
       END OF ty_tab.

2️⃣ Déclarer la table interne HASHED :

DATA: lt_tab_types TYPE HASHED TABLE OF ty_tab
                     WITH UNIQUE KEY obj1.

• WITH UNIQUE KEY obj1 → clé primaire obligatoire.
• Pas d’ordre, pas d’index explicite. La clé identifie chaque ligne.

Insertion et lecture par clé

#

DATA: ls_tab TYPE ty_tab.

" Insertion
ls_tab-obj1 = '0001'.
ls_tab-obj2 = 'Dupont'.
ls_tab-obj3 = 45.
INSERT ls_tab INTO TABLE lt_tab_types.

IF sy-subrc = 0.
  WRITE: / ls_tab-obj2, ls_tab-obj3.
ENDIF.

Ici, la recherche est instantanée grâce au mécanisme de hachage.
Aucune boucle ni tri n’est nécessaire pour accéder à une ligne spécifique.

Différences avec sorted table

#

• L’accès séquentiel (LOOP AT) reste possible, mais l’ordre n’est jamais garanti.
• Pour les recherches fréquentes par clé, HASHED TABLE est optimal.
• Ne jamais insérer deux lignes avec la même clé unique.

Exercices – Déclaration et insertion

#

1 – Créer une hashed table de clients

#

Déclarer une table interne lt_clients avec une structure ty_client contenant

• id (CHAR10) → clé unique
• nom (CHAR20)
• ville (CHAR20)

Ajouter au moins deux clients.

TYPES: BEGIN OF ty_client,
         id   TYPE char10,
         nom  TYPE char20,
         ville TYPE char20,
       END OF ty_client.

DATA: lt_clients TYPE HASHED TABLE OF ty_client
                      WITH UNIQUE KEY id,
      ls_client TYPE ty_client.

ls_client-id    = 'C002'.
ls_client-nom   = 'Martin'.
ls_client-ville = 'Paris'.
INSERT ls_client INTO TABLE lt_clients.

ls_client-id    = 'C001'.
ls_client-nom   = 'Dupont'.
ls_client-ville = 'Lyon'.
INSERT ls_client INTO TABLE lt_clients.

Résumé

#

• HASHED TABLE → table interne avec accès direct par clé unique.
• Obligatoire : WITH UNIQUE KEY.
• Avantage : lecture très rapide par clé, insertion performante.
• Inconvénient : pas d’ordre naturel, pas d’accès séquentiel ordonné garanti.

[!IMPORTANT] définir clairement la clé, éviter les doublons, privilégier les recherches par clé.