So you’re an experienced ABAP programmer wanting to leverage off the fantastic new functionality available to you in ABAP 7.40!

However, searching for information on this topic leads you to fragmented pages or blogs that refer to only a couple of the new features available to you.

What you need is a quick reference guide which gives you the essentials you need and shows you how the code you are familiar with can be improved with ABAP 7.40.

The below document contains exactly this!

It gives examples of “classic” ABAP and its 740 equivalent. It goes into more details on the more difficult topics normally via examples. This allows the reader to dive in to the level they desire. While this document does not contain everything pertaining to ABAP 740 it certainly covers the most useful parts in the experience of the author.

The document has been compiled by drawing on existing material available online as well as trial and error by the author. In particular the blogs by Horst Keller have been useful and are the best reference I have found (prior to this document ). He has a landing page of sorts for his various blogs on the topic here:

ABAP Language News for Release 7.40

Credit also goes to Naimesh Patel for his useful explanations and examples on ABAP 7.40. Here is his example of the “FOR iteration expression” which I leaned on (links to his other 740 articles can be found at the bottom of the link):

http://zevolving.com/2015/05/abap-740-for-iteration-expression/

I compiled the below document to make the transition to using ABAP 740 easier for myself and my project team. It has worked well for us and I hope it will do the same for you.

Regards,

Jeff Towell

ABAP 7.40 Quick Reference  

Author:

Jeffrey Towell

Created:

2015

 

Contents

1. Inline Declarations

2. Table Expressions

3. Conversion Operator CONV

     I.  Definition

     II. Example

4. Value Operator VALUE

     I.   Definition

     II.  Example for structures

     III. Examples for internal tables

5. FOR operator

     I.   Definition

     II.  Explanation

     III. Example 1

     IV. Example 2

     V. FOR with THEN and UNTIL|WHILE

6. Reduction operator REDUCE

     I.   Definition

     II.  Note

     III. Example 1

     IV. Example 2

     V.  Example 3

7. Conditional operators COND and SWITCH

     I.   Definition

     II.  Example for COND

     III. Example for SWITCH

8. CORRESPONDING operator

     I.   Definition

     II.  Example Code

     III. Output

     IV. Explanation

     V.  Additions MAPPING and EXCEPT

9.Strings

     I.   String Templates

     II.  Concatenation

     III. Width/Alignment/Padding.

     IV. Case

     V.  ALPHA conversion

     VI.  Date conversion

10. Loop at Group By

     I.   Definition

     II.  Explanation

     III. Example

     IV. Output

11. Classes/Methods

     I.   Referencing fields within returned structures

     II.  Methods that return a type BOOLEAN

     III. NEW operator

12. Meshes

     I.   Problem

     II.  Solution

     III. Output

13. Filter

     I.   Definition

     II.  Problem

     III. Solution

1. Inline Declarations

Description

Before 7.40

With 7.40

Data statement

DATA text TYPE string.
text = `ABC`.

DATA(text) = `ABC`.

Loop at into work area

DATA wa like LINE OF itab.
LOOP AT itab
INTO wa.  
  …
ENDLOOP.

LOOP AT itab INTO DATA(wa).  
 
ENDLOOP
.

Call method

DATA a1 TYPE …

DATA a2 TYPE …

oref->meth( IMPORTING p1 = a1

            IMPORTING p2 = a2

          ).

oref->meth(

        IMPORTING p1 = DATA(a1)

        IMPORTING p2 = DATA(a2) ).

Loop at assigning

FIELD-SYMBOLS: <line> type …

LOOP AT itab ASSIGNING <line>.

  …

ENDLOOP.

LOOP AT itab

   ASSIGNING FIELD-SYMBOL(<line>).
   …
ENDLOOP.

Read assigning

FIELD-SYMBOLS: <line> type …

READ TABLE itab

           ASSIGNING <line>.

READ TABLE itab

   ASSIGNING FIELD-SYMBOL(<line>).

Select into

table

DATA itab TYPE TABLE OF dbtab.

SELECT * FROM dbtab

   INTO TABLE itab

        WHERE fld1 = lv_fld1.

SELECT * FROM dbtab

   INTO TABLE DATA(itab) 

        WHERE fld1 = @lv_fld1.

Select single

into

SELECT SINGLE f1 f2 

  FROM dbtab

  INTO (lv_f1, lv_f2)

WHERE …

WRITE: / lv_f1, lv_f2.

SELECT SINGLE f1 AS my_f1,

              F2 AS abc  

         FROM dbtab

         INTO DATA(ls_structure)

        WHERE …

WRITE: / ls_structure-my_f1,              ls_structure-abc.

 

2. Table Expressions

If a table line is not found, the exception CX_SY_ITAB_LINE_NOT_FOUND is raised. No sy-subrc.


Description

Before 7.40

With 7.40

Read Table  index

READ TABLE itab INDEX idx

      INTO wa.

wa = itab[ idx ].

Read Table  using key

READ TABLE itab INDEX idx

     USING KEY key

      INTO wa.

wa = itab[ KEY key INDEX idx ].

Read Table  with key

READ TABLE itab

  WITH KEY col1 =

           col2 =

       INTO wa.

wa = itab[ col1 = col2 = ].

Read Table  with key components

READ TABLE itab

      WITH TABLE KEY key

COMPONENTS col1 =

           col2 =

      INTO wa.

wa = itab[ KEY key col1 =

                    col2 = ].

Does record exist?

READ TABLE itab …

    TRANSPORTING NO FIELDS.

IF sy-subrc = 0.

  …

ENDIF.

IF line_exists( itab[ … ] ).

ENDIF.

Get table index

DATA idx type sy-tabix.

READ TABLE …

  TRANSPORTING NO FIELDS.

  idx = sy-tabix.

DATA(idx) =

       line_index( itab[ … ] ).

NB: There will be a short dump if you use an inline expression that references a non-existent record.

        SAP says you should therefore assign a field symbol and check sy-subrc.

ASSIGN lt_tab[ 1 ] to FIELDSYMBOL(<ls_tab>).
IF sysubrc = 0.

ENDIF.


NB: Use itab [ table_line = … ] for untyped tables.


3. Conversion Operator CONV

I.  Definition

CONV dtype|#( … )

dtype = Type you want to convert to (explicit)

#     = compiler must use the context to decide the type to convert to (implicit)


II. Example

Method cl_abap_codepage=>convert_to expects a string

Before 7.40

DATA text   TYPE c LENGTH 255.

DATA helper TYPE string.

DATA xstr   TYPE xstring.

helper = text.

xstr = cl_abap_codepage=>convert_to( source = helper ).

With 7.40

DATA text TYPE c LENGTH 255.

DATA(xstr) = cl_abap_codepage=>convert_to( source = CONV string( text ) ).

OR

DATA(xstr) = cl_abap_codepage=>convert_to( source = CONV #( text ) ).

 

4. Value Operator VALUE

I. Definition

     Variables:    VALUE dtype|#( )

     Structures:  VALUE dtype|#( comp1 = a1 comp2 = a2 … )

     Tables:         VALUE dtype|#( ( … ) ( … ) … ) …

II. Example for structures

     TYPES:  BEGIN OF ty_columns1, “Simple structure
                     cols1 TYPE i,
                     cols2 TYPE i,
                   END OF ty_columns1.

      TYPES: BEGIN OF ty_columnns2,  “Nested structure
                     coln1 TYPE i,
                     coln2 TYPE ty_columns1,
                  END OF ty_columns2.

      DATA: struc_simple TYPE ty_columns1,
                struc_nest    TYPE ty_columns2.

     struct_nest   = VALUE t_struct(coln1 = 1
                                                  coln2-cols1 = 1
                                                  coln2-cols2 = 2 ).


     OR


     struct_nest   = VALUE t_struct(coln1 = 1
                                                   coln2 = VALUE #( cols1 = 1

                                                   cols2 = 2 ) ).


III. Examples for internal tables

Elementary line type:

TYPES t_itab TYPE TABLE OF i WITH EMPTY KEY.

DATA itab TYPE t_itab.

itab = VALUE #( ( ) ( 1 ) ( 2 ) ).

Structured line type (RANGES table):

DATA itab TYPE RANGE OF i.

itab = VALUE #( sign = ‘I’  option = ‘BT’ ( low = 1  high = 10 )
( low = 21 high = 30 )
( low = 41 high = 50 )
option = ‘GE’ ( low = 61 )  ).


5. FOR operator

I. Definition

     FOR wa|<fs> IN itab [INDEX INTO idx] [cond]

II. Explanation

This effectively causes a loop at itab. For each loop the row read is assigned to a work area (wa) or field-symbol(<fs>).

This wa or <fs> is local to the expression i.e. if declared in a subrourine the variable wa or <fs> is a local variable of

that subroutine. Index like SY-TABIX in loop.

Given: 

TYPES: BEGIN OF ty_ship,
           tknum
TYPE tknum,     “Shipment Number
           name 
TYPE ernam,     “Name of Person who Created the Object
           city 
TYPE ort01,     “Starting city
           route
TYPE route,     “Shipment route
      
END OF ty_ship.
TYPES: ty_ships TYPE SORTED TABLE OF ty_ship WITH UNIQUE KEY tknum.
TYPES: ty_citys TYPE STANDARD TABLE OF ort01 WITH EMPTY KEY.

GT_SHIPS type ty_ships. -> has been populated as follows:

Row TKNUM[C(10)] Name[C(12)] City[C(25)] Route[C(6)]
1 001 John Melbourne R0001
2 002 Gavin Sydney R0003
3 003 Lucy Adelaide R0001
4 004 Elaine Perth R0003

III. Example 1

Populate internal table GT_CITYS with the cities from GT_SHIPS.

Before 7.40

DATA: gt_citys TYPE ty_citys,
       gs_ship 
TYPE ty_ship,
       gs_city 
TYPE ort01.

LOOP AT gt_ships INTO gs_ship.
  gs_city
gs_shipcity.
  APPEND gs_city TO gt_citys.
ENDLOOP.

With 7.40

DATA(gt_citys) = VALUE ty_citys( FOR ls_ship IN gt_ships ( ls_shipcity ) ).

IV. Example 2

Populate internal table GT_CITYS with the cities from GT_SHIPS where the route is R0001.


Before 7.40

DATA: gt_citys TYPE ty_citys,
       gs_ship 
TYPE ty_ship,
       gs_city 
TYPE ort01.

LOOP AT gt_ships INTO gs_ship WHERE route = ‘R0001’.
  gs_city
gs_shipcity.
  APPEND gs_city TO gt_citys.
ENDLOOP.

With 7.40

DATA(gt_citys) = VALUE ty_citys( FOR ls_ship IN gt_ships

                               WHERE ( route = ‘R0001’ ) ( ls_shipcity ) ).

Note: ls_ship does not appear to have been declared but it is declared implicitly.


V. FOR with THEN and UNTIL|WHILE

FOR i = … [THEN expr] UNTIL|WHILE log_exp

Populate an internal table as follows:

TYPES:
  BEGIN OF ty_line,
    col1 TYPE i,
    col2 TYPE i,
    col3 TYPE i,
  END OF ty_line,
  ty_tab TYPE STANDARD TABLE OF ty_line WITH EMPTY KEY.

Before 7.40

DATA: gt_itab TYPE ty_tab,
      j      
TYPE i.
FIELD-SYMBOLS <ls_tab> TYPE ty_line.

j = 1.
DO.
j
= j + 10.
IF j > 40. EXIT. ENDIF.
APPEND INITIAL LINE TO gt_itab ASSIGNING <ls_tab>.
<ls_tab>
col1 = j.
<ls_tab>
col2 = j + 1.
<ls_tab>
col3 = j + 2.
ENDDO.

With 7.40

DATA(gt_itab) = VALUE ty_tab( FOR j = 11 THEN j + 10 UNTIL j > 40
                            ( col1 = j col2 = j + 1 col3 = j + ) ).

 

6. Reduction operator REDUCE

I. Definition

… REDUCE type(

INIT result = start_value

           …

FOR for_exp1

FOR for_exp2

NEXT …

           result = iterated_value

… )

II. Note

     While VALUE and NEW expressions can include FOR expressions, REDUCE must include at least one FOR expression. You can use all kinds      of FOR expressions in REDUCE:

  • with IN for iterating internal tables
  • with UNTIL or WHILE for conditional iterations

III. Example 1

Count lines of table that meet a condition (field F1 contains “XYZ”).

Before 7.40

DATA: lv_lines TYPE i.

LOOP AT gt_itab INTO ls_itab where F1 = ‘XYZ’.
  lv_
lines = lv_lines + 1.
ENDLOOP.

With 7.40

DATA(lv_lines) = REDUCE i( INIT x = 0 FOR wa IN gt_itab

                    WHERE( F1 = ‘XYZ’ ) NEXT x = x + 1 ).

IV. Example 2

Sum the values 1 to 10 stored in the column of a table defined as follows

DATA gt_itab TYPE STANDARD TABLE OF i WITH EMPTY KEY.
gt_itab
= VALUE #( FOR j = 1 WHILE j <= 10 ( j ) ).

Before 7.40

DATA: lv_line TYPE i,
      lv_sum 
TYPE i.

LOOP AT gt_itab INTO lv_line.
  lv_sum
= lv_sum + lv_line.
ENDLOOP.

With 7.40

DATA(lv_sum) = REDUCE i( INIT x = 0 FOR wa IN itab NEXT x = x + wa ).

V. Example 3

Using a class reference – works because “write” method returns reference to instance object

With 7.40

TYPES outref TYPE REF TO if_demo_output.

DATA(output) = REDUCE outref( INIT out  = cl_demo_output=>new( )
                              text
= `Count up:`
                              FOR n = 1 UNTIL n > 11
                              NEXT out = out->write( text )
                              text
= |{ n }| ).

output->display( ).

7. Conditional operators COND and SWITCH

I. Definition

… COND dtype|#( WHEN log_exp1 THEN result1
[ WHEN log_exp2 THEN result2 ]

[ ELSE resultn ] ) …

… SWITCH dtype|#( operand
WHEN const1 THEN result1
[ WHEN const2 THEN result2 ]

[ ELSE resultn ] ) …

II. Example for COND

DATA(time) =

  COND string(

    WHEN sy-timlo < ‘120000’ THEN

      |{ sy-timlo TIME = ISO } AM|

    WHEN sy-timlo > ‘120000’ THEN

      |{ CONV t( sy-timlo – 12 * 3600 )

TIME = ISO } PM|

    WHEN sy-timlo = ‘120000’ THEN

      |High Noon|

    ELSE

      THROW cx_cant_be( ) ).

III. Example for SWITCH

DATA(text) =
NEW class( )->meth(
                     SWITCH #( sy-langu
                              WHEN ‘D’ THEN `DE`
                              WHEN ‘E’ THEN `EN`
                               ELSE THROW cx_langu_not_supported( ) ) ).

 

8. Corresponding Operator

I. Definition

… CORRESPONDING type( [BASE ( base )] struct|itab [mapping|except] )

II. Example Code

With 7.40

TYPES: BEGIN OF line1, col1 TYPE i, col2 TYPE i, END OF line1.
TYPES: BEGIN OF line2, col1 TYPE i, col2 TYPE i, col3 TYPE i, END OF line2.

DATA(ls_line1) = VALUE line1( col1 = 1 col2 = 2 ).
WRITE: / ‘ls_line1 =’ ,15 ls_line1col1, ls_line1col2.
DATA(ls_line2) = VALUE line2( col1 = 4 col2 = 5 col3 = 6 ).
WRITE: / ‘ls_line2 =’ ,15 ls_line2col1, ls_line2col2, ls_line2col3.
SKIP 2.

ls_line2 = CORRESPONDING #( ls_line1 ).
WRITE: / ‘ls_line2 = CORRESPONDING #( ls_line1 )’

     ,70 ‘Result is ls_line2 = ‘     

        ,ls_line2col1, ls_line2col2, ls_line2col3.
SKIP.

ls_line2 = VALUE line2( col1 = 4 col2 = 5 col3 = 6 ).   “Restore ls_line2
ls_line2
= CORRESPONDING #( BASE ( ls_line2 ) ls_line1 ).
WRITE: / ‘ls_line2 = CORRESPONDING #( BASE ( ls_line2 ) ls_line1 )’

        , 70 ‘Result is ls_line2 = ‘, ls_line2col1

        , ls_line2col2, ls_line2col3.
SKIP.

ls_line2 = VALUE line2( col1 = 4 col2 = 5 col3 = 6 ).   “Restore ls_line2
DATA(ls_line3) = CORRESPONDING line2( BASE ( ls_line2 ) ls_line1 ).
WRITE: / ‘DATA(ls_line3) = CORRESPONDING line2( BASE ( ls_line2 ) ls_line1 )’

         , 70 ‘Result is ls_line3 = ‘ , ls_line3col1

         , ls_line3col2, ls_line3col3.

III. Output

/wp-content/uploads/2015/10/image001_906951.jpg

IV. Explanation

Given structures ls_line1 & ls_line2 defined and populated as above.

Before 7.40

With 7.40

1

CLEAR ls_line2.

MOVE-CORRESPONDING ls_line1 

                TO ls_line2.

ls_line2 = CORRESPONDING #( ls_line1 ).

2

MOVE-CORRESPONDING ls_line1 

                TO ls_line2.

ls_line2 = CORRESPONDING #

        ( BASE ( ls_line2 ) ls_line1 ).

3

DATA: ls_line3 like ls_line2.

ls_line3 = ls_line2.

MOVE-CORRESPONDING ls_line1 

                TO ls_line2.

DATA(ls_line3) = CORRESPONDING line2

        ( BASE ( ls_line2 ) ls_line1 ).

  1.   The contents of ls_line1 are moved to ls_line2 where there is a matching column name. Where there is no

            match the column of ls_line2 is initialised.

  2. This uses the existing contents of ls_line2 as a base and overwrites the matching columns from ls_line1.

            This is exactly like MOVE-CORRESPONDING.

  3. This creates a third and new structure (ls_line3) which is based on ls_line2 but overwritten by matching

             columns of ls_line1.

V. Additions MAPPING and EXCEPT

   MAPPING allows you to map fields with non-identically named components to qualify for the data transfer.

   … MAPPING  t1 = s1 t2 = s2


   EXCEPT allows you to list fields that must be excluded from the data transfer

   … EXCEPT  {t1 t2 …}

9. Strings

I. String Templates

A string template is enclosed by two characters “|” and creates a character string.

Literal text consists of all characters that are not in braces {}. The braces can contain:

  • data objects,
  • calculation expressions,
  • constructor expressions,
  • table expressions,
  • predefined functions, or
  • functional methods and method chainings

Before 7.40

DATA itab TYPE TABLE OF scarr.

SELECT * FROM scarr INTO TABLE itab.

DATA wa LIKE LINE OF itab.

READ TABLE itab WITH KEY carrid = ‘LH’ INTO wa.

DATA output TYPE string.

CONCATENATE ‘Carrier:’ wa-carrname INTO output SEPARATED BY space.

cl_demo_output=>display( output ).

With 7.40

SELECT * FROM scarr INTO TABLE @DATA(lt_scarr).
cl_demo_output
=>display( |Carrier: { lt_scarr[ carrid = ‘LH’ ]carrname }|  ).

II. Concatenation

Before 7.40

DATA lv_output TYPE string.
CONCATENATE
‘Hello’ ‘world’ INTO lv_output SEPARATED BY space.

With 7.40

DATA(lv_out) = |Hello| & | | & |world|.

III. Width/Alignment/Padding

WRITE / |{ ‘Left’     WIDTH = 20 ALIGN = LEFT   PAD = ‘0’ }|.
WRITE / |{ ‘Centre’   WIDTH = 20 ALIGN = CENTER PAD = ‘0’ }|.
WRITE / |{ ‘Right’    WIDTH = 20 ALIGN = RIGHT  PAD = ‘0’ }|.

IV. Case

WRITE / |{ ‘Text’ CASE = (cl_abap_format=>c_raw) }|.
WRITE / |{ ‘Text’ CASE = (cl_abap_format=>c_upper) }|.
WRITE / |{ ‘Text’ CASE = (cl_abap_format=>c_lower) }|.

V. ALPHA conversion

DATA(lv_vbeln) = ‘0000012345’.
WRITE / |{ lv_vbeln  ALPHA = OUT }|.     “or use ALPHA = IN to go in other direction

VI. Date conversion

WRITE / |{ pa_date DATE = ISO }|.           “Date Format YYYY-MM-DD
WRITE / |{ pa_date DATE = User }|.          “As per user settings
WRITE / |{ pa_date DATE = Environment }|.   “Formatting setting of language environment

10. Loop at Group By

I. Definition

LOOP AT itab result [cond] GROUP BY key ( key1 = dobj1 key2 = dobj2 …
      [gs = GROUP SIZE] [gi = GROUP INDEX] )
      [ASCENDING|DESCENDING [AS TEXT]]
      [WITHOUT MEMBERS]
      [{INTO group}|{ASSIGNING <group>}]
      …
     
[LOOP AT GROUP group|<group>
     

     
ENDLOOP.]
      …

ENDLOOP.


II. Explanation

The outer loop will do one iteration per key. So if 3 records match the key there will only be one iteration for these 3 records. The structure “group” (or

“<group>” ) is unusual in that it can be looped over using the “LOOP AT GROUP” statement. This will loop over the 3 records (members) of the group. The

structure “group” also contains the current key as well as the size of the group and index of the group ( if GROUP SIZE and GROUP INDEX have been

assigned a field name). This is best understood by an example.


III. Example

With 7.40

TYPES: BEGIN OF ty_employee,

  name TYPE char30,

  role    TYPE char30,

  age    TYPE i,

END OF ty_employee,

ty_employee_t TYPE STANDARD TABLE OF ty_employee WITH KEY name.

DATA(gt_employee) = VALUE ty_employee_t(

( name = ‘John‘     role = ‘ABAP guru‘       age = 34 )

( name = ‘Alice‘     role = ‘FI Consultant‘   age = 42 )

( name = ‘Barry‘    role = ‘ABAP guru‘       age = 54 )

( name = ‘Mary‘     role = ‘FI Consultant‘   age = 37 )

( name = ‘Arthur‘   role = ‘ABAP guru‘       age = 34 )

( name = ‘Mandy‘  role = ‘SD Consultant‘  age = 64 ) ).

DATA: gv_tot_age TYPE i,

           gv_avg_age TYPE decfloat34.

“Loop with grouping on Role

LOOP AT gt_employee INTO DATA(ls_employee)

  GROUP BY ( role  = ls_employee-role

                        size  = GROUP SIZE

                       index = GROUP INDEX )

  ASCENDING

  ASSIGNING FIELD-SYMBOL(<group>).

  CLEAR: gv_tot_age.

  “Output info at group level

  WRITE: / |Group: { <group>-index }    Role: { <group>-role WIDTH = 15 }|

              & |     Number in this role: { <group>-size }|.

   “Loop at members of the group

   LOOP AT GROUP <group> ASSIGNING FIELD-SYMBOL(<ls_member>).

      gv_tot_age = gv_tot_age + <ls_member>-age.

      WRITE: /13 <ls_member>-name.

   ENDLOOP.

   “Average age

   gv_avg_age = gv_tot_age / <group>-size.

   WRITE: / |Average age: { gv_avg_age }|.

   SKIP.

ENDLOOP.

IV. Output

Group: 1    Role: ABAP guru           Number in this role: 3

                 John

                 Barry

                 Arthur

Average age: 40.66666666666666666666666666666667

Group: 2    Role: FI Consultant       Number in this role: 2

                  Alice

                  Mary

Average age: 39.5

Group: 3    Role: SD Consultant       Number in this role: 1

                  Mandy

Average age: 64

11. Classes/Methods

I. Referencing fields within returned structures

Before 7.40

DATA: ls_lfa1  TYPE lfa1,
      lv_name1
TYPE lfa1name1.

ls_lfa1  = My_Class=>get_lfa1( ).
lv_name1
= ls_lfa1name1.

With 7.40

DATA(lv_name1) = My_Class=>get_lfa1( )name1.

II. Methods that return a type BOOLEAN

Before 7.40

IF My_Class=>return_boolean( ) = abap_true.

ENDIF.

With 7.40

IF My_Class=>return_boolean( ).

ENDIF.

NB: The type “BOOLEAN” is not a true Boolean but a char1 with allowed values X,- and <blank>.

       Using type “FLAG” or “WDY_BOOLEAN” works just as well.

III. NEW operator

This operator can be used to instantiate an object.

Before 7.40

DATA: lo_delivs TYPE REF TO zcl_sd_delivs,

            lo_deliv  TYPE REF TO zcl_sd_deliv.

CREATE OBJECT lo_delivs.
CREATE OBJECT lo_deliv.

lo_deliv = lo_delivs->get_deliv( lv_vbeln ).

With 7.40

DATA(lo_deliv) = new zcl_sd_delivs( )->get_deliv( lv_vbeln ).

12. Meshes

Allows an association to be set up between related data groups.


I. Problem

Given the following 2 internal tables:

TYPES: BEGIN OF t_manager,
name  
TYPE char10,
salary
TYPE int4,
END OF t_manager,
tt_manager
TYPE SORTED TABLE OF t_manager WITH UNIQUE KEY name.

TYPES: BEGIN OF t_developer,
name   
TYPE char10,
salary 
TYPE int4,
manager
TYPE char10,   “Name of manager
END OF t_developer,
tt_developer
TYPE SORTED TABLE OF t_developer WITH UNIQUE KEY name.


Populated as follows:

Row Name[C(10)] Salary[I(4)]
1 Jason 3000
2 Thomas 3200
Row
Name[C(10)]

Salary[I(4) Manager[C(10)]
1 Bob 2100 Jason
2 David 2000 Thomas
3 Jack 1000 Thomas
4 Jerry 1000 Jason
5 John 2100 Thomas
6 Tom 2000 Jason

Get the details of Jerry’s manager and all developers managed by Thomas.

II. Solution

With 7.40

TYPES: BEGIN OF MESH m_team,
         managers  
TYPE tt_manager  ASSOCIATION my_employee TO developers

                                                            ON manager = name,
         developers
TYPE tt_developer ASSOCIATION my_manager TO managers  

                                                            ON name = manager,
       END OF MESH m_team.

DATA: ls_team TYPE m_team.
ls_team
managers   = lt_manager.
ls_team
developers = lt_developer.

*Get details of Jerry’s manager *

“get line of dev table

ASSIGN lt_developer[ name = ‘Jerry’ ] TO FIELDSYMBOL(<ls_jerry>).
DATA(ls_jmanager) =  ls_teamdevelopers\my_manager[ <ls_jerry> ].

WRITE: / |Jerry‘s manager: { ls_jmanager-name }|,30

                  |Salary: { ls_jmanager-salary }|.


“Get Thomas’ developers
SKIP.
WRITE: / |Thomas‘ developers:|.

“line of manager table

ASSIGN lt_manager[ name = ‘Thomas’ ] TO FIELDSYMBOL(<ls_thomas>).
LOOP AT ls_teammanagers\my_employee[ <ls_thomas> ]     

        ASSIGNING FIELDSYMBOL(<ls_emp>).

  WRITE: / |Employee name: { <ls_emp>name }|.
ENDLOOP.

III. Output

     Jerry’s manager: Jason          Salary: 3000

     Thomas’ developers:

     Employee name: David

     Employee name: Jack

     Employee name: John

13. Filter

Filter the records in a table based on records in another table.


I. Definition

… FILTER type( itab [EXCEPT] [IN ftab] [USING KEY keyname]
           WHERE c1 op f1 [AND c2 op f2 […]] )

II. Problem

Filter an internal table of Flight Schedules (SPFLI) to only those flights based on a filter table that contains the fields Cityfrom and CityTo.

III. Solution

With 7.40

TYPES: BEGIN OF ty_filter,
         cityfrom
TYPE spflicityfrom,
         cityto  
TYPE spflicityto,
         f3      
TYPE i,
       END OF ty_filter,
       ty_filter_tab
TYPE HASHED TABLE OF ty_filter

                     WITH UNIQUE KEY cityfrom cityto.
DATA: lt_splfi TYPE STANDARD TABLE OF spfli.

SELECT * FROM spfli APPENDING TABLE lt_splfi.

DATA(lt_filter) = VALUE ty_filter_tab( f3 = 2

                          ( cityfrom = ‘NEW YORK’  cityto  = ‘SAN FRANCISCO’ )
             ( cityfrom = ‘FRANKFURT’ cityto  = ‘NEW YORK’ )  ).

DATA(lt_myrecs) = FILTER #( lt_splfi IN lt_filter

                                  WHERE cityfrom = cityfrom 

                                    AND cityto = cityto ).

“Output filtered records
LOOP AT lt_myrecs ASSIGNING FIELDSYMBOL(<ls_rec>).
  WRITE: / <ls_rec>carrid,8 <ls_rec>cityfrom,30

           <ls_rec>cityto,45 <ls_rec>deptime.

ENDLOOP.

Note: using the keyword “EXCEPT” (see definition above) would have returned the exact opposite records i.e all records EXCEPT for those those returned above.

To report this post you need to login first.

33 Comments

You must be Logged on to comment or reply to a post.

  1. Jitendra Soni

    Hi Jeffrey,

    Very informative blog.

     

    Below syntax is not working for me.

     

    “SELECT * FROM dbtab INTO TABLE @DATA(lt_dbtab) WHERE field1 = @lv_field1.”

     

    ABAP version:

    SAP_BASIS 740 0007 SAPKB74007 0000 SAP Basis Component
    SAP_ABA 740 0007 SAPKA74007 0000 Cross-Application Component
    (0) 
    1. Jeffrey Towell Post author

      Thanks Jitendra.

      I am not sure which bits of ABAP 7.40 come in with exactly which version but here is some working code. If this does not work on your box then its fair to say you do not have the relevant version yet.

       

      DATA: lv_bukrs type bukrs VALUE ‘0001’.
       
      SELECT * FROM t001 INTO TABLE @DATA(lt_t001)

                     WHERE bukrs = @lv_bukrs

      (0) 
  2. Paul Bakker

    Thanks for going to so much effort! Very interesting reading.

     

    Unfortunately some of the code (inside the black borders) is truncated on the right hand side. But I think we can work it out

     

    cheers

    Paul

    (0) 
    1. Jeffrey Towell Post author

      Thanks for your comments Paul.

       

      Was also concerned about truncation on the right but found that if you click on the text and drag to the right that it all becomes visible. Alternatively the scroll bar at the bottom works but it’s a bit inconvenient scrolling down to find it.

       

      Cheers,

      Jeff

      (0) 
  3. Guy Lamoureux

    Very Interesting. But I see that clarity and “ease of reading”continues to be vastly underestimated and undervalued. ABAP is going to the dark side 😉

    (0) 
    1. Jeffrey Towell Post author

      Guy, I thought the exact same thing at first along with others I have chatted to. However, after using it a while I realise it becomes more clear as you get more familiar with the syntax. After years of using the old syntax it has become so familiar to us that it feels like we have to think too much to understand what is being coded in the new syntax. Soon it will be second nature to you and hence easy to read.

      (0) 
      1. Guy Lamoureux

        Hi Jeffrey,

         

        “after using it a while” the problem is right here. Not everybody is an ABAP programmer and not everybody programs in ABAP on a regular base. I’ve seen a lot of functional analyst who can follow what’s going on in an ABAP program. They do it for many reasons but it’s part of their job and the more we change the language to something more obscure, the less they will be able to do it. They will need help from ABAP programmers. This will slow down the process.

        On my part, I’ve worked as an ABAP programmer for 10 years, followed by 10 years of BW developement. I don’t write ABAP code on a regular base. This new syntax will keep being obscure.

        (0) 
  4. Jakob Mainka

    When I do an inline Declaration of an internal table

    SELECT … FROM … INTO TABLE @data(lt_data).

    Is there also some way, to have this as a sorted / hashed table or at least add secondary keys?

    (0) 
    1. Jeffrey Towell

      Not that I’m aware of Jakob. If you create a “type” of the kind you want with sorting etc. and call it say ty_mytab you could do a conversion using CONV:

       

      TYPES ty_mytab TYPE SORTED TABLE OF t001w WITH NON-UNIQUE KEY fabkl.

       

      SELECT * FROM t001w INTO TABLE @DATA(lt_t001w).

        DATA(lt_new_tab) = CONV ty_mytab( lt_t001w ).

       

      However, this does not save you any time/typing compared to selecting directly into your defined internal table:

       

      TYPES ty_mytab TYPE SORTED TABLE OF t001w WITH NON-UNIQUE KEY fabkl.

      DATA: lt_new_tab TYPE ty_mytab.

       

      SELECT * FROM t001w INTO TABLE lt_new_tab.

      (0) 
  5. Michael Calekta

    Thanks for your effort Jeffrey!

    Yet there’s a little mistake in the Mesh-Example:

    ASSIGN lt_developer[ name = ‘Jerry’ ] TO FIELDSYMBOL(<ls_jerry>).
    DATA(ls_jmanager) =  ls_teamdevelopers\my_manager[ jerry ].


    Second line should read instead:

    DATA(ls_jmanager) =  ls_teamdevelopers\my_manager[ <ls_jerry> ].


    Same is true for “thomas” a few lines below.

    Nevertheless this is the first example I found, where the advantage of meshes can be seen.
    All the best
    Michael

    (0) 
    1. Jeffrey Towell Post author

      Thanks for pointing that out Michael. I have corrected that.

      The amazing thing is that the code is a copy and paste from a working program I wrote and still have. I’ve noticed the “<” and “>” get stripped off my field symbols in this document before. My theory is that when it gets converted to HTML that the field symbols sometimes look like HTML tags because they are between the <>. As such they are sometimes stripped out by this conversion to HTML.

       

      That’s my theory anyway.

      Thanks again.

      (0) 
      1. Michael Calekta

        Sorry to interrupt again, but it was not only the <> missing, which you have corrected, but also the ls_ which is still missing. I don’t think this can get lost by an html-conversion-error. Perhaps a missing definition and value assignment from the original coding.

         

        I have copied the example and tried it, and it really works fine, once I could eliminate the syntax-errors because of the missing letters.

        (0) 
        1. Jeffrey Towell Post author

          Interruption appreciated as you are correct that I forgot to add the “ls_” in. However, I can assure you that the original code has both the “<>” and the “ls_” in. The HTML issue has caused problems in other parts of this document which is why I know about it. In the “Loop at Group By” section it would not let me save the code I added. I finally added the code into the document word by word (i.e. saving after each word) and discovered it was a field symbol causing the problem. When I renamed the field symbol it saved.

          (0) 
  6. Vinay Mutt

    Thanks for documenting all the new changes. This comes as a helpful doc for all who wants to know the new features of ABAP Programming. The Inline Declaration is a very helpful feature of ABAP 740 and it solves huge effots of developer.

     

    Regards,

    Vinay Mutt

    (0) 
  7. Martin Neuß

    … wonderful !

     

    I am just trying to gather some Information about Netweaver 7.40 ABAP for a forthcoming inhouse training here in our company, and found out soon that the original SAP samples are hardly helpful.

     

    Your examples are really straightforward, easy to understand and useful for “real life” developers.

     

    Thank you !

     

    Regards,

    Martin Neuss

    (0) 
  8. Konstantin Mesnyankin

    Hi, experts. How can i fill itab with corresponding fields from structure variable and one field from another table using one statement ? my example:

     

     

    data(RT_CONFIG_PERS_DATA) =

    VALUE BSP_DLCT_PERS(   for wa_touser in TOUSER

    ( CORRESPONDING #( RS_CONFIG_PERS_DATA EXCEPT PERS_FOR_USER ) PERS_FOR_USER = wa_touserlow  ).


    this statement gives syntax error.


    so i am just using classic code:


    data RT_CONFIG_PERS_DATA type BSP_DLCT_PERS.

      LOOP AT TOUSER INTO DATA(wa_touser) .

        APPEND INITIAL LINE TO rt_config_pers_data ASSIGNING FIELDSYMBOL(<fs>).

        MOVE-CORRESPONDING rs_config_pers_data to <fs>.

        <fs>pers_for_user = wa_touserlow.

      ENDLOOP.


    is it possible to do such actions in one statement ?

     

     

    (0) 
    1. Jeffrey Towell Post author

      Hi Konstantin,

      Its possible to get it on one line by using each component of the structure instead of the “CORRESPONDING”. In your case this would look like:

       

      DATA(rt_config_pers_data) =

      VALUE bsp_dlct_pers(   FOR wa_touser IN touser

      ( pers_for_user   = wa_touserlow

         component       = rs_config_pers_datacomponent

         viewname         = rs_config_pers_dataviewname

         role_key           = rs_config_pers_datarole_key

         component_usage = rs_config_pers_datacomponent_usage

         object_type       = rs_config_pers_dataobject_type

         object_sub_type = rs_config_pers_dataobject_sub_type

         changed_by      = rs_config_pers_datachanged_by

         changed_at      = rs_config_pers_datachanged_at

         config               = rs_config_pers_dataconfig

         parameters      = rs_config_pers_dataparameters

         config_type      = rs_config_pers_dataconfig_type

         invalid_flag      = rs_config_pers_datainvalid_flag

         marking_flag    = rs_config_pers_datamarking_flag

         check_flag      = rs_config_pers_datacheck_flag ) ).


      Of course your “classic code” is better not just because the above is longer but also because the above will not work if there is ever a change to the structure bsp_dlct_pers.

      (0) 
  9. Ramesh Kothapally

    Hi Jeffrey,

    Thanks for sharing very informative document with us.This blog help for all who wants to know new features and techniques in ABAP 7.4 programming and helpful to getting started with ABAP 7.4/7/5

    Thank you very much.

     

    Thanks and Regards,

    Ramesh Kothapally

     

    (0) 

Leave a Reply