ABAP MOVE-CORRESPONDING : Copier des valeurs entre structures/tables par noms de champs identiques

Catégorie
ABAP-Statements
Publié
Auteur
Johannes

L’instruction MOVE-CORRESPONDING sert a copier des valeurs entre deux structures ou deux tables internes, en ne considerant que les composants (champs) dont les noms correspondent exactement dans la source et la cible. Les composants avec des noms differents ou les composants qui n’existent que dans la source ou que dans la cible sont ignores. La condition prealable pour la copie est aussi que les types de donnees des composants de meme nom soient compatibles pour l’affectation.

Syntaxe

1. Entre structures

MOVE-CORRESPONDING <structure_source> TO <structure_cible>
                  [EXPANDING NESTED TABLES]
                  [KEEPING TARGET LINES]. " Rarement utile pour les structures

2. Entre tables internes

MOVE-CORRESPONDING <table_source> TO <table_cible>
                  [EXPANDING NESTED TABLES]
                  [KEEPING TARGET LINES].

Clauses importantes

  • EXPANDING NESTED TABLES : Cette clause est importante lorsque les structures ou les lignes des tables contiennent elles-memes des tables internes comme composants portant le meme nom. Avec EXPANDING NESTED TABLES, le contenu de ces tables imbriquees de meme nom est egalement copie selon la logique de MOVE-CORRESPONDING (eventuellement de maniere recursive). Sans cette clause, ces composants de type table sont generalement ignores (exception : types reference).
  • KEEPING TARGET LINES (Principalement pertinent pour les tables internes) : Empeche la suppression par defaut de la table cible <table_cible> avant l’operation de copie. Au lieu de cela, les valeurs des lignes de <table_source> sont transferees dans les champs de meme nom des lignes deja existantes de <table_cible>. Cela se fait ligne par ligne en fonction de l’index. S’il y a plus de lignes dans la table source que dans la table cible, les lignes source excedentaires sont ignorees. S’il y a plus de lignes dans la table cible, les valeurs dans les champs correspondants des lignes cible excedentaires restent inchangees.
  • PERCENTAGE (Obsolete) : Cette clause est obsolete et ne devrait plus etre utilisee.

Fonctionnement

  1. Comparaison des noms : Le systeme identifie tous les composants au niveau superieur de la source et de la cible qui portent le meme nom. Pour les tables, cela concerne les composants de la structure de ligne.
  2. Compatibilite des types : Pour chaque paire de composants de meme nom, on verifie si leurs types de donnees sont compatibles selon les regles d’affectation ABAP. Une affectation est possible si les types sont identiques ou si une conversion implicite est autorisee (par ex. C vers STRING, I vers P). Pour les structures profondes, les types des sous-structures de meme nom doivent aussi etre compatibles.
  3. Transfert de valeurs : Si les noms correspondent et les types sont compatibles, la valeur est copiee du composant source vers le composant cible.
  4. Comportement pour les tables (Standard) : Lorsque MOVE-CORRESPONDING est applique aux tables internes sans la clause KEEPING TARGET LINES, voici ce qui se passe :
    • La table cible est implicitement videe (CLEAR ziel_tabelle.).
    • Le systeme itere sur les lignes de la table source.
    • Pour chaque ligne source, une nouvelle ligne est creee dans la table cible, et les valeurs des composants de meme nom compatibles sont copiees de la ligne source vers la nouvelle ligne cible.
    • La nouvelle ligne cible est ajoutee a la table cible (APPEND).

Alternative moderne : L’operateur CORRESPONDING (depuis ABAP 7.40)

Pour les nouveaux developpements, il est fortement recommande d’utiliser l’operateur CORRESPONDING. Il est plus flexible, plus puissant et s’integre mieux dans la syntaxe ABAP moderne.

" Affectation de structure
ziel_struktur = CORRESPONDING #( quelle_struktur ).


" Affectation de table (equivalent a MOVE-CORRESPONDING standard)
ziel_tabelle = CORRESPONDING #( quelle_tabelle ).


" Avec options (exemples) :
ziel_struktur = CORRESPONDING type_de_cible( quelle_struktur
                                           MAPPING champ_cible = champ_source " Renommer
                                           EXCEPT champ_a champ_b ).          " Exclure


ziel_tabelle = CORRESPONDING #( BASE (ziel_tabelle) quelle_tabelle ). " Similaire a KEEPING TARGET LINES

L’operateur permet un mapping explicite des champs (MAPPING), l’exclusion de champs (EXCEPT), l’utilisation d’une base (BASE pour un comportement similaire a KEEPING TARGET LINES) et peut etre utilise directement dans les affectations ou d’autres expressions.

Exemples pour MOVE-CORRESPONDING

1. Structure vers structure

TYPES: BEGIN OF type_source,
         matnr TYPE matnr,         " Numero d'article
         werks TYPE werks_d,       " Site
         menge TYPE i,            " Quantite
         extra TYPE string,        " Champ supplementaire source
       END OF type_source.


TYPES: BEGIN OF type_target,
         matnr TYPE matnr,         " Numero d'article (identique)
         werks TYPE werks_d,       " Site (identique)
         stock TYPE i,            " Quantite (nom different)
         info  TYPE string,        " Champ supplementaire cible
       END OF type_target.


DATA: source_data TYPE type_source,
      target_data TYPE type_target.


source_data-matnr = 'MAT01'.
source_data-werks = '1000'.
source_data-menge = 100.
source_data-extra = 'Info Source'.


target_data-stock = 50. " Valeur existante dans cible
target_data-info = 'Info Cible'.


WRITE: / 'Cible AVANT:', target_data-matnr, target_data-werks, target_data-stock, target_data-info.


MOVE-CORRESPONDING source_data TO target_data.


WRITE: / 'Cible APRES:', target_data-matnr, target_data-werks, target_data-stock, target_data-info.

Sortie :

Cible AVANT:             1000         50 Info Cible
Cible APRES: MAT01      1000         50 Info Cible

(Seuls matnr et werks ont ete copies car seuls ces noms correspondent. stock et info dans la cible restent inchanges, menge et extra de la source ont ete ignores).

2. Table vers table (Standard)

TYPES: BEGIN OF ty_s1, f1 TYPE i, f2 TYPE c LENGTH 2, END OF ty_s1.
TYPES: BEGIN OF ty_s2, f2 TYPE c LENGTH 2, f3 TYPE d, END OF ty_s2.
DATA: lt_source TYPE STANDARD TABLE OF ty_s1,
      lt_target TYPE STANDARD TABLE OF ty_s2.


APPEND VALUE #( f1 = 1 f2 = 'AA' ) TO lt_source.
APPEND VALUE #( f1 = 2 f2 = 'BB' ) TO lt_source.


APPEND VALUE #( f2 = 'XX' f3 = sy-datum - 1 ) TO lt_target. " Ligne existante dans cible


WRITE: / 'Lignes cible AVANT:', lines( lt_target ).


MOVE-CORRESPONDING lt_source TO lt_target.


WRITE: / 'Lignes cible APRES:', lines( lt_target ). " La cible a ete videe puis remplie
LOOP AT lt_target INTO DATA(ls_target).
  WRITE: / '-> Cible F2:', ls_target-f2, ' | Cible F3:', ls_target-f3.
ENDLOOP.

Sortie :

Lignes cible AVANT:          1
Lignes cible APRES:          2
-> Cible F2: AA  | Cible F3: 00000000
-> Cible F2: BB  | Cible F3: 00000000

(La table cible a ete videe, puis 2 lignes ont ete ajoutees, seul le champ f2 a ete copie).

3. Table vers table avec KEEPING TARGET LINES

" ... remplir lt_source et lt_target comme dans l'exemple 2 ...
WRITE: / 'Lignes cible AVANT (KEEPING):', lines( lt_target ).


MOVE-CORRESPONDING lt_source TO lt_target KEEPING TARGET LINES.


WRITE: / 'Lignes cible APRES (KEEPING):', lines( lt_target ). " Le nombre reste identique
LOOP AT lt_target INTO DATA(ls_target_k).
  WRITE: / '-> Cible F2:', ls_target_k-f2, ' | Cible F3:', ls_target_k-f3.
ENDLOOP.

Sortie :

Lignes cible AVANT (KEEPING):          1
Lignes cible APRES (KEEPING):          1
-> Cible F2: AA  | Cible F3: <Date d'hier>

(La table cible conserve ses lignes. Seul pour la premiere ligne, f2 est copie depuis la premiere ligne de la source. f3 reste intouche. La deuxieme ligne de la source est ignoree car la cible n’a qu’une seule ligne).

Remarques importantes / Bonnes pratiques

  • MOVE-CORRESPONDING est utile lorsque de nombreux champs correspondent et que vous voulez economiser de la saisie.
  • Risque : Cela peut conduire a des resultats inattendus si les correspondances de noms sont involontaires ou si vous perdez la vue d’ensemble de quels champs sont reellement copies. Les champs manquants dans la cible ne sont pas automatiquement crees.
  • Faites attention a la compatibilite des types pour eviter les erreurs d’execution ou les conversions indesirables.
  • Pour les tres grandes tables, la performance peut etre moins bonne comparee aux affectations ciblees ou a l’operateur CORRESPONDING.
  • Recommandation : Utilisez pour les nouveaux developpements l’operateur CORRESPONDING plus flexible et souvent plus clair. MOVE-CORRESPONDING reste cependant pertinent pour comprendre et maintenir le code plus ancien.