This is a test message to test the length of the message box.
Login
ABAP Quick Performance INSERT vs VALUE
Erstellt von Software-Heroes

ABAP Tipp - Performance INSERT vs VALUE

In diesem Artikel schauen wir uns einmal die Performance der Einfüge-Operationen APPEND, INSERT und VALUE im Hinblick auf Tabellen an und bewerten die Performance und Stabilität bei der Entwicklung.

Werbung

Neben Append und Insert kannst du mittlerweile auch Value verwenden, um Zeilen an eine Tabelle zu hängen oder bei sortierten Tabellen einzufügen. Dazu wollen wir uns einmal die Performance beim Anfügen von Datensätzen anschauen und einen automatisierten Test machen. Zum Vergleich haben wir auch den "alten" Append aufgenommen, um hier vielleicht weitere Unterschiede zu ermitteln.

 

Aufbau

Für die Durchführung des Tests verwenden wir eine Console-Application und legen für jeden Testfall eine Methode an. Die Erzeugung und Haltung der Daten geschieht in der Methode, sodass nach verlassen der Methode der Garbage-Collector die alten Variablen aufräumen kann und so den Speicher freigibt. Die Laufzeitmessung geschieht außerhalb dieser Methode in MAIN. Für den Test haben wir jeweils eine kleine und eine große Tabelle vorgesehen, die jeweils eine unterschiedliche Komplexität darstellen.

TYPES:
  BEGIN OF ts_small,
    integer TYPE i,
    text    TYPE c LENGTH 35,
  END OF ts_small,
  tt_small        TYPE STANDARD TABLE OF ts_small WITH EMPTY KEY,
  tt_small_sorted TYPE SORTED TABLE OF ts_small WITH UNIQUE KEY integer,

  BEGIN OF ts_big,
    integer TYPE i,
    text    TYPE c LENGTH 35,
    ltext   TYPE string,
    amt     TYPE p LENGTH 15 DECIMALS 2,
    curr    TYPE waers,
    tab     TYPE string_table,
  END OF ts_big,
  tt_big        TYPE STANDARD TABLE OF ts_big WITH EMPTY KEY,
  tt_big_sorted TYPE SORTED TABLE OF ts_big WITH UNIQUE KEY integer.

 

Zur Erzeugung der einzelnen gefüllten Zeilen (Struktur), stellen wir zwei Hilfsmethoden zur Verfügung die uns unterschiedliche Zeilen an Hand des Index zur Verfügung stellen, sodass die eingefügten Daten nicht immer gleich sind. Die große Struktur besitzt zusätzlich noch eine tiefe Struktur, da wir eine String-Tabelle zur Verfügung stellen.

METHOD create_small_line.
  rs_result-integer = id_index.
  rs_result-text = |Text for number { id_index }|.
ENDMETHOD.


METHOD create_big_line.
  rs_result-integer = id_index.
  rs_result-text = |Text for number { id_index }|.
  rs_result-ltext = |Some longtext with the number { id_index }. Add this to your table|.
  rs_result-amt = CONV #( id_index ).
  rs_result-curr = 'EUR'.
  rs_result-tab = VALUE #( FOR ld_x = 1 THEN ld_x + 1 WHILE ld_x < 5 ( |Entry { ld_x }| ) ).
ENDMETHOD.

 

Für die Laufzeitmessung verwenden wir die Klasse CL_ABAP_RUNTIME die uns eine Startzeit zur Verfügung stellt und wir diese von den Endzeit subtrahieren können. Diesen Output geben wir dann direkt in die Console von Eclipse aus. An dieser Stelle hast du die Möglichkeit einen Timer mit hoher oder niedriger Genauigkeit zu generieren.

DATA(lo_timer) = cl_abap_runtime=>create_hr_timer( ).

DATA(ld_start) = lo_timer->get_runtime( ).
" Run test method
out->write( |TEST_METHOD_NAME: { lo_timer->get_runtime( ) - ld_start }| ).

 

Test

Die Tests führen wir entsprechend drei Mal durch und bestimmen den Mittelwert als Ergebnis für die Performance Messung. In den Screenshots könnt ihr die einzelnen Werte noch einmal im Detail sehen und wie sie sich für die entsprechenden Tabellengrößen verhalten.

 

Die Ergebnisse der Performance Messung im Durchschnitt sehen dann wie folgt aus. Die Werte wurden entsprechend in Sekunden umgerechnet, um leichter vergleichbar zu sein:

Art des Tests APPEND INSERT VALUE
Standard Tabelle (klein) 5,06 5,06 5,87
Standard Tabelle (groß) 36,3 109,5 116,9
Sortierte Tabelle (klein) 6,60 6,31 7,54
Sortierte Tabelle (groß) 110,4 110,3 115,7

 

Der Value Befehl schneidet in fast allen Fällen etwas schlechter ab und weist eine schlechtere Performance gegenüber dem Insert auf. Zwischen Insert und Append gibt es kaum Unterschiede, außer wir betrachten uns die Zeit beim Anhängen von komplexen und großen Strukturen an eine Standard Tabelle. Hier kann Append mit mehr als 50% Laufzeitgewinn punkten und hängt die anderen beiden Statements ab. Bei der Verwendung einer sortierten Tabelle, kommt es aber kaum noch zu Abweichungen.

 

Hinweis: In unserem Beispiel verwenden wir einen APPEND auf eine sortierte Tabelle mit Schlüssel. Dies funktioniert nur, da der Schlüssel der Tabelle in aufsteigend sortierter Form angehangen wird (SY-INDEX). Für unser Beispiel ist es ausreichend, du solltest aber niemals einen Append an eine sortierte Tabelle vornehmen, da es sonst zu einer Ausnahme (Schlüsselverletzung) kommt.

 

Beispiel

Hier noch einmal die vollständige Klasse zur Nachstellung des Tests. Über die Konstante C_LOOP_VALUE kann die Anzahl der erzeugten Datensätze reguliert werden. Bei ca. 7,5 Millionen Einträgen in der Testtabelle ging dem Prozess aber auf unserem System der Speicher aus und es kam zu einem Abbruch, daher haben wir den Wert auf 5 Millionen gestellt.

CLASS zcl_test_table_performance DEFINITION PUBLIC FINAL CREATE PUBLIC.
  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.

  PROTECTED SECTION.
  PRIVATE SECTION.
    CONSTANTS:
      c_loop_value TYPE i VALUE 5000000.

    TYPES:
      BEGIN OF ts_small,
        integer TYPE i,
        text    TYPE c LENGTH 35,
      END OF ts_small,
      tt_small        TYPE STANDARD TABLE OF ts_small WITH EMPTY KEY,
      tt_small_sorted TYPE SORTED TABLE OF ts_small WITH UNIQUE KEY integer,

      BEGIN OF ts_big,
        integer TYPE i,
        text    TYPE c LENGTH 35,
        ltext   TYPE string,
        amt     TYPE p LENGTH 15 DECIMALS 2,
        curr    TYPE waers,
        tab     TYPE string_table,
      END OF ts_big,
      tt_big        TYPE STANDARD TABLE OF ts_big WITH EMPTY KEY,
      tt_big_sorted TYPE SORTED TABLE OF ts_big WITH UNIQUE KEY integer.

    METHODS:
      create_small_line
        IMPORTING
                  id_index         TYPE i
        RETURNING VALUE(rs_result) TYPE ts_small,

      create_big_line
        IMPORTING
                  id_index         TYPE i
        RETURNING VALUE(rs_result) TYPE ts_big,

      test_append_small,
      test_append_big,
      test_insert_small,
      test_insert_big,
      test_value_small,
      test_value_big,

      sort_append_small,
      sort_append_big,
      sort_insert_small,
      sort_insert_big,
      sort_value_small,
      sort_value_big.
ENDCLASS.


CLASS zcl_test_table_performance IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    DATA(lo_timer) = cl_abap_runtime=>create_hr_timer( ).

    DATA(ld_start) = lo_timer->get_runtime( ).
    test_append_small( ).
    out->write( |TEST_APPEND_SMALL: { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    test_insert_small( ).
    out->write( |TEST_INSERT_SMALL: { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    test_value_small( ).
    out->write( |TEST_VALUE_SMALL : { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    test_append_big( ).
    out->write( |TEST_APPEND_BIG  : { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    test_insert_big( ).
    out->write( |TEST_INSERT_BIG  : { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    test_value_big( ).
    out->write( |TEST_VALUE_BIG   : { lo_timer->get_runtime( ) - ld_start }| ).


    ld_start = lo_timer->get_runtime( ).
    sort_append_small( ).
    out->write( |SORT_APPEND_SMALL: { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    sort_insert_small( ).
    out->write( |SORT_INSERT_SMALL: { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    sort_value_small( ).
    out->write( |SORT_VALUE_SMALL : { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    sort_append_big( ).
    out->write( |SORT_APPEND_BIG  : { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    sort_insert_big( ).
    out->write( |SORT_INSERT_BIG  : { lo_timer->get_runtime( ) - ld_start }| ).

    ld_start = lo_timer->get_runtime( ).
    sort_value_big( ).
    out->write( |SORT_VALUE_BIG   : { lo_timer->get_runtime( ) - ld_start }| ).
  ENDMETHOD.


  METHOD create_small_line.
    rs_result-integer = id_index.
    rs_result-text = |Text for number { id_index }|.
  ENDMETHOD.


  METHOD create_big_line.
    rs_result-integer = id_index.
    rs_result-text = |Text for number { id_index }|.
    rs_result-ltext = |Some longtext with the number { id_index }. Add this to your table|.
    rs_result-amt = CONV #( id_index ).
    rs_result-curr = 'EUR'.
    rs_result-tab = VALUE #( FOR ld_x = 1 THEN ld_x + 1 WHILE ld_x < 5 ( |Entry { ld_x }| ) ).
  ENDMETHOD.


  METHOD test_append_small.
    DATA:
      lt_table TYPE tt_small.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_small_line( sy-index ).
      APPEND ls_line TO lt_table.
    ENDDO.
  ENDMETHOD.


  METHOD test_append_big.
    DATA:
      lt_table TYPE tt_big.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_big_line( sy-index ).
      APPEND ls_line TO lt_table.
    ENDDO.
  ENDMETHOD.


  METHOD test_insert_small.
    DATA:
      lt_table TYPE tt_small.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_small_line( sy-index ).
      INSERT ls_line INTO TABLE lt_table.
    ENDDO.
  ENDMETHOD.


  METHOD test_insert_big.
    DATA:
      lt_table TYPE tt_big.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_big_line( sy-index ).
      INSERT ls_line INTO TABLE lt_table.
    ENDDO.
  ENDMETHOD.


  METHOD test_value_small.
    DATA:
      lt_table TYPE tt_small.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_small_line( sy-index ).
      lt_table = VALUE #( BASE lt_table ( integer = ls_line-integer text = ls_line-text ) ).
    ENDDO.
  ENDMETHOD.


  METHOD test_value_big.
    DATA:
      lt_table TYPE tt_big.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_big_line( sy-index ).
      lt_table = VALUE #( BASE lt_table (
        integer = ls_line-integer
        text = ls_line-text
        ltext = ls_line-ltext
        amt = ls_line-amt
        curr = ls_line-curr
        tab = ls_line-tab
      ) ).
    ENDDO.
  ENDMETHOD.


  METHOD sort_append_small.
    DATA:
      lt_table TYPE tt_small_sorted.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_small_line( sy-index ).
      APPEND ls_line TO lt_table.
    ENDDO.
  ENDMETHOD.


  METHOD sort_append_big.
    DATA:
      lt_table TYPE tt_big_sorted.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_big_line( sy-index ).
      APPEND ls_line TO lt_table.
    ENDDO.
  ENDMETHOD.


  METHOD sort_insert_small.
    DATA:
      lt_table TYPE tt_small_sorted.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_small_line( sy-index ).
      INSERT ls_line INTO TABLE lt_table.
    ENDDO.
  ENDMETHOD.


  METHOD sort_insert_big.
    DATA:
      lt_table TYPE tt_big_sorted.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_big_line( sy-index ).
      INSERT ls_line INTO TABLE lt_table.
    ENDDO.
  ENDMETHOD.


  METHOD sort_value_small.
    DATA:
      lt_table TYPE tt_small_sorted.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_small_line( sy-index ).
      lt_table = VALUE #( BASE lt_table ( integer = ls_line-integer text = ls_line-text ) ).
    ENDDO.
  ENDMETHOD.


  METHOD sort_value_big.
    DATA:
      lt_table TYPE tt_big_sorted.

    DO c_loop_value TIMES.
      DATA(ls_line) = create_big_line( sy-index ).
      lt_table = VALUE #( BASE lt_table (
        integer = ls_line-integer
        text = ls_line-text
        ltext = ls_line-ltext
        amt = ls_line-amt
        curr = ls_line-curr
        tab = ls_line-tab
      ) ).
    ENDDO.
  ENDMETHOD.
ENDCLASS.

 

Fazit

Der VALUE Befehl ist zwar sehr umfangreich und bietet viele neue Features, doch kann man bei der Übernahme der Datensätze weiterhin getrost INSERT verwenden, um auch auf der sicheren und stabilen Seite zu bleiben und den Performancevorteil mitnehmen. Von APPEND raten wir mittlerweile grundsätzlich ab, da sich im Laufe der Entwicklung der Tabellentyp verändern kann und man sich somit nachträgliche Änderungen am Quellcode spart. Mehr dazu erfährst du in einem anderen Artikel von uns.


Enthaltene Themen:
TippINSERTVALUEAPPENDPerformance
Kommentare (0)
Werbung

ABAP Tipp - Aufbau von Testdaten

Kategorie - ABAP

Welche Herausforderungen hat man beim Aufbau von Testtabellen und Testdaten und wie kann dir die maschinelle Verarbeitung dabei helfen.

25.06.2021

ABAP Tipp - RFC Puffer

Kategorie - ABAP

Hier ein kleiner Tipp von uns, was beim Lesen über RFC mit dem Puffer so alles schief gehen kann und auf was du dabei unbedingt achten solltest.

23.04.2021

ABAP Tipp - Wait for Task

Kategorie - ABAP

Heute einmal einen Tipp für die asynchrone Verarbeitung oder wenn ihr in speziellen Situationen die Verarbeitung in einen separaten Task geben wollt. Wie geht es im Anschluss weiter?

05.03.2021

ABAP Tipp - Suche im Quellcode

Kategorie - ABAP

Manchmal ist die Suche über verschiedene Quellcode in einem System nötig. Wir zeigen dir wie es in der SAP GUI und in Eclipse funktioniert.

24.04.2020

ABAP Tipp - Icons

Kategorie - ABAP

Icons oder auch Ikonen in SAP finden und richtig nutzen? Hier ein kleiner Guide zum Umgang mit den Bildern für unterschiedliche Zwecke.

06.03.2020