ABAP Memory Management : EXPORT, IMPORT, Shared Memory

Catégorie

ABAP-Statements

Publié

24. Nov. 2025

Auteur

Le Memory Management en ABAP permet l’échange de données entre programmes. Il existe différentes zones mémoire : ABAP Memory, SAP Memory, Cluster de base de données et Shared Objects.

Zones mémoire

Zone	Durée de vie	Utilisation
ABAP Memory	Session (Call Stack)	Entre CALL TRANSACTION
SAP Memory	Session utilisateur	Entre transactions
Database Cluster	Persistant	Au-delà des sessions
Shared Objects	Serveur d’application	Entre utilisateurs

Exemples

1. ABAP Memory (EXPORT/IMPORT TO MEMORY)

" Programme 1 : Exporter des données
DATA: ls_customer TYPE kna1,
      lt_orders   TYPE TABLE OF vbak.

" Préparer les données
ls_customer-kunnr = '0000001000'.
ls_customer-name1 = 'Mustermann GmbH'.

" Exporter vers ABAP Memory
EXPORT customer = ls_customer
       orders   = lt_orders
  TO MEMORY ID 'ZCUSTOMER_DATA'.


" Programme 2 : Importer des données (après CALL TRANSACTION)
DATA: ls_customer TYPE kna1,
      lt_orders   TYPE TABLE OF vbak.

IMPORT customer = ls_customer
       orders   = lt_orders
  FROM MEMORY ID 'ZCUSTOMER_DATA'.

IF sy-subrc = 0.
  WRITE: / 'Client :', ls_customer-name1.
ENDIF.

" Libérer la mémoire
FREE MEMORY ID 'ZCUSTOMER_DATA'.

2. SAP Memory (SET/GET PARAMETER)

" SAP Memory pour le préremplissage de champs
" Les Parameter-IDs sont définis dans le Data Dictionary

" Définir une valeur
SET PARAMETER ID 'KUN' FIELD '0000001000'.
SET PARAMETER ID 'BUK' FIELD '1000'.

" Lire une valeur
DATA: lv_kunnr TYPE kunnr,
      lv_bukrs TYPE bukrs.

GET PARAMETER ID 'KUN' FIELD lv_kunnr.
GET PARAMETER ID 'BUK' FIELD lv_bukrs.

WRITE: / 'Client :', lv_kunnr,
       / 'Société :', lv_bukrs.


" Appeler une transaction avec des valeurs préremplies
SET PARAMETER ID 'KUN' FIELD '0000001000'.
CALL TRANSACTION 'XD03' AND SKIP FIRST SCREEN.

3. Cluster de base de données (EXPORT/IMPORT TO DATABASE)

" Stockage persistant au-delà des sessions
" Table : INDX ou table cluster personnalisée

DATA: ls_settings TYPE ty_settings.

ls_settings-user    = sy-uname.
ls_settings-variant = 'DEFAULT'.
ls_settings-values  = lt_values.

" Sauvegarder dans la base de données
EXPORT settings = ls_settings
  TO DATABASE indx(zs)           " Table INDX, Area 'ZS"
  ID |SETTINGS_{ sy-uname }|.    " Clé unique


" Lire plus tard
DATA: ls_settings TYPE ty_settings.

IMPORT settings = ls_settings
  FROM DATABASE indx(zs)
  ID |SETTINGS_{ sy-uname }|.

IF sy-subrc = 0.
  " Settings trouvés
  WRITE: / 'Variante :', ls_settings-variant.
ENDIF.


" Supprimer
DELETE FROM DATABASE indx(zs)
  ID |SETTINGS_{ sy-uname }|.

4. Table cluster personnalisée

" Créer une table dans SE11 :
" Nom : ZCUSTOM_CLUSTER
" Champs :
"   - RELID (CHAR 2) - Area
"   - SRTFD (CHAR 40) - ID/Clé
"   - Champs cluster (CLUSTR, CLUSTD)

" Utilisation
EXPORT data = ls_data
  TO DATABASE zcustom_cluster(AA)
  ID lv_key.

IMPORT data = ls_data
  FROM DATABASE zcustom_cluster(AA)
  ID lv_key.

5. Shared Objects (Cache du serveur d’application)

" 1. Définir une classe Area (SE24)
CLASS zcl_shared_area DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC
  SHARED MEMORY ENABLED.

  PUBLIC SECTION.
    INTERFACES: if_shm_build_instance.

    DATA: mt_customers TYPE HASHED TABLE OF kna1 WITH UNIQUE KEY kunnr.

    METHODS: load_customers.
ENDCLASS.

CLASS zcl_shared_area IMPLEMENTATION.
  METHOD if_shm_build_instance~build.
    " Appelé lorsque l'Area est construite
    DATA(lo_area) = CAST zcl_shared_area( bound_memory ).
    lo_area->load_customers( ).
  ENDMETHOD.

  METHOD load_customers.
    SELECT * FROM kna1
      INTO TABLE mt_customers
      UP TO 10000 ROWS.
  ENDMETHOD.
ENDCLASS.


" 2. Créer une Shared Memory Area dans SHMA
" Nom : ZSM_CUSTOMER_CACHE
" Classe Root : ZCL_SHARED_AREA


" 3. Utilisation
DATA: lo_area   TYPE REF TO zcl_shared_area,
      lo_handle TYPE REF TO zcl_sm_customer_cache.

TRY.
    " Accès en lecture
    lo_handle = zcl_sm_customer_cache=>attach_for_read( ).
    lo_area = CAST zcl_shared_area( lo_handle->root ).

    " Utiliser les données
    READ TABLE lo_area->mt_customers INTO DATA(ls_customer)
      WITH KEY kunnr = '0000001000'.

    lo_handle->detach( ).

  CATCH cx_shm_attach_error INTO DATA(lx_error).
    " L'Area n'existe pas encore -> construire
    TRY.
        zcl_sm_customer_cache=>build(
          EXPORTING
            inst_name = zcl_sm_customer_cache=>default_instance
        ).
      CATCH cx_shm_build_error.
    ENDTRY.
ENDTRY.

6. Mémoire entre CALL TRANSACTION

" Programme principal
DATA: ls_order TYPE vbak.

ls_order-vbeln = '0000000001'.
ls_order-kunnr = '0000001000'.

" Fournir des données pour le programme appelé
EXPORT order = ls_order TO MEMORY ID 'ZORDER_EDIT'.

" Appeler la transaction
CALL TRANSACTION 'ZORDER_CHANGE'.

" Après le retour : Lire les données modifiées
IMPORT order = ls_order FROM MEMORY ID 'ZORDER_EDIT'.
FREE MEMORY ID 'ZORDER_EDIT'.


" Programme appelé (ZORDER_CHANGE)
DATA: ls_order TYPE vbak.

IMPORT order = ls_order FROM MEMORY ID 'ZORDER_EDIT'.

" Traitement...

" Retourner les données modifiées
EXPORT order = ls_order TO MEMORY ID 'ZORDER_EDIT'.

LEAVE PROGRAM.

7. Classe Memory Helper

CLASS zcl_memory_helper DEFINITION.
  PUBLIC SECTION.
    " ABAP Memory
    CLASS-METHODS: export_to_memory
      IMPORTING iv_id   TYPE clike
                iv_data TYPE any.

    CLASS-METHODS: import_from_memory
      IMPORTING iv_id           TYPE clike
      EXPORTING ev_data         TYPE any
      RETURNING VALUE(rv_found) TYPE abap_bool.

    CLASS-METHODS: free_memory
      IMPORTING iv_id TYPE clike.

    " SAP Memory
    CLASS-METHODS: set_parameter
      IMPORTING iv_id    TYPE clike
                iv_value TYPE clike.

    CLASS-METHODS: get_parameter
      IMPORTING iv_id          TYPE clike
      RETURNING VALUE(rv_value) TYPE string.

    " Database Cluster
    CLASS-METHODS: save_to_db
      IMPORTING iv_id   TYPE clike
                iv_data TYPE any.

    CLASS-METHODS: load_from_db
      IMPORTING iv_id           TYPE clike
      EXPORTING ev_data         TYPE any
      RETURNING VALUE(rv_found) TYPE abap_bool.

    CLASS-METHODS: delete_from_db
      IMPORTING iv_id TYPE clike.
ENDCLASS.

CLASS zcl_memory_helper IMPLEMENTATION.
  METHOD export_to_memory.
    EXPORT data = iv_data TO MEMORY ID iv_id.
  ENDMETHOD.

  METHOD import_from_memory.
    IMPORT data = ev_data FROM MEMORY ID iv_id.
    rv_found = xsdbool( sy-subrc = 0 ).
  ENDMETHOD.

  METHOD free_memory.
    FREE MEMORY ID iv_id.
  ENDMETHOD.

  METHOD set_parameter.
    SET PARAMETER ID iv_id FIELD iv_value.
  ENDMETHOD.

  METHOD get_parameter.
    GET PARAMETER ID iv_id FIELD rv_value.
  ENDMETHOD.

  METHOD save_to_db.
    DATA(lv_id) = CONV indx_srtfd( iv_id ).
    EXPORT data = iv_data TO DATABASE indx(zm) ID lv_id.
    COMMIT WORK.
  ENDMETHOD.

  METHOD load_from_db.
    DATA(lv_id) = CONV indx_srtfd( iv_id ).
    IMPORT data = ev_data FROM DATABASE indx(zm) ID lv_id.
    rv_found = xsdbool( sy-subrc = 0 ).
  ENDMETHOD.

  METHOD delete_from_db.
    DATA(lv_id) = CONV indx_srtfd( iv_id ).
    DELETE FROM DATABASE indx(zm) ID lv_id.
    COMMIT WORK.
  ENDMETHOD.
ENDCLASS.


" Utilisation
" ABAP Memory
 zcl_memory_helper=>export_to_memory(
  iv_id   = 'MY_DATA"
  iv_data = ls_data
).

IF zcl_memory_helper=>import_from_memory(
     iv_id   = 'MY_DATA"
     IMPORTING ev_data = ls_data
   ) = abap_true.
  " Données trouvées
ENDIF.

" Database
zcl_memory_helper=>save_to_db(
  iv_id   = |USER_{ sy-uname }_SETTINGS|
  iv_data = ls_settings
).

8. Paramètres spécifiques à l’utilisateur

CLASS zcl_user_settings DEFINITION.
  PUBLIC SECTION.
    TYPES: BEGIN OF ty_settings,
             layout   TYPE string,
             pagesize TYPE i,
             filters  TYPE string,
           END OF ty_settings.

    METHODS: constructor
      IMPORTING iv_program TYPE sy-repid DEFAULT sy-repid.

    METHODS: load
      RETURNING VALUE(rs_settings) TYPE ty_settings.

    METHODS: save
      IMPORTING is_settings TYPE ty_settings.

    METHODS: delete.

  PRIVATE SECTION.
    DATA: mv_id TYPE indx_srtfd.
ENDCLASS.

CLASS zcl_user_settings IMPLEMENTATION.
  METHOD constructor.
    mv_id = |{ iv_program }_{ sy-uname }|.
  ENDMETHOD.

  METHOD load.
    IMPORT settings = rs_settings
      FROM DATABASE indx(us)
      ID mv_id.

    IF sy-subrc <> 0.
      " Valeurs par défaut
      rs_settings-pagesize = 100.
    ENDIF.
  ENDMETHOD.

  METHOD save.
    EXPORT settings = is_settings
      TO DATABASE indx(us)
      ID mv_id.
    COMMIT WORK.
  ENDMETHOD.

  METHOD delete.
    DELETE FROM DATABASE indx(us) ID mv_id.
    COMMIT WORK.
  ENDMETHOD.
ENDCLASS.


" Utilisation
DATA(lo_settings) = NEW zcl_user_settings( ).
DATA(ls_settings) = lo_settings->load( ).

" Modifier les paramètres
ls_settings-pagesize = 50.
lo_settings->save( ls_settings ).

9. Cache inter-sessions

" Shared Memory pour données de base fréquemment utilisées

" Classe Area Root
CLASS zcl_material_cache DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC
  SHARED MEMORY ENABLED.

  PUBLIC SECTION.
    INTERFACES: if_shm_build_instance.

    TYPES: ty_materials TYPE HASHED TABLE OF mara WITH UNIQUE KEY matnr.

    DATA: mt_materials TYPE ty_materials,
          mv_loaded_at TYPE timestampl.

    METHODS: get_material
      IMPORTING iv_matnr         TYPE matnr
      RETURNING VALUE(rs_material) TYPE mara.

    METHODS: is_expired
      RETURNING VALUE(rv_expired) TYPE abap_bool.
ENDCLASS.

CLASS zcl_material_cache IMPLEMENTATION.
  METHOD if_shm_build_instance~build.
    DATA(lo_root) = CAST zcl_material_cache( bound_memory ).

    SELECT * FROM mara
      INTO TABLE lo_root->mt_materials
      WHERE mtart IN ('FERT', 'HALB', 'ROH').

    GET TIME STAMP FIELD lo_root->mv_loaded_at.
  ENDMETHOD.

  METHOD get_material.
    READ TABLE mt_materials INTO rs_material
      WITH KEY matnr = iv_matnr.
  ENDMETHOD.

  METHOD is_expired.
    DATA: lv_now TYPE timestampl.
    GET TIME STAMP FIELD lv_now.

    " Invalider le cache après 1 heure
    rv_expired = xsdbool(
      lv_now - mv_loaded_at > 3600
    ).
  ENDMETHOD.
ENDCLASS.


" Utilisation
DATA: lo_handle TYPE REF TO zcl_sm_material,
      lo_cache  TYPE REF TO zcl_material_cache.

TRY.
    lo_handle = zcl_sm_material=>attach_for_read( ).
    lo_cache = lo_handle->root.

    " Vérifier la validité du cache
    IF lo_cache->is_expired( ).
      lo_handle->detach( ).
      zcl_sm_material=>invalidate_instance( ).
      " Au prochain accès, il sera reconstruit
    ELSE.
      DATA(ls_material) = lo_cache->get_material( lv_matnr ).
      lo_handle->detach( ).
    ENDIF.

  CATCH cx_shm_attach_error.
    " Fallback : Directement depuis la DB
    SELECT SINGLE * FROM mara
      WHERE matnr = @lv_matnr
      INTO @ls_material.
ENDTRY.

10. EXPORT/IMPORT avec compression

" Pour de grandes quantités de données : Compression
DATA: lt_big_table TYPE TABLE OF vbak,
      lv_xstring   TYPE xstring.

" Données dans XString compressé
EXPORT data = lt_big_table
  TO DATA BUFFER lv_xstring
  COMPRESSION ON.

" Sauvegarder dans la DB
UPDATE zcache SET data = lv_xstring
  WHERE id = lv_id.


" Recharger
SELECT SINGLE data FROM zcache
  WHERE id = @lv_id
  INTO @lv_xstring.

IMPORT data = lt_big_table
  FROM DATA BUFFER lv_xstring.

11. Libérer la mémoire en cas d’erreur

" TRY-CLEANUP pour un nettoyage propre
DATA: lv_memory_id TYPE c LENGTH 30 VALUE 'ZTEMP_DATA'.

TRY.
    EXPORT data = ls_data TO MEMORY ID lv_memory_id.

    " Traitement pouvant échouer
    process_data( ).

    " Libération normale
    FREE MEMORY ID lv_memory_id.

  CATCH cx_root INTO DATA(lx_error).
    " Libérer aussi en cas d'erreur
    FREE MEMORY ID lv_memory_id.
    RAISE EXCEPTION lx_error.
ENDTRY.


" Ou avec CLEANUP
TRY.
    EXPORT data = ls_data TO MEMORY ID lv_memory_id.
    process_data( ).

  CLEANUP.
    " Exécuté automatiquement en cas d'exception
    FREE MEMORY ID lv_memory_id.
ENDTRY.

12. Transfert de données vers un report

" Programme principal : Transférer des données à un report
DATA: lt_selections TYPE TABLE OF rsparams.

" Exporter les données
EXPORT selections = lt_selections
  TO MEMORY ID 'ZREPORT_DATA'.

" Appeler le report
SUBMIT zreport_process AND RETURN.

" Récupérer le résultat
DATA: lt_results TYPE ty_result_tab.
IMPORT results = lt_results
  FROM MEMORY ID 'ZREPORT_RESULTS'.

FREE MEMORY ID 'ZREPORT_DATA'.
FREE MEMORY ID 'ZREPORT_RESULTS'.


" Report (ZREPORT_PROCESS)
DATA: lt_selections TYPE TABLE OF rsparams,
      lt_results    TYPE ty_result_tab.

" Données de l'appelant
IMPORT selections = lt_selections
  FROM MEMORY ID 'ZREPORT_DATA'.

" Traitement...

" Retourner le résultat
EXPORT results = lt_results
  TO MEMORY ID 'ZREPORT_RESULTS'.

Vue d’ensemble des zones mémoire

Méthode	Syntaxe	Zone
`EXPORT TO MEMORY`	ID ‘xyz’	ABAP Memory
`SET PARAMETER`	ID ‘PAR’	SAP Memory
`EXPORT TO DATABASE`	indx(xx) ID ‘xyz’	DB Cluster
`EXPORT TO DATA BUFFER`	xstring	Variable
Shared Memory	CL_SHM_AREA	Serveur d’application

Remarques importantes / Best Practice

Appeler FREE MEMORY lorsque les données ne sont plus nécessaires.
Utiliser des IDs uniques (par ex. avec programme/utilisateur).
ABAP Memory uniquement au sein d’une Call Stack.
SAP Memory pour le préremplissage de champs (Parameter-IDs).
Database Cluster pour les données persistantes.
Shared Objects pour le caching à l’échelle du serveur.
COMPRESSION ON pour de grandes quantités de données.
CLEANUP pour le nettoyage en cas d’exceptions.
Les IDs mémoire ne doivent pas être trop longs (max. 72 caractères).
Combinez avec Background Jobs pour le transfert de données.