diff --git a/02_Structures.md b/02_Structures.md index ff0f3d6..4e2580c 100644 --- a/02_Structures.md +++ b/02_Structures.md @@ -20,7 +20,7 @@ - consist of a sequence of [components](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abencomponent_glosry.htm "Glossary Entry") of any data type, that is, the components of a structure can be, for example, [elementary data objects](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenelementary_data_object_glosry.htm), structures themselves, [internal tables](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abeninternal_table_glosry.htm "Glossary Entry") or [references](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenreference_glosry.htm). - are used to combine different data objects that belong together. A typical example is an address. It has several components, such as name, street, city, and so on, that belong together. - play an important role in the context of internal tables and [database tables](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abendatabase_table_glosry.htm "Glossary Entry"). Structured types serve as [line types](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenrow_type_glosry.htm) for these tables. Most internal tables across [ABAP programs](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenabap_program_glosry.htm) may have structured line types. For database tables, there is no alternative to structured line types. -- can be created locally in an ABAP program. You can also create them as a global [DDIC structures](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenddic_structure_glosry.htm) in the [ABAP Dictionary](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenabap_dictionary_glosry.htm). Such a DDIC structure defines a globally available structured type ([DDIC type](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenddic_type_glosry.htm)). +- can be created locally in an ABAP program. You can also create them as global [DDIC structures](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenddic_structure_glosry.htm) in the [ABAP Dictionary](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenabap_dictionary_glosry.htm). Such a DDIC structure defines a globally available structured type ([DDIC type](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenddic_type_glosry.htm)). - Note: There are other structured types available globally, which may be the structured types most commonly used in ABAP programs: - [Database tables](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenddic_db_table_glosry.htm) defined in the ABAP Dictionary can be used as data types just like DDIC structures in an ABAP program. This means that when you create a structure in your ABAP program, for example, you can simply use the name of a database table to address the line type of the table. The structure you created will then have the same structured type as the database table. Typically, you use the database tables to create structures of such a type, or internal tables of such a structured line type, to process data read from the database table in structures or internal tables. - A [CDS entity](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abencds_entity_glosry.htm) such as a [CDS view](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abencds_view_glosry.htm) also represents a structured data type and can be used as such in ABAP programs (but not in the ABAP Dictionary). The same applies to [DDIC views](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenddic_view_glosry.htm) that are only available in [Standard ABAP](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenstandard_abap_glosry.htm). @@ -65,7 +65,7 @@ components. - As mentioned above, the components can be of any type, i.e. they can be of structured types themselves, internal table types, or [reference types](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abenreference_type_glosry.htm). - You can use the [`TYPE`](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abapdata_simple.htm) and [`LIKE`](https://help.sap.com/doc/abapdocu_cp_index_htm/CLOUD/en-US/index.htm?file=abapdata_referring.htm) additions for the types of the components. -You can use the [`LINE OF`] addition to refer to a table type or an internal table. +You can use the `LINE OF` addition to refer to a table type or an internal table. ``` abap @@ -510,6 +510,10 @@ entire structure using the [`CLEAR`](https://help.sap.com/doc/abapdocu_cp_index_ CLEAR structure-component. CLEAR structure. + +"Note: Watch out when using the VALUE operator. An assignment as follows also +"clears the structure. +structure = VALUE #( ). ``` ## Processing Structures diff --git a/06_Dynamic_Programming.md b/06_Dynamic_Programming.md index f58d350..83f653a 100644 --- a/06_Dynamic_Programming.md +++ b/06_Dynamic_Programming.md @@ -607,10 +607,11 @@ For the rich variety of options (where dynamic specification is possible for ABA - Dynamic invoke: 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 that dynamic method calls require a CALL METHOD statement. + "Notes: + "- Dynamic method calls require a CALL METHOD statement. + "- The first 3 examples assume that there are no mandatory parameters defined for the method. + "- The example covers only static methods. Dynamic method calls for instance methods are also possible. - "Note: The following 3 examples assume that there are no - "mandatory parameters defined for the method. "Method dynamically specified CALL METHOD class=>(meth). diff --git a/07_String_Processing.md b/07_String_Processing.md index 92c59b3..29b14f2 100644 --- a/07_String_Processing.md +++ b/07_String_Processing.md @@ -1475,7 +1475,7 @@ Repetitions and Alternatives | `x{m,}` | Exactly `m` or more repetitions | `ab{2,}` | abc abbc abbbc a ac | abc **abb**c **abbb**c a ac | **ab**c ... | | `x?` | Optional `x`, i.e. zero or one time | `ab?` | abc abbc abbbc a ac | **ab**c **ab**bc **ab**bbc **a** **a**c | ... **ac** | | `x\|y` | Matching alternatives, i. e. `x` or `y` | 1. `b\|2`
2. `b(a\|u)t` | 1. abc 123
2. bit bat but bet | 1. b, 2
2. bat, but | 1. a, c, 1, 3
2. bit, bet | -| `x*?` | `x*` captures greedily, i.e. as much as possible, while `x*?` captures non-greedily, i.e. as few as possible | 1. `bc*?`
2. `a(.*?)#` | 1. abcd abccccd ab
2. abc#defgh#i | 1. a**b**cd a**b**ccccd a**b**
2. **abc#**defgh#i | 1. a**bc**d a**bcccc**d a**b** (result for `bc*`)
2. **abc#defgh#**i (result for `a(.*)#`) | +| `x*?` | `x*` captures greedily, i.e. as much as possible, while `x*?` captures non-greedily, i.e. as few as possible | 1. `bc*?`
2. `a.*?#` | 1. abcd abccccd ab
2. abc#defgh#i | 1. a**b**cd a**b**ccccd a**b**
2. **abc#**defgh#i | 1. a**bc**d a**bcccc**d a**b** (result for `bc*`)
2. **abc#defgh#**i (result for `a.*#`) | | `x+?` | Same as above: `x+` (greedy), `x+?` (non-greedy) | 1. `bc+?`
2. `<.+?>` | 1. abcd abccccd ab
2. <span>Hallo</span> html. | 1. a**bc**d a**bc**cccd ab
2. **<span>**Hallo**</span>** html. | 1. a**bc**d a**bcccc**d ab (result for `bc+`)
2. **<span>Hallo</span>** html. (result for `<.+>`) | Character Sets, Ranges, Subgroups and Lookarounds diff --git a/13_Program_Flow_Logic.md b/13_Program_Flow_Logic.md index 2ae207c..f0b0a06 100644 --- a/13_Program_Flow_Logic.md +++ b/13_Program_Flow_Logic.md @@ -520,7 +520,7 @@ Regarding the exiting of procedures, note the hint mentioned above. The use of ` ``` - If the addition `INTO` is specified in the `CATCH` statement, a reference to the exception object is stored. -- This is for, example relevant, to determine the exact exception. In the code snippet above, the exception class `CX_SY_ZERODIVIDE` is mentioned. Consider a calculator. It should not only be able to deal with error situations like zero division but also, for example, overflows in arithmetic operations. The predefined exception class `CX_SY_ARITHMETIC_OVERFLOW` is available. It is also derived from `CX_SY_ARITHMETIC_ERROR`. If you then specify the exception class `CX_SY_ARITHMETIC_ERROR` which is higher up in the inheritance hierarchy and can handle both error situations (`CX_SY_ARITHMETIC_OVERFLOW` and `CX_SY_ZERODIVIDE`), the concrete exception that was raised is unclear. Using the `INTO` clause and the stored exception object, it is possible to carry out certain tasks, for example, retrieving and displaying the exception text. +- This is relevant to determine the exact exception, for example. In the code snippet above, the exception class `CX_SY_ZERODIVIDE` is mentioned. Consider a calculator. It should not only be able to deal with error situations like zero division but also, for example, overflows in arithmetic operations. The predefined exception class `CX_SY_ARITHMETIC_OVERFLOW` is available. It is also derived from `CX_SY_ARITHMETIC_ERROR`. If you then specify the exception class `CX_SY_ARITHMETIC_ERROR` which is higher up in the inheritance hierarchy and can handle both error situations (`CX_SY_ARITHMETIC_OVERFLOW` and `CX_SY_ZERODIVIDE`), the concrete exception that was raised is unclear. Using the `INTO` clause and the stored exception object, it is possible to carry out certain tasks, for example, retrieving and displaying the exception text. ```abap DATA: exception TYPE REF TO cx_root. "Note the root class diff --git a/src/zcl_demo_abap_sql_group_by.clas.abap b/src/zcl_demo_abap_sql_group_by.clas.abap index 67b5680..295ef64 100644 --- a/src/zcl_demo_abap_sql_group_by.clas.abap +++ b/src/zcl_demo_abap_sql_group_by.clas.abap @@ -34,7 +34,7 @@ * *********************************************************************** "!

ABAP cheat sheet: ABAP SQL - Grouping Internal Tables

-"! Example to demonstrate working with structures.
Choose F9 in ADT to run the class. +"! Example to demonstrate grouping internal tables.
Choose F9 in ADT to run the class. CLASS zcl_demo_abap_sql_group_by DEFINITION PUBLIC FINAL