TYPE numeric, "Numeric ((b, s), i, int8, p, decfloat16, decfloat34, f)
- TYPE p, "Packed number (generic length and number of decimal places)
-
- "Internal table types
- TYPE ANY TABLE, "Internal table with any table type
- TYPE HASHED TABLE,
- TYPE INDEX TABLE,
- TYPE SORTED TABLE,
- TYPE STANDARD TABLE,
- TYPE table, "Standard table
-
- "Other types
- TYPE simple, "Elementary data type including enumerated types and
- "structured types with exclusively character-like flat components
- TYPE REF TO object. "object can only be specified after REF TO; can point to any object
-
-"Data objects to work with
-DATA: BEGIN OF s,
- c3 TYPE c LENGTH 3,
- c10 TYPE c LENGTH 10,
- n4 TYPE n LENGTH 4,
- str TYPE string,
- time TYPE t,
- date TYPE d,
- dec16 TYPE decfloat16,
- dec34 TYPE decfloat34,
- int TYPE i,
- pl4d2 TYPE p LENGTH 4 DECIMALS 2,
- tab_std TYPE STANDARD TABLE OF string WITH EMPTY KEY,
- tab_so TYPE SORTED TABLE OF string WITH NON-UNIQUE KEY table_line,
- tab_ha TYPE HASHED TABLE OF string WITH UNIQUE KEY table_line,
- xl1 TYPE x LENGTH 1,
- xstr TYPE xstring,
- structure TYPE zdemo_abap_carr, "character-like flat structure
- oref TYPE REF TO object,
- END OF s.
-
-"The following static ASSIGN statements demonstrate various assignments
-"Note:
-"- The statements commented out show impossible assignments.
-"- If a static assignment is not successful, sy-subrc is not set and no
-" memory area is assigned. Dynamic assignments, however, set the value.
-
-"----- Any data type -----
-ASSIGN s-c3 TO .
-ASSIGN s-time TO .
-ASSIGN s-tab_std TO .
-ASSIGN s-xstr TO .
-ASSIGN s-pl4d2 TO .
-ASSIGN s-date TO .
-ASSIGN s TO .
-
-"----- Character-like types -----
-ASSIGN s-c3 TO .
-ASSIGN s-c10 TO .
-"ASSIGN s-str TO .
-
-ASSIGN s-c10 TO .
-ASSIGN s-str TO .
-ASSIGN s-n4 TO .
-ASSIGN s-date TO .
-ASSIGN s-time TO .
-ASSIGN s-structure TO .
-
-ASSIGN s-c10 TO .
-ASSIGN s-str TO .
-"ASSIGN s-n4 TO .
-
-ASSIGN s-n4 TO .
-"ASSIGN s-int TO .
-"ASSIGN s-time TO .
-
-ASSIGN s-xl1 TO .
-"ASSIGN s-xstr TO .
-
-ASSIGN s-xl1 TO .
-ASSIGN s-xstr TO .
-
-"----- Numeric types -----
-ASSIGN s-dec16 TO .
-ASSIGN s-dec34 TO .
-ASSIGN s-int TO .
-ASSIGN s-pl4d2 TO .
-"ASSIGN s-n4 TO .
-
-ASSIGN s-dec16 TO .
-ASSIGN s-dec34 TO .
-
-ASSIGN s-pl4d2 TO .
-"ASSIGN s-dec34 TO
.
-
-"----- Internal table types -----
-ASSIGN s-tab_std TO .
-ASSIGN s-tab_so TO .
-ASSIGN s-tab_ha TO .
-
-ASSIGN s-tab_std TO .
-ASSIGN s-tab_so TO .
-"ASSIGN s-tab_ha TO .
-
-"ASSIGN s-tab_std TO .
-ASSIGN s-tab_so TO .
-"ASSIGN s-tab_ha TO .
-
-ASSIGN s-tab_std TO .
-ASSIGN s-tab_std TO .
-"ASSIGN s-tab_so TO .
-"ASSIGN s-tab_so TO .
-"ASSIGN s-tab_ha TO .
-"ASSIGN s-tab_ha TO .
-
-"ASSIGN s-tab_std TO .
-"ASSIGN s-tab_so TO .
-ASSIGN s-tab_ha TO .
-
-"----- Other types -----
-ASSIGN s-c10 TO .
-ASSIGN s-str TO .
-ASSIGN s-dec34 TO .
-ASSIGN s-date TO .
-ASSIGN s-structure TO .
-ASSIGN s-xl1 TO .
-"ASSIGN s-tab_ha TO .
-
-ASSIGN s-oref TO .
-s-oref = NEW zcl_demo_abap_objects( ).
-```
-
-⬆️ back to top
-
-### Data References
-
-[Data references](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendata_reference_glosry.htm "Glossary Entry")
-...
-
-- are references that point to any data object or to their parts (for example, components, lines of internal tables).
-- are contained in [data reference variables](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendata_reference_variable_glosry.htm "Glossary Entry")
- in ABAP programs.
-
-[Data reference variables](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendata_reference_variable_glosry.htm "Glossary Entry")
-...
-
-- are data objects that contain a reference.
-- are "opaque", i. e. the contained references cannot be accessed directly. To access the content, these variables must be dereferenced first.
-- are [deep](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendeep_glosry.htm "Glossary Entry") data objects like strings and internal tables.
-- are typed with the addition [`REF TO`](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abaptypes_references.htm) followed by a [static type](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenstatic_type_glosry.htm). Note the [dynamic type](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendynamic_type_glosry.htm) in this context: The dynamic type of such a variable is the data type to which it actually points. This concept is particularly relevant in the context of assignments (see the assignment rules [here](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenconversion_references.htm)).
-- can be typed with a complete or generic type. However, only `data` can be used as generic type.
-
-> **💡 Note**).
- = 123.
-
-"An access as the following, as it is possible in modern ABAP, was not possible.
-ref_generic->* = 123.
-
-"In modern ABAP, variables and field symbols of the generic types
-"'any' and 'data' can be used directly, for example, in LOOP and READ statements.
-DATA dref TYPE REF TO data.
-CREATE DATA dref TYPE TABLE OF zdemo_abap_carr.
-SELECT *
- FROM zdemo_abap_carr
- INTO TABLE @dref->*.
-
-"Note: In case of a fully generic type, an explicit or implicit index operation
-"is not possible (indicated by the examples commented out).
-LOOP AT dref->* ASSIGNING FIELD-SYMBOL().
- ...
-ENDLOOP.
-"LOOP AT dref->* ASSIGNING FIELD-SYMBOL() FROM 1 TO 4.
-"ENDLOOP.
-
-"The following examples use a dynamic key specification.
-"See more syntax examples below.
-READ TABLE dref->* ASSIGNING FIELD-SYMBOL() WITH KEY ('CARRID') = 'AA'.
-"READ TABLE dref->* INDEX 1 ASSIGNING FIELD-SYMBOL().
-
-"Table expressions
-DATA(line) = CONV zdemo_abap_carr( dref->*[ ('CARRID') = 'AA' ] ).
-dref->*[ ('CARRID') = 'AA' ] = VALUE zdemo_abap_carr( BASE dref->*[ ('CARRID') = 'AA' ] carrid = 'XY' ).
-dref->*[ ('CARRID') = 'XY' ]-('CARRID') = 'ZZ'.
-
-"Table functions
-DATA(num_tab_lines) = lines( dref->* ).
-DATA(idx) = line_index( dref->*[ ('CARRID') = 'LH' ] ).
-```
-
-**Examples using data references**
-
-Some example contexts of using data references are as follows:
-
-*Overwriting data reference variables*:
-``` abap
-dref = NEW i( 1 ).
-
-"ref is overwritten here because a new object is created
-"with a data reference variable already pointing to a data object
-dref = NEW i( 2 ).
-```
-
-*Retaining data references*:
-
-``` abap
-"This snippet shows that three data references are created
-"with the same reference variable. Storing them in an internal table
-"using the type TYPE TABLE OF REF TO prevents the overwriting.
-
-DATA: dref TYPE REF TO data,
- itab TYPE TABLE OF REF TO data,
- num TYPE i VALUE 0.
-
-DO 3 TIMES.
- "Adding up 1 to demonstrate a changed data object.
- num += 1.
-
- "Creating data reference and assigning value.
- "In the course of the loop, the variable gets overwritten.
- dref = NEW i( num ).
-
- "Adding the reference to itab
- itab = VALUE #( BASE itab ( dref ) ).
-ENDDO.
-```
-
-*Processing internal tables*:
-
-``` abap
-"Similar use case to using field symbols: In a loop across an internal table,
-"you assign the content of the line in a data reference variable
-"instead of actually copying the content to boost performance.
-"Again, the inline declaration comes in handy.
-
-"Filling an internal table.
-SELECT *
- FROM zdemo_abap_fli
- INTO TABLE @DATA(fli_tab).
-
-LOOP AT fli_tab REFERENCE INTO DATA(ref).
-
- "A component of the table line may be addressed.
- "Note the object component selector; the dereferencing operator together
- "with the component selector is also possible: ->*-
- ref->carrid = ...
- ...
-ENDLOOP.
-
-"More statements are available that assign content to a data reference variable,
-"for example, READ TABLE.
-READ TABLE fli_tab INDEX 1 REFERENCE INTO DATA(rt_ref).
-```
-
-*Data reference variables as part of structures and internal tables*:
-``` abap
-"Unlike field symbols, data reference variables can be used as
-"components of structures or columns in internal tables.
-
-"Structure
-DATA: BEGIN OF struc,
- num TYPE i,
- ref TYPE REF TO i,
- END OF struc.
-
-"Some value assignment
-
-struc = VALUE #( num = 1 ref = NEW #( 2 ) ).
-
-"Internal table
-
-DATA itab LIKE TABLE OF struc WITH EMPTY KEY.
-APPEND struc TO itab.
-itab[ 1 ]-ref->* = 123.
-```
-
-> **✔️ Hint**⬆️ back to top
-
-## Dynamic ABAP Statements
-
-As already mentioned above, there are ABAP statements that support the dynamic specification of syntax elements.
-In this context, you can usually use elementary, character-like data objects specified within a pair of parentheses.
-For example, `SORT` statements:
-``` abap
-"Named, character-like data object specified within parentheses
-"used by an ABAP statement
-DATA(field_name) = 'CARRNAME'.
-SORT itab BY (field_name).
-
-"Unnamed, character-like data object specified within parentheses
-SORT itab BY ('CURRCODE').
-```
-
-Note that dynamically specifying syntax elements has downsides, too. Consider some erroneous character-like content of such data objects. There is no syntax warning. At runtime, it can lead to runtime errors.
-Some of the following code snippets use artifacts from the cheat sheet repository. The code snippets demonstrate a selection.
-
-### Dynamic ASSIGN Statements
-
-``` abap
-"Creating and populating various types/data objects to work with
-TYPES: BEGIN OF st_type,
- col1 TYPE i,
- col2 TYPE string,
- col3 TYPE string,
- END OF st_type.
-DATA st TYPE st_type.
-DATA it TYPE TABLE OF st_type WITH EMPTY KEY.
-st = VALUE #( col1 = 1 col2 = `aaa` col3 = `Z` ).
-APPEND st TO it.
-DATA(dref) = NEW st_type( col1 = 2 col2 = `b` col3 = `Y` ).
-DATA dobj TYPE string VALUE `hallo`.
-"The following examples use a field symbol with generic type
-FIELD-SYMBOLS TYPE data.
-
-"------- Specifying the memory area dynamically ------
-"I.e. the memory area is not specified directly, but as content of a
-"character-like data object in parentheses.
-"Note:
-"- When specified as unnamed data object, the compiler treats the
-" specifications like static assignments. Do not use named data objects
-" for ASSIGN statements in ABAP for Cloud Development. It is recommended
-" that existing named data objects are put in a structure. Then, the syntax
-" for assigning components dynamically can be used so as to avoid a syntax
-" warning.
-"- Most of the following examples use an unnamed data object.
-"- The specification of the name is not case-sensitive.
-
-ASSIGN ('IT') TO .
-ASSIGN ('ST') TO .
-
-"Field symbol declared inline
-"Note: The typing is performed with the generic type data.
-ASSIGN ('DOBJ') TO FIELD-SYMBOL().
-
-"The statements set the sy-subrc value.
-ASSIGN ('DOES_NOT_EXIST') TO .
-IF sy-subrc <> 0.
- ...
-ENDIF.
-
-"The memory area can also be a dereferenced data reference
-ASSIGN dref->* TO .
-
-"------- Assigning components dynamically ------
-"You can chain the names with the component selector (-), or, in
-"case of reference variables, the object component selector (->).
-ASSIGN st-('COL1') TO .
-ASSIGN it[ 1 ]-('COL1') TO .
-ASSIGN dref->('COL1') TO .
-"The following example uses the dereferencing operator explicitly
-"followed by the component selector.
-ASSIGN dref->*-('COL1') TO .
-
-"Using a named data object for the component specification
-DATA columnname TYPE string VALUE `COL1`.
-ASSIGN st-(columnname) TO .
-
-"Fully dynamic specification
-"If the compiler can fully determine the data object in ASSIGN statements
-"in ABAP for Cloud Development, a warning is not issued.
-ASSIGN ('ST-COL1') TO .
-
-"Numeric expressions are possible. Its value is interpreted
-"as the position of the component in the structure.
-ASSIGN st-(3) TO .
-
-"If the value is 0, the memory area of the entire structure is
-"assigned to the field symbol.
-ASSIGN st-(0) TO .
-
-"The statements above replace the following, older statements.
-ASSIGN COMPONENT 'COL1' OF STRUCTURE st TO .
-ASSIGN COMPONENT 3 OF STRUCTURE st TO .
-
-"------- Assigning attributes of classes or interfaces dynamically ------
-"The following syntax pattern shows the possible specifications.
-"... cref->(attr_name) ... "object reference variable
-"... iref->(attr_name) ... "interface reference variable
-"... (clif_name)=>(attr_name) ... "class/interface name
-"... (clif_name)=>attr ...
-"... clif=>(attr_name) ...
-
-"Creating an instance of a class
-DATA(oref) = NEW zcl_demo_abap_objects( ).
-
-"Assigning instance attributes using an object reference variable
-"All visible attributes of objects can be assigned.
-oref->string = `ABAP`. "Assigning a value to the attribute for demo purposes
-ASSIGN oref->('STRING') TO .
-
-"Assigning instance attributes using an interface reference variable
-DATA iref TYPE REF TO zdemo_abap_objects_interface.
-iref = oref.
-ASSIGN iref->('STRING') TO .
-iref->in_str = `hallo`.
-ASSIGN iref->('IN_STR') TO .
-
-"Assigning static attributes
-"All visible static attributes in classes and interfaces can be assigned
-"In the following example, a class and an interface are specified statically,
-"and the attributes are specified dynamically.
-ASSIGN zcl_demo_abap_objects=>('PUBLIC_STRING') TO .
-ASSIGN zdemo_abap_objects_interface=>('CONST_INTF') TO .
-
-"Specifying a class or interface dynamically, and attributes statically
-ASSIGN ('ZCL_DEMO_ABAP_OBJECTS')=>public_string TO .
-ASSIGN ('ZDEMO_ABAP_OBJECTS_INTERFACE')=>const_intf TO .
-
-"Specifying a class or interface as well as attributes dynamically
-ASSIGN ('ZCL_DEMO_ABAP_OBJECTS')=>('PUBLIC_STRING') TO .
-ASSIGN ('ZDEMO_ABAP_OBJECTS_INTERFACE')=>('CONST_INTF') TO .
-
-"Further dynamic syntax options are possible, for example,
-"specifying the memory area after ASSIGN with a writable expression
-"because the operand position after ASSIGN is a result position.
-ASSIGN NEW zcl_demo_abap_objects( )->('PUBLIC_STRING') TO .
-
-"ELSE UNASSIGN addition
-"If ELSE UNASSIGN is specified in the context of dynamic assignments/accesses,
-"no memory area is assigned to the field symbol. It is unassigned after
-"the ASSIGN statement.
-"Note: For the static variant of the ASSIGN statement, i.e. if the memory area
-"to be assigned following the ASSIGN keyword is statically specified, the addition
-"ELSE UNASSIGN is implicitly set and cannot be used explicitly.
-DATA(hallo) = `Hallo world`.
-ASSIGN ('HALLO') TO FIELD-SYMBOL() ELSE UNASSIGN.
-ASSERT sy-subrc = 0 AND IS ASSIGNED.
-ASSIGN ('DOES_NOT_EXIST') TO ELSE UNASSIGN.
-ASSERT sy-subrc = 4 AND IS NOT ASSIGNED.
-```
-
-> **💡 Note**⬆️ back to top
-
-### Dynamically Specifying Data Types/Creating (Data) Objects
-
-- For dynamic syntax elements in `CREATE OBJECT` statements, find more information [here](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abapcreate_object_explicit.htm) (note that parameters can be specified dynamically, too).
-- In addition to character-like data objects for the type name specified in the parentheses, you can also use [absolute type names](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenabsolute_typename_glosry.htm) (see the information about RTTI below).
-
-``` abap
-"Anonymous data objects are created using a type determined at
-"runtime. See more information below. Note that the NEW operator
-"cannot be used here.
-DATA(some_type) = 'STRING'.
-DATA dataref TYPE REF TO data.
-CREATE DATA dataref TYPE (some_type).
-CREATE DATA dataref TYPE TABLE OF (some_type).
-CREATE DATA dataref TYPE REF TO (some_type).
-"Using an absolute type name
-CREATE DATA dataref TYPE ('\TYPE=STRING').
-
-"Assigning a data object to a field symbol casting a dynamically
-"specified type
-TYPES clen5 TYPE c LENGTH 5.
-DATA: dobj_c10 TYPE c LENGTH 10 VALUE '1234567890',
- some_struct TYPE zdemo_abap_fli.
-FIELD-SYMBOLS TYPE data.
-
-ASSIGN dobj_c10 TO CASTING TYPE ('CLEN5'). "12345
-ASSIGN dobj_c10 TO CASTING LIKE some_struct-('CARRID'). "123
-
-"Dynamically creating an object as an instance of a class and
-"assigning the reference to the object to an object reference
-"variable. oref can be an object or interface reference variable.
-"The reference variable is created here with the generic 'object'.
-DATA oref_dyn TYPE REF TO object.
-CREATE OBJECT oref_dyn TYPE ('ZCL_DEMO_ABAP_OBJECTS').
-"Accessing an instance attribute
-oref_dyn->('ANOTHER_STRING') = `hi`.
-
-"Note: As covered further down and in the executable example,
-"CREATE DATA and ASSIGN statements have the HANDLE addition
-"after which dynamically created types can be specified. A type
-"description object is expected.
-
-"Getting type description object
-DATA(tdo_elem) = cl_abap_elemdescr=>get_c( 4 ).
-CREATE DATA dataref TYPE HANDLE tdo_elem.
-dataref->* = dobj_c10. "1234
-ASSIGN dobj_c10 TO CASTING TYPE HANDLE tdo_elem. "1234
-```
-
-⬆️ back to top
-
-### Accessing Structure Components Dynamically
-
-``` abap
-"Creating and populating various types/data objects to work with
-TYPES: BEGIN OF st_type,
- col1 TYPE i,
- col2 TYPE string,
- col3 TYPE string,
- END OF st_type.
-DATA st TYPE st_type.
-DATA it TYPE TABLE OF st_type WITH EMPTY KEY.
-st = VALUE #( col1 = 1 col2 = `aaa` col3 = `Z` ).
-APPEND st TO it.
-DATA(dref) = NEW st_type( col1 = 2 col2 = `b` col3 = `Y` ).
-
-"You can achieve the access using ASSIGN statements as shown above, or
-"by statically specifying the structure and the (object) component selector
-"followed by a character-like data object in parentheses.
-"Write position
-st-('COL1') = 123.
-it[ 1 ]-('COL1') = 456.
-dref->('COL1') = 789.
-
-"Read position
-"The example shows how you can retrieve the textual content of any component
-"of any structure.
-DATA(content_col2) = CONV string( st-('COL1') ).
-DATA(content_col3) = |{ st-('COL3') }|.
-DATA content_col1 LIKE st-col1.
-content_col1 = st-('COL1').
-
-DATA dref_comp TYPE REF TO data.
-CREATE DATA dref_comp LIKE st-('COL3').
-dref_comp->* = st-('COL3').
-
-"If the component is not found, a catchable exception is raised.
-TRY.
- DATA(col_not_existent) = |{ st-('COL123') }|.
- CATCH cx_sy_assign_illegal_component.
- ...
-ENDTRY.
-
-"Accessing components of generic structures dynamically,
-"e.g. if you have a method parameter that is typed with the generic type
-"data.
-"The example uses a field symbol with the generic type data which is assigned
-"a structure.
-FIELD-SYMBOLS TYPE data.
-ASSIGN st TO .
-
-"As in the examples above, specifying components dynamically is possible.
--('COL2') = `ABAP`.
-DATA(gen_comp) = CONV string( -('COL2') ).
-
-"Excursion
-"In the following example, a structure is assigned to a field symbol that
-"has a generic type. The components of the structure are accessed dynamically in
-"a DO loop. The sy-index value is interpreted as the position of the component
-"in the structure. Plus, using RTTI - as also shown further down - the component
-"names are retrieved. Component names and the values are added to a string. As a
-"prerequisite, all component values must be convertible to type string.
-DATA struc2string TYPE string.
-FIELD-SYMBOLS TYPE data.
-ASSIGN st TO .
-IF sy-subrc = 0.
- TRY.
- DATA(comps) = CAST cl_abap_structdescr( cl_abap_typedescr=>describe_by_data( ) )->components.
- DO.
- TRY.
- DATA(comp_name) = comps[ sy-index ]-name.
- struc2string = struc2string &&
- COND #( WHEN sy-index <> 1 THEN `, ` ) &&
- comp_name && `: "` &&
- -(sy-index) && `"`.
- CATCH cx_sy_assign_illegal_component cx_sy_itab_line_not_found.
- EXIT.
- ENDTRY.
- ENDDO.
- CATCH cx_sy_move_cast_error.
- ENDTRY.
-ENDIF.
-"struc2string: COL1: "123", COL2: "ABAP", COL3: "Z"
-```
-
-⬆️ back to top
-
-### Dynamic Specifications in Statements for Processing Internal Tables
-
-```abap
-"Creating and populating various types/data objects to work with
-TYPES: BEGIN OF demo_struct,
- col1 TYPE i,
- col2 TYPE string,
- col3 TYPE string,
- END OF demo_struct.
-DATA itab_ek TYPE TABLE OF demo_struct WITH EMPTY KEY.
-"Standard table and specification of primary and secondary table key
-DATA itab TYPE TABLE OF demo_struct
- WITH NON-UNIQUE KEY col1
- WITH UNIQUE SORTED KEY sk COMPONENTS col2.
-TYPES itab_type LIKE itab.
-DATA itab_ref TYPE TABLE OF REF TO demo_struct WITH EMPTY KEY.
-itab_ek = VALUE #( ( col1 = 1 col2 = `aaa` col3 = `zzz` )
- ( col1 = 2 col2 = `bbb` col3 = `yyy` )
- ( col1 = 3 col2 = `ccc` col3 = `xxx` ) ).
-itab = itab_ek.
-itab_ref = VALUE #( ( NEW demo_struct( col1 = 1 col2 = `aaa` col3 = `zzz` ) ) ).
-
-"Notes
-"- In statements using key specifications, secondary table key names (or alias names)
-" are usually specified. Also the primary table key using the predefined name
-" primary_key or its alias name can be used.
-"- Many of the following statements provide similar additions offering dynamic
-" specifications, such as USING KEY and dynamic component name specifications.
-
-"------- SORT ------
-"Named data object specified within parenteses
-DATA(field_name) = 'COL1'.
-SORT itab_ek BY (field_name) DESCENDING.
-"Unnamed data object specified within parenteses
-SORT itab_ek BY ('COL2') ASCENDING.
-
-"------- READ TABLE ------
-"Reading by specifying keys dynamically
-"Implicitly specifying the table key values in a work area (USING KEY addition)
-DATA(wa_read) = VALUE demo_struct( col2 = `aaa` ).
-READ TABLE itab FROM wa_read USING KEY ('SK') REFERENCE INTO DATA(read_ref).
-
-"Explicitly specifying the key and key values (TABLE KEY addition)
-"The component names can also be specified dynamically (which is done in most of the
-"following examples for demonstration purposes). Note that each component of the table
-"key must be specified.
-READ TABLE itab WITH TABLE KEY ('SK') COMPONENTS ('COL2') = `aaa` REFERENCE INTO read_ref.
-"Specifying the predefined name primary_key explicitly and dynamically
-READ TABLE itab WITH TABLE KEY ('PRIMARY_KEY') COMPONENTS ('COL1') = 1 REFERENCE INTO read_ref.
-"If the addition COMPONENTS is not specified, the primary table key is implicitly used.
-READ TABLE itab WITH TABLE KEY ('COL1') = 1 REFERENCE INTO read_ref.
-
-"Reading using a free key (WITH KEY addition)
-READ TABLE itab WITH KEY ('COL3') = `yyy` REFERENCE INTO read_ref.
-"The addition can also be used by specifying a secondary table key name
-READ TABLE itab WITH KEY ('SK') COMPONENTS ('COL2') = `ccc` REFERENCE INTO read_ref.
-
-"Reading based on a table index (INDEX addition)
-"Not using the addition USING KEY means reading from the primary table index.
-READ TABLE itab INDEX 1 USING KEY ('SK') REFERENCE INTO read_ref.
-
-"More dynamic specification options when specifying the target as work area
-"(COMPARING/TRANSPORTING additions)
-"TRANSPORTING: Specifying which components shall be respected
-READ TABLE itab INDEX 1 INTO DATA(workarea) TRANSPORTING ('COL1') ('COL3').
-
-"COMPARING: If the content of the compared components is identical, sy-subrc is set
-"to 0, and otherwise to 2. The line found is assigned to the work area independently
-"of the result of the comparison.
-workarea-('COL3') = `uvw`.
-READ TABLE itab INDEX 1 INTO workarea COMPARING ('COL3') TRANSPORTING ('COL1') ('COL3').
-IF sy-subrc <> 0.
- ...
-ENDIF.
-
-"------- Table expressions ------
-"Similar to READ TABLE statements, you can specify table lines with 3 alternatives:
-"index read, read using free key, table key
-"Also there, dynamic specifications are possible regarding the key specifications.
-
-"Reading based on index with dynamic key specifications
-"Specifying the secondary table index of a sorted secondary key
-DATA(wa_te1) = itab[ KEY ('SK') INDEX 1 ].
-"Reading using a free key, the keys are specified dynamically
-DATA(wa_te2) = itab[ ('COL2') = `bbb` ('COL3') = `yyy` ].
-
-"Reading using a table key
-"Specyfing the table key explicitly
-"Note: Unlike READ TABLE statements, the name of the table key must be specified. The
-"addition COMPONENTS can be omitted.
-"In the following example, the component names are also specified dynamically.
-DATA(wa_te3) = itab[ KEY ('SK') ('COL2') = `ccc` ].
-"Specifying the COMPONENTS addition explicitly
-DATA(wa_te4) = itab[ KEY ('PRIMARY_KEY') COMPONENTS ('COL1') = 1 ].
-
-"Accessing components
-"As shown above, chaininings with the (object) component selector are possible.
-"The examples use index access and write positions.
-itab[ 1 ]-('COL2') = `jkl`.
-itab_ref[ 1 ]->('COL2') = `mno`.
-
-"------- LOOP AT ------
-"USING KEY addition: Overriding the standard order determined by the table category
-LOOP AT itab REFERENCE INTO DATA(ref) USING KEY ('SK').
- ...
-ENDLOOP.
-
-"When the primary table key is specified, the loop behaves as if it was not specified.
-"So, the following statement corresponds to the one below.
-LOOP AT itab REFERENCE INTO ref USING KEY ('PRIMARY_KEY').
- ...
-ENDLOOP.
-
-LOOP AT itab REFERENCE INTO ref.
- ...
-ENDLOOP.
-
-"Dynamic WHERE condition
-"You can specify a character-like data object or a standard table with character-like
-"line type.
-DATA(cond_loop) = `COL1 > 1`.
-LOOP AT itab REFERENCE INTO ref WHERE (cond_loop).
- ...
-ENDLOOP.
-
-"------- INSERT ------
-"The USING KEY addition (which accepts a dynamic specification) affects the order in which lines are inserted.
-
-"Result of the following example when using the ...
-"- secondary table key: order of itab entries 5 ... /4 ... /...
-"- primary table key: order of itab entries 4 ... /5 ... /...
-INSERT LINES OF VALUE itab_type( ( col1 = 4 col2 = `eee` col3 = `www` )
- ( col1 = 5 col2 = `ddd` col3 = `vvv` ) )
- USING KEY ('SK')
- "USING KEY ('PRIMARY_KEY')
- INTO itab INDEX 1.
-
-"Excursion: Using LOOP AT statements with the USING KEY addition
-"and exploring the table index
-"Declaring demo tables to hold the internal table entries
-DATA it_seckey_idx TYPE TABLE OF demo_struct WITH EMPTY KEY.
-DATA it_primekey_idx LIKE it_seckey_idx.
-
-"Visualizing the secondary table index
-LOOP AT itab INTO DATA(wa_sk) USING KEY ('SK').
- APPEND wa_sk TO it_seckey_idx.
-ENDLOOP.
-
-"Visualizing the primary table index
-LOOP AT itab INTO DATA(wa_pk) USING KEY ('PRIMARY_KEY').
- APPEND wa_pk TO it_primekey_idx.
-ENDLOOP.
-
-"------- MODIFY ------
-"In the following example, a line is modified based on a work area and a table key.
-"The component col1 is left out from the work area intentionally.
-"If the primary table key was used, the value of sy-subrc would be 4, and no modification was done.
-"The optional addition transporting is specified to denote what should be modified. In this example,
-"the component is also specified dynamically.
-MODIFY TABLE itab FROM VALUE #( col2 = `bbb` col3 = `uuu` ) USING KEY ('SK') TRANSPORTING ('COL3').
-
-"In the following example, a line is modified based on a work area, an index specification and a
-"table key.
-"INDEX can also be positioned after FROM.
-MODIFY itab INDEX 2 USING KEY ('SK') FROM VALUE #( col3 = `ttt` ) TRANSPORTING ('COL3').
-
-"Dynamic WHERE clause (only to be used with the TRANSPORTING addition)
-"The USING KEY addition is also possible. Check the ABAP Keyword Documentation
-"for special rules that apply.
-DATA(cond_mod) = `COL1 < 3`.
-MODIFY itab FROM VALUE #( col3 = `sss` ) TRANSPORTING ('COL3') WHERE (cond_mod).
-
-"------- DELETE ------
-"A single line or multipled lines can be deleted.
-"Note that DELETE ADJACENT DUPLICATES statements can also be specified using
-"dynamic parts.
-
-"Deleting based on a dynamically specified table key
-"The values can be declared either implicitly in a work area after FROM or explicitly
-"by listing the components of the table key after TABLE KEY.
-"If the USING KEY addition is not specified, the primary table key is used by default.
-DELETE TABLE itab FROM VALUE #( col2 = `eee` col3 = `www` ) USING KEY ('SK').
-
-"Each component of the table key must be listed.
-DELETE TABLE itab WITH TABLE KEY ('SK') COMPONENTS ('COL2') = `ddd`.
-
-"Deleting based on the table index
-DELETE itab INDEX 1 USING KEY ('SK').
-
-"Deleting multiple lines and specifying the WHERE conditions dynamically
-"The USING KEY addition is also possible.
-DATA(condition_tab) = VALUE string_table( ( `COL1 < 3` )
- ( `OR` )
- ( `COL3 = ``www``` ) ).
-DELETE itab WHERE (condition_tab).
-```
-
-⬆️ back to top
-
-### Dynamic ABAP SQL Statements
-
-```abap
-"Dynamic SELECT list
-DATA(select_list) = `CARRID, CONNID, FLDATE`.
-DATA fli_tab TYPE TABLE OF zdemo_abap_fli WITH EMPTY KEY.
-
-SELECT (select_list)
- FROM zdemo_abap_fli
- INTO CORRESPONDING FIELDS OF TABLE @fli_tab.
-
-"Dynamic FROM clause
-DATA(table) = 'ZDEMO_ABAP_FLI'.
-SELECT *
- FROM (table)
- INTO TABLE @fli_tab.
-
-"Excursion: Compatible target data objects
-"In the examples above, the data object/type is created statically.
-
-"Creating an anonymous data object with a CREATE DATA statement
-"and specifiying the type dynamically.
-"You can use the dereferenced object reference variable as target.
-DATA itab_dyn TYPE REF TO data.
-CREATE DATA itab_dyn TYPE TABLE OF (table).
-
-SELECT *
- FROM (table)
- INTO TABLE @itab_dyn->*.
-
-"In older ABAP code, you may find assignments to a field symbol
-"due to the reasons mentioned above.
-FIELD-SYMBOLS TYPE ANY TABLE.
-ASSIGN itab_dyn->* TO .
-
-SELECT *
- FROM (table)
- INTO TABLE @.
-
-"Similar to the NEW operator, you can use the addition NEW
-"to create an anonymous data object in place. The advantage is
-"that the data type is constructed in a suitable way.
-SELECT *
- FROM (table)
- INTO TABLE NEW @DATA(dref_tab).
-
-"Dynamic WHERE clause
-"The example includes a WHERE clause that is created as an internal
-"table with a character-like row type.
-DATA(where_clause) = VALUE string_table( ( `CARRID = 'LH'` )
- ( `OR` )
- ( `CARRID = 'AA'` ) ).
-
-SELECT *
- FROM zdemo_abap_fli
- WHERE (where_clause)
- INTO TABLE NEW @DATA(tab_dyn_where).
-
-"Dynamic ORDER BY clause
-SELECT *
- FROM zdemo_abap_fli
- ORDER BY (`FLDATE`)
- INTO TABLE NEW @DATA(tab_dyn_order).
-
-"SELECT statement with miscellaneous dynamic specifications
-SELECT (`CARRID, CONNID, FLDATE`)
- FROM (`ZDEMO_ABAP_FLI`)
- WHERE (`CARRID <> ``AA```)
- ORDER BY (`FLDATE`)
- INTO TABLE NEW @DATA(tab_dyn_misc).
-
-"Further dynamic specifications in other ABAP SQL statements
-"Creating a structure to be inserted into the database table
-SELECT SINGLE *
- FROM (table)
- INTO NEW @DATA(dref_struc).
-dref_struc->('CARRID') = 'YZ'.
-
-INSERT (table) FROM @dref_struc->*.
-
-dref_struc->('CURRENCY') = 'EUR'.
-UPDATE (table) FROM @dref_struc->*.
-
-dref_struc->('SEATSOCC') = 10.
-MODIFY (table) FROM @dref_struc->*.
-
-DELETE FROM (table) WHERE (`CARRID = 'YZ'`).
-```
-
-⬆️ back to top
-
-**Excursion**: To take up the use case mentioned in the introduction about retrieving the content of a database table, storing it in an internal table, and
-displaying it when the database table name is specified dynamically at
-runtime, see the following code snippet. Note the comments.
-
-
-```abap
-CLASS zcl_example_class DEFINITION
- PUBLIC
- FINAL
- CREATE PUBLIC .
-
- PUBLIC SECTION.
- INTERFACES if_oo_adt_classrun.
- PROTECTED SECTION.
- PRIVATE SECTION.
-ENDCLASS.
-CLASS zcl_example_class IMPLEMENTATION.
- METHOD if_oo_adt_classrun~main.
- "The example retrieves the content of a database table, storing it in an
- "internal table, and displaying it when the database table name is
- "specified dynamically at runtime.
- "Certainly, there are quite some ways to achieve it, and that work out
- "of the box. For example, in ABAP for Cloud Development, you can implement
- "the classrun if_oo_adt_classrun and output content using the out->write(...)
- "method. You can also inherit from cl_demo_classrun in your class. In
- "classic ABAP, you can, for example and additionally, use cl_demo_output or
- "ALV.
- "Notes:
- "- The following example is just ABAP code exploring dynamic programming
- " aspects. Note the disclaimer in the README of the cheat sheet repository.
- " It is an example that sets its focus on a dynamic SELECT statement and
- " processing internal table content by dynamically accessing structure
- " components.
- "- The ways mentioned above are way more powerful (e.g. in most cases also
- " nested and deep data objects can be displayed for demo purposes).
- "- For simplicity, column contents are converted to string here if necessary,
- " i.e. all column contents must be convertible to string.
- "- For display purposes, the snippet uses the classrun methods to display
- " results sequentially - instead of displaying the internal table
- " content retrieved by the SELECT statement directly.
- "- The example uses database tables from the cheat sheet repository. To fill
- " them, you can use the method call zcl_demo_abap_aux=>fill_dbtabs( )..
- zcl_demo_abap_aux=>fill_dbtabs( ).
-
- "Data objects and types relevant for the example (length and offset for
- "content display)
- DATA str TYPE string.
- TYPES: BEGIN OF comp_struc,
- name TYPE string,
- len TYPE i,
- off TYPE i,
- END OF comp_struc.
- DATA it_comps TYPE TABLE OF comp_struc WITH EMPTY KEY.
-
- "Database table of type string containing names of database tables;
- "table is looped over to output content of all database tables
- DATA(dbtabs) = VALUE string_table( ( `ZDEMO_ABAP_CARR` )
- ( `ZDEMO_ABAP_FLI` )
- ( `ZDEMO_ABAP_FLSCH` ) ).
-
- LOOP AT dbtabs INTO DATA(dbtab).
- "Retrieving database content of a dynamically specified database table
- TRY.
- SELECT *
- FROM (dbtab)
- INTO TABLE NEW @DATA(itab)
- UP TO 5 ROWS.
- CATCH cx_sy_dynamic_osql_semantics INTO DATA(sql_error).
- CLEAR itab->*.
- out->write( |Table { dbtab } does not exist.| ).
- ENDTRY.
-
- IF sql_error IS INITIAL.
- "Getting table component names using RTTI methods
- TRY.
- DATA(type_descr_obj_tab) = CAST cl_abap_tabledescr(
- cl_abap_typedescr=>describe_by_data( itab->* ) ).
- DATA(tab_comps) = CAST cl_abap_structdescr(
- type_descr_obj_tab->get_table_line_type( ) )->get_components( ).
- LOOP AT tab_comps ASSIGNING FIELD-SYMBOL().
- APPEND VALUE #( name = -name len = strlen( -name ) ) TO it_comps.
- ENDLOOP.
- CATCH cx_sy_move_cast_error INTO DATA(error).
- out->write( |{ error->get_text( ) }| ).
- ENDTRY.
-
- IF error IS INITIAL.
- out->write( |\n| ).
- out->write( |Retrieved content of database table { dbtab }:| ).
- "Implementation for properly aligning the content
- "The example is implemented to check the length of the column names as well as the
- "length of the values in the columns. It determines the length of the longest string
- "in each column. Depending on the length values, either the length of the column name
- "or the length of the longest string in a column is stored in an internal table that
- "contains information for calculating the offset.
- LOOP AT tab_comps ASSIGNING FIELD-SYMBOL().
- ASSIGN it_comps[ name = -name ] TO FIELD-SYMBOL().
- DATA(max_content) = REDUCE i( INIT len = -len
- FOR IN itab->*
- NEXT len = COND #( WHEN strlen( CONV string( -(-name) ) ) > len
- THEN strlen( CONV string( -(-name) ) )
- ELSE len ) ).
- "Extend the length value to leave some more space
- IF max_content > -len.
- -len = max_content + 3.
- ELSE.
- -len += 3.
- ENDIF.
- ENDLOOP.
- "Calculating offset values
- DATA max_str_len TYPE i.
- LOOP AT it_comps ASSIGNING FIELD-SYMBOL().
- DATA(tabix) = sy-tabix.
- READ TABLE it_comps INDEX tabix - 1 ASSIGNING FIELD-SYMBOL().
- -off = COND #( WHEN tabix = 1 THEN 0 ELSE -len + -off ).
- max_str_len += -len.
- ENDLOOP.
- "Providing enough space so that table row content can be inserted based on
- "the offset specification
- SHIFT str BY max_str_len PLACES RIGHT.
- "Adding the column names first
- LOOP AT it_comps ASSIGNING FIELD-SYMBOL().
- str = insert( val = str sub = -name off = -off ).
- ENDLOOP.
- out->write( str ).
- "Processing all lines in the internal table containing the retrieved table rows
- LOOP AT itab->* ASSIGNING FIELD-SYMBOL().
- CLEAR str.
- SHIFT str BY max_str_len PLACES RIGHT.
- DO.
- TRY.
- str = insert( val = str sub = -(sy-index) off = it_comps[ sy-index ]-off ).
- CATCH cx_sy_assign_illegal_component cx_sy_range_out_of_bounds cx_sy_itab_line_not_found.
- EXIT.
- ENDTRY.
- ENDDO.
- out->write( str ).
- ENDLOOP.
- ENDIF.
- out->write( |\n| ).
- CLEAR: str, it_comps.
- ENDIF.
- ENDLOOP.
- ENDMETHOD.
-ENDCLASS.
-```
-
-⬆️ back to top
-
-### Dynamic Invoke
-The following code snippet shows dynamically specifying [procedure](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenprocedure_glosry.htm "Glossary Entry") calls.
-
-``` abap
-"Note: Dynamic method calls require a CALL METHOD statement.
-"The following examples assume that there are no mandatory
-"parameters defined for the method.
-"Possible for methods of the same class, works like me->(meth)
-CALL METHOD (meth).
-"Class specified statically
-CALL METHOD class=>(meth).
-"Object reference variable specified statically;
-"also possible for interface reference variables
-CALL METHOD oref->(meth).
-
-"The following statements are possible for all visible static methods
-"Class dynamically specified
-CALL METHOD (class)=>meth.
-"Class and method dynamically specified
-CALL METHOD (class)=>(meth).
-
-"The following examples assume that there are parameters defined
-"for the method.
-"Assigning actual parameters to the formal parameters statically
-CALL METHOD class=>(meth) EXPORTING p1 = a1 p2 = a2 ...
- IMPORTING p1 = a1 p2 = a2 ...
-
-"Assigning actual parameters to the formal parameters dynamically
-DATA ptab TYPE abap_parmbind_tab.
-ptab = ...
-
-CALL METHOD class=>(meth) PARAMETER-TABLE ptab.
-
-"Notes on PARAMETER-TABLE ptab
-"- The table (of type abap_parmbind_tab; line type is abap_parmbind)
-" must be filled and have a line for all non-optional parameters.
-"- Components: name -> formal parameter name
-" kind -> kind of parameter, e. g. importing
-" value -> pointer to appropriate actual parameter,
-" is of type REF TO data
-"The addition EXCEPTION-TABLE for exceptions is not dealt with here.
-
-"Example that uses the PARAMETER-TABLE addition
-"Creating an instance by specifying the type statically
-"An example class of the cheat sheet repository is used.
-DATA(oref1) = NEW zcl_demo_abap_objects( ).
-"Calling an instance method
-"The method multiplies an integer by 3.
-"The calculation result is returned.
-DATA(result) = oref1->triple( i_op = 2 ). "6
-
-"Dynamic equivalent
-"Creating an instance of a class by specifying the type
-"dynamically
-DATA oref2 TYPE REF TO object.
-CREATE OBJECT oref2 TYPE ('ZCL_DEMO_ABAP_OBJECTS').
-
-"Creating parameter table
-DATA(ptab) = VALUE abap_parmbind_tab( ( name = 'I_OP'
- kind = cl_abap_objectdescr=>exporting
- value = NEW i( 3 ) )
- ( name = 'R_TRIPLE'
- kind = cl_abap_objectdescr=>returning
- value = NEW i( ) ) ).
-
-"Dynamic method call and specifying a parameter table
-CALL METHOD oref2->('TRIPLE') PARAMETER-TABLE ptab.
-result = ptab[ name = 'R_TRIPLE' ]-('VALUE')->*. "9
-```
-
-⬆️ back to top
-
-### Validating Input for Dynamic Specifications (CL_ABAP_DYN_PRG)
-
-You can use the `CL_ABAP_DYN_PRG` class to validate input for dynamic specifications.
-There are several methods for different use cases. See the class documentation (click F2 on the class name in ADT) for more information.
-The following examples show some of those methods. If the validation is successful, the methods in the examples return the input value.
-Otherwise, an exception is raised.
-
-```abap
-"The following method checks database table names. The name is provided
-"with the val parameter. The packages formal parameter expects a table
-"containing the names of packages in which the specified table should be
-"included. Assuming you provide incorrect input for the table name, or
-"the table is not contained in the specified packages, you can expect an
-"exception to be raied.
-
-TRY.
- DATA(dbtab) = cl_abap_dyn_prg=>check_table_name_tab(
- val = `ZDEMO_ABAP_FLI`
- packages = VALUE #( ( `TEST_ABAP_CHEAT_SHEETS` )
- ( `TEST_SOME_PACK` ) ) ).
-
- SELECT SINGLE * FROM (dbtab) INTO NEW @DATA(ref_wa).
- CATCH cx_abap_not_a_table cx_abap_not_in_package.
- ...
-ENDTRY.
-
-"In the following examples, a method is used to check whether
-"the input is allowed or not. For this, you specify an allowlist.
-"Here, the relvant parameter expects a comma-separated list of
-"allowed values.
-TRY.
- DATA(value1) = cl_abap_dyn_prg=>check_allowlist(
- val = `A`
- allowlist_str = `A,B,C,D` ).
-
- ... "Here might go an ABAP SQL statement with a dynamic specification.
- CATCH cx_abap_not_in_allowlist.
- ...
-ENDTRY.
-
-"Another parameter of the method expects an internal table that
-"contains the allowed values.
-TRY.
- DATA(value2) = cl_abap_dyn_prg=>check_allowlist(
- val = `XYZ`
- allowlist_htab = VALUE #( ( `A` )
- ( `B` )
- ( `C` )
- ( `D` ) ) ).
-
- ... "Here might go an ABAP SQL statement with a dynamic specification.
- CATCH cx_abap_not_in_allowlist.
- ...
-ENDTRY.
-```
-
-⬆️ back to top
-
-## Runtime Type Services (RTTS)
-
-[RTTS](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenrun_time_type_services_glosry.htm "Glossary Entry")
-represent a hierarchy of [type description classes](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abentype_class_glosry.htm "Glossary Entry")
-containing methods for
-- getting type information on data objects, data types or
- [instances](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abeninstance_glosry.htm "Glossary Entry")
- at runtime ([Runtime Type Identification (RTTI)](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenrun_time_type_identific_glosry.htm "Glossary Entry")).
-- defining and creating new data types as [type description objects](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abentype_object_glosry.htm) at runtime ([Runtime Type Creation (RTTC)](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenrun_time_type_creation_glosry.htm "Glossary Entry")).
-
-The hierarchy of type description classes is as follows.
-
-
-CL_ABAP_TYPEDESCR
- |
- |--CL_ABAP_DATADESCR
- | |
- | |--CL_ABAP_ELEMDESCR
- | | |
- | | |--CL_ABAP_ENUMDESCR
- | |
- | |--CL_ABAP_REFDESCR
- | |--CL_ABAP_COMPLEXDESCR
- | |
- | |--CL_ABAP_STRUCTDESCR
- | |--CL_ABAP_TABLEDESCR
- |
- |--CL_ABAP_OBJECTDESCR
- |
- |--CL_ABAP_CLASSDESCR
- |--CL_ABAP_INTFDESCR
-
-So, the
-[superclass](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abensuperclass_glosry.htm "Glossary Entry")
-`CL_ABAP_TYPEDESCR` has multiple
-[subclasses](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abensubclass_glosry.htm "Glossary Entry"),
-for example, to deal with each kind of type.
-Working with this inheritance tree means making use of
-[casts](https://help.sap.com/doc/abapdocu_latest_index_htm/latest/en-US/index.htm?file=abencast_glosry.htm "Glossary Entry"),
-especially
-[downcasts](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendown_cast_glosry.htm "Glossary Entry") when retrieving information at runtime.
-Detailing out all the possibilities for the information retrieval and
-type creation is beyond scope. Check the information, options and
-various methods that can be used in the class documentation, e. g. using
-F2 help information in
-[ADT](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenadt_glosry.htm "Glossary Entry"),
-for more details.
-
-⬆️ back to top
-
-### Getting Type Information at Runtime
-
-With RTTI, you can determine data types at runtime using description methods in type description classes.
-To get the type information, you can get a reference to a type description object of a type, that is, an instance of a type description class.
-The type properties are represented by attributes that are accessible through the type description object.
-
-
-> **💡 Note**⬆️ back to top
-
-### Dynamically Creating Data Types at Runtime
-You can create data types at program runtime using methods of the type description classes of RTTS.
-These types are only valid locally in the program. They are also anonymous, i.e. they are only accessible through type description objects.
-As shown above, you can get a reference to a type description object of a type using the static methods of the class `CL_ABAP_TYPEDESCR`.
-```abap
-"For example, a structured type
-DATA(type_descr_obj) = CAST cl_abap_structdescr(
- cl_abap_typedescr=>describe_by_name( 'SOME_STRUC_TYPE' ) ).
-```
-
-The focus here is on using RTTC methods such as `get...`. It is recommended that you use the `get` method instead of the `create` method.
-
-```abap
-"----------------------------------------------------------------------
-"--- Creating type description objects using elementary data types ----
-"----------------------------------------------------------------------
-"Conceptually, all elementary, built-in ABAP types already
-"exist and can be accessed by the corresponding get_* methods.
-"In ADT, click CTRL + space after cl_abap_elemdescr=>...
-"to check out the options. The following examples show a
-"selection.
-
-DATA(tdo_elem_i) = cl_abap_elemdescr=>get_i( ).
-DATA(tdo_elem_string) = cl_abap_elemdescr=>get_string( ).
-
-"For the length specification of type c and others, there is
-"an importing parameter available.
-DATA(tdo_elem_c_l20) = cl_abap_elemdescr=>get_c( 20 ).
-
-"Type p with two parameters to be specified.
-DATA(tdo_elem_p) = cl_abap_elemdescr=>get_p( p_length = 3
- p_decimals = 2 ).
-
-"Note: Instead of calling get_i() and others having no importing
-"parameters, you could also call the describe_by_name( ) method
-"and pass the type names (I‚ STRING etc.) as arguments.
-"DATA(tdo_elem_i_2) = CAST cl_abap_elemdescr(
-" cl_abap_typedescr=>describe_by_name( 'I' ) ).
-"DATA(tdo_elem_string_2) = CAST cl_abap_elemdescr(
-" cl_abap_typedescr=>describe_by_name( 'STRING' ) ).
-
-"----------------------------------------------------------------------
-"--- Creating type description objects using structured data types ----
-"----------------------------------------------------------------------
-"They are created based on a component description table.
-
-"A structured type such as the following shall be created dynamically
-"using a type description object.
-TYPES: BEGIN OF struc_type,
- a TYPE string,
- b TYPE i,
- c TYPE c LENGTH 5,
- d TYPE p LENGTH 4 DECIMALS 3,
- END OF struc_type.
-
-"Creating a type description object using RTTC method
-"Using the get method, you can create the type description object
-"dynamically based on a component table. The component table is
-"of type abap_component_tab. In this example, the component table
-"is created inline.
-DATA(tdo_struc) = cl_abap_structdescr=>get(
- VALUE #(
- ( name = 'A' type = cl_abap_elemdescr=>get_string( ) )
- ( name = 'B' type = cl_abap_elemdescr=>get_i( ) )
- ( name = 'C' type = cl_abap_elemdescr=>get_c( 5 ) )
- ( name = 'D' type = cl_abap_elemdescr=>get_p( p_length = 4
- p_decimals = 3 ) ) ) ).
-
-"---------------------------------------------------------------------
-"--- Creating type description objects using internal table types ----
-"---------------------------------------------------------------------
-"Note: Specifying the line type is mandatory, the rest is optional.
-
-"An internal table type such as the following shall be created dynamically
-"using a type description object.
-TYPES std_tab_type_std_key TYPE STANDARD TABLE OF string WITH DEFAULT KEY.
-
-"Creating a type description object using RTTC method
-"Not specifying the other optional parameters means that the
-"default values are used, for example, standard table is the
-"default value for p_table_kind.
-DATA(tdo_tab_1) = cl_abap_tabledescr=>get(
- p_line_type = cl_abap_elemdescr=>get_string( ) ).
-
-"Another internal table type for which more parameter specifications
-"are needed. The following internal table type shall be created using
-"a type description object.
-TYPES so_table_type TYPE SORTED TABLE OF zdemo_abap_flsch WITH UNIQUE KEY carrid connid.
-
-"Creating a type description object using RTTC method
-"The following example also demonstrates how comfortably constructor
-"operators can be used at these positions.
-DATA(tdo_tab_2) = cl_abap_tabledescr=>get(
- p_line_type = CAST cl_abap_structdescr(
- cl_abap_tabledescr=>describe_by_name( 'ZDEMO_ABAP_FLSCH' ) )
- p_table_kind = cl_abap_tabledescr=>tablekind_sorted
- p_key = VALUE #( ( name = 'CARRID' ) ( name = 'CONNID' ) )
- p_unique = cl_abap_typedescr=>true ).
-
-" ... reference types
-"Reference types such as the following shall be created using a
-"type description object.
-TYPES some_ref_type2t TYPE REF TO t.
-TYPES some_ref_type2cl TYPE REF TO zcl_demo_abap_dynamic_prog.
-
-"Using RTTC methods
-"You can create a reference type from a base type. This base type
-"may be a class, interface or data type.
-DATA(tdo_ref_1) = cl_abap_refdescr=>get( cl_abap_elemdescr=>get_t( ) ).
-DATA(tdo_ref_2) = cl_abap_refdescr=>get(
- cl_abap_typedescr=>describe_by_name( 'ZCL_DEMO_ABAP_DYNAMIC_PROG' ) ).
-"Alternative: get_by_name method
-DATA(tdo_ref_3) = cl_abap_refdescr=>get_by_name( 'T' ).
-DATA(tdo_ref_4) = cl_abap_refdescr=>get_by_name( 'ZCL_DEMO_ABAP_DYNAMIC_PROG' ).
-```
-
-⬆️ back to top
-
-### Dynamically Creating Data Objects at Runtime
-
-As shown above, anonymous data objects can be dynamically created using `CREATE DATA` statements in many ways by specifying the type ...
-- statically: `CREATE DATA dref TYPE string.`
-- dynamically: `CREATE DATA dref TYPE (some_type).`
-
-Another way to dynamically create data objects with dynamic type specification is to use types created at runtime with RTTC methods.
-The `CREATE DATA` statement provides the [`TYPE HANDLE`](https://help.sap.com/doc/abapdocu_latest_index_htm/latest/en-US/index.htm?file=abapcreate_data_handle.htm) addition after which you can specify type description objects. A reference variable of the static type of class `CL_ABAP_DATADESCR` or its subclasses that points to a type description object can be specified after `TYPE HANDLE`.
-
-``` abap
-DATA dref_cr TYPE REF TO data.
-
-"Elementary data object
-"Type description object for an elementary type
-DATA(tdo_elem_c_l20) = cl_abap_elemdescr=>get_c( 20 ).
-"Creating an elementary data object based on a type description object
-CREATE DATA dref_cr TYPE HANDLE tdo_elem_c_l20.
-
-"Structure
-DATA(tdo_struc) = cl_abap_structdescr=>get(
- VALUE #(
- ( name = 'COMP1' type = cl_abap_elemdescr=>get_string( ) )
- ( name = 'COMP2' type = cl_abap_elemdescr=>get_i( ) )
- ( name = 'COMP3' type = cl_abap_elemdescr=>get_c( 3 ) ) ) ).
-
-"Creating a structure based on a type description object
-CREATE DATA dref_cr TYPE HANDLE tdo_struc.
-
-"Internal table
-"In the case below, it is a standard table with standard key by
-"default because the other parameters are not specified.
-DATA(tdo_tab) = cl_abap_tabledescr=>get(
- p_line_type = CAST cl_abap_structdescr(
- cl_abap_tabledescr=>describe_by_name( 'ZDEMO_ABAP_CARR' ) ) ).
-
-"Creating an internal table based on a type description object
-CREATE DATA dref_cr TYPE HANDLE tdo_tab.
-
-"Data reference
-DATA(tdo_ref) = cl_abap_refdescr=>get( cl_abap_elemdescr=>get_t( ) ).
-CREATE DATA dref_cr TYPE HANDLE tdo_ref.
-```
-
-⬆️ back to top
-
-## More Information
-- It is recommended that you also consult section [Dynamic Programming Techniques (F1 docu for standard ABAP)](https://help.sap.com/doc/abapdocu_latest_index_htm/latest/en-US/index.htm?file=abendynamic_prog_technique_gdl.htm) in the ABAP Keyword Documentation since it provides important aspects that should be considered when dealing with dynamic programming in general (e. g. security aspects or runtime error prevention).
-- There are even further dynamic programming techniques in the unrestricted ABAP language scope [Standard ABAP](https://help.sap.com/doc/abapdocu_latest_index_htm/latest/en-US/index.htm?file=abenstandard_abap_glosry.htm) such as the generation or execution of programs at runtime. They are not part of this cheat sheet. Find more details on the related syntax (e. g. `GENERATE SUBROUTINE POOL`, `READ REPORT` and `INSERT REPORT` in the ABAP Keyword Documentation for Standard ABAP: [Dynamic Program Development (F1 docu for standard ABAP)](https://help.sap.com/doc/abapdocu_latest_index_htm/latest/en-US/index.htm?file=abenabap_language_dynamic.htm)
-
-## Executable Example
-
-[zcl_demo_abap_dynamic_prog](./src/zcl_demo_abap_dynamic_prog.clas.abap)
-
-> **💡 Note**⬆️ back to top
+
+## Excursion: Field Symbols and Data References
+
+[Field symbols](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenfield_symbol_glosry.htm "Glossary Entry")
+and [data references](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendata_reference_glosry.htm "Glossary Entry") are covered here since they are supporting elements for dynamic programming.
+
+### Field Symbols
+
+Field symbols ...
+
+- are symbolic names for almost any data object or parts of existing data objects.
+- can be assigned actual memory areas at program runtime (using `ASSIGN`). Note that you can only work with the field symbols if indeed they have been assigned before.
+- can be used as placeholders for a data object at an [operand position](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenoperand_position_glosry.htm).
+ - Consider there is a data object in your program. A field symbol is also available that is assigned the memory area of this data object. Accessing a field symbol is like accessing the [named data object](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abennamed_data_object_glosry.htm) or part of the object itself.
+- do not reserve physical space in the [data area](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendata_area_glosry.htm) of a program like a data object. Instead, they work as dynamic identifiers of a memory area in which a specific data object or part of an object is located.
+- can be typed either with [generic data types](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abengeneric_data_type_glosry.htm "Glossary Entry") or [complete data types](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abencomplete_data_type_glosry.htm "Glossary Entry").
+- are declared using the statement [`FIELD-SYMBOLS`](https://help.sap.com/doc/abapdocu_latest_index_htm/latest/en-US/index.htm?file=abapfield-symbols.htm) or the [declaration operator](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendeclaration_operator_glosry.htm) [`FIELD-SYMBOL`](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenfield-symbol_inline.htm). Their names must be included between angle brackets.
+
+**Declaring field symbols**
+
+Syntax:
+``` abap
+"Declaring field symbols using the FIELD-SYMBOLS statement
+"and providing a complete/generic type
+
+"Examples for complete types
+FIELD-SYMBOLS: TYPE i,
+ TYPE zdemo_abap_fli,
+ TYPE LINE OF some_table_type,
+ LIKE some_data_object.
+
+"Examples for generic types (see more examples further down)
+FIELD-SYMBOLS TYPE c. "Text field with a generic length
+FIELD-SYMBOLS TYPE csequence. "Text-like (c, string)
+FIELD-SYMBOLS TYPE data. "Any data type
+FIELD-SYMBOLS TYPE any table. "Internal table with any table type
+
+"Declaring field symbols inline
+"In an inline declaration, the typing of the field symbol is done
+"with the generic type data.
+"Example use case: Inline declaration of a field symbol for an internal table.
+LOOP AT itab ASSIGNING FIELD-SYMBOL().
+ ...
+ENDLOOP.
+```
+
+> **💡 Note** TYPE i,
+ TYPE zdemo_abap_fli,
+ TYPE string_table.
+
+"Declaring field symbols with generic type
+FIELD-SYMBOLS TYPE data.
+
+"Assigning data objects to field symbols
+"Using field symbols with a static type
+ASSIGN num TO .
+ASSIGN struc TO .
+ASSIGN itab_str TO .
+"Using field symbol with a generic type
+ASSIGN num TO .
+ASSIGN itab_fli TO .
+ASSIGN itab_fli[ 1 ] TO .
+"Assigning components
+ASSIGN struc-carrid TO .
+ASSIGN itab_fli[ 1 ]-connid TO .
+
+"Inline declaration (the field symbol has the type data)
+ASSIGN num TO FIELD-SYMBOL().
+
+"CASTING addition for matching types of data object and field
+"symbol when assigning memory areas
+TYPES c_len_3 TYPE c LENGTH 3.
+DATA(chars) = 'abcdefg'.
+
+FIELD-SYMBOLS TYPE c_len_3.
+
+"Implicit casting
+ASSIGN chars TO CASTING. "abc
+
+FIELD-SYMBOLS TYPE data.
+
+"Explicit casting
+ASSIGN chars TO CASTING TYPE c_len_3. "abc
+
+DATA chars_l4 TYPE c LENGTH 4.
+ASSIGN chars TO CASTING LIKE chars_l4. "abcd
+```
+
+> **💡 Note** IS ASSIGNED.
+> ...
+> ENDIF.
+>
+> DATA(check) = COND #( WHEN IS ASSIGNED THEN `assigned` ELSE `not assigned` ).
+> ```
+>- Using the statement `UNASSIGN`, you can explicitly remove the assignment of the field symbol. A `CLEAR` statement only initializes the value.
+> ``` abap
+> UNASSIGN .
+> ```
+>- See more information on the addition `CASTING` [here](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abapassign_casting.htm).
+
+**Examples using field symbols**
+
+``` abap
+"Assignments
+DATA num TYPE i VALUE 1.
+FIELD-SYMBOLS TYPE i.
+ASSIGN num TO .
+
+ = 2.
+"The data object 'num' has now the value 2.
+
+"Loops
+"Here, field symbols are handy since you can avoid an
+"actual copying of the table line.
+SELECT *
+ FROM zdemo_abap_fli
+ INTO TABLE @DATA(itab).
+
+FIELD-SYMBOLS LIKE LINE OF itab.
+
+LOOP AT itab ASSIGNING .
+ -carrid = ... "The field symbol represents a line of the table.
+ -connid = ... "Components are accessed with the component selector.
+ "Here, it is assumed that a new value is assigned.
+ ...
+ENDLOOP.
+
+"Inline declaration of a field symbol. The field symbol is implcitly typed
+"with the generic type data.
+LOOP AT itab ASSIGNING FIELD-SYMBOL().
+ -carrid = ...
+ -connid = ...
+ ...
+ENDLOOP.
+
+"----------- Generic typing -----------
+"- Generic types are available with which formal parameters of methods or field symbols
+" can be specified.
+"- At runtime, the actual data type is copied from the assigned actual parameter or
+" memory area, i.e. they receive the complete data type only when an actual parameter
+" is passed or a memory area is assigned.
+
+"The following code snippet demonstrates generic types with field symbols.
+FIELD-SYMBOLS:
+ "Any data type
+ TYPE data,
+ TYPE any,
+ "Any data type can be assigned. Restrictions for formal parameters and 'data': no
+ "numeric functions, no description functions, and no arithmetic expressions can be
+ "passed to these parameters. However, you can bypass the restriction by applying the
+ "CONV operator for the actual parameter.
+
+ "Character-like types
+ TYPE c, "Text field with a generic length
+ TYPE clike, "Character-like (c, n, string, d, t and character-like flat structures)
+ TYPE csequence, "Text-like (c, string)
+ TYPE n, "Numeric text with generic length
+ TYPE x, "Byte field with generic length
+ TYPE xsequence, "Byte-like (x, xstring)
+
+ "Numeric types
+ TYPE decfloat, "decfloat16, decfloat34)
+ TYPE numeric, "Numeric ((b, s), i, int8, p, decfloat16, decfloat34, f)
+ TYPE p, "Packed number (generic length and number of decimal places)
+
+ "Internal table types
+ TYPE ANY TABLE, "Internal table with any table type
+ TYPE HASHED TABLE,
+ TYPE INDEX TABLE,
+ TYPE SORTED TABLE,
+ TYPE STANDARD TABLE,
+ TYPE table, "Standard table
+
+ "Other types
+ TYPE simple, "Elementary data type including enumerated types and
+ "structured types with exclusively character-like flat components
+