- Structures
Structures ...
- are data objects with structured data types (which is a complex data type because it is composed of other data types).
- consist of a sequence of components of any data type, that is, the components of a structure can be, for example, elementary data objects, structures themselves, internal tables or references.
- 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. Structured types serve as line types for these tables. Most internal tables across ABAP programs 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 global DDIC structures in the ABAP Dictionary. Such a DDIC structure defines a globally available structured type (DDIC type).
- Note: There are other structured types available globally, which may be the structured types most commonly used in ABAP programs:
- Database tables 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 such as a CDS view 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 that are only available in Standard ABAP.
- Structures and structured data types can also be defined in the public visibility section of global classes or in global interfaces and then used globally.
- Note: There are other structured types available globally, which may be the structured types most commonly used in ABAP programs:
The typical language elements for creating structures and structured types locally in an ABAP program are BEGIN OF ... END OF .... They are used in combination with the TYPES keyword to create a structured type and the DATA keyword to create a structure.
💡 Note
This cheat sheet focuses on locally defined structures and structured types.
Creating structured types
- The following statement defines a structured type introduced by
TYPES. The type name is preceded byBEGIN OF(which marks the beginning of the structured type definition) andEND OF(the end of the definition). - The components - at least one must be defined - are listed in between.
- Such structured type definitions are usually grouped together in a chained statement, i.e.
TYPESis followed by a colon, and the components are separated by commas.
TYPES: BEGIN OF struc_type,
comp1 TYPE ...,
comp2 TYPE ...,
comp3 TYPE ...,
...,
END OF struc_type.Alternatively, you can also use the following syntax. However, a chained statement provides better readability.
TYPES BEGIN OF struc_type.
TYPES comp1 TYPE ... .
TYPES comp2 TYPE ... .
TYPES comp3 TYPE ... .
... .
TYPES END OF struc_type.- The simplest structures and structured types have elementary 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.
- You can use the
TYPEandLIKEadditions for the types of the components. You can use theLINE OFaddition to refer to a table type or an internal table.
TYPES: BEGIN OF struc_type,
comp1 TYPE i, "elementary type
comp2 TYPE c LENGTH 5, "elementary type
comp3 TYPE structured_type, "structured type
comp4 TYPE itab_type, "internal table type
comp5 TYPE ddic_type, "DDIC type
comp6 TYPE REF TO i, "data reference
comp7 LIKE data_object, "deriving type from a data object
comp8 TYPE LINE OF itab_type, "component has structured type, type derived from internal table type
comp9 LIKE LINE OF itab, "component has structured type, type derived from internal table
comp10, "no TYPE/LIKE specification: component is of type c length 1
...,
END OF struc_type.💡 Note
Outside of classes, you can also refer to DDIC types usingLIKE(... comp11 LIKE ddic_type, ...). If you actually want to refer to an existing data object, but due to typing errors you inadvertently specify a name that exists as DDIC type, errors may be unavoidable.
Creating structures
- To create a structure in an ABAP program, you can use the
DATAkeyword. - It works in the same way as theTYPESstatement above. - Unlike the
TYPESstatement, you can use theVALUEaddition to set default values.
DATA: BEGIN OF struc,
comp1 TYPE ...,
comp2 TYPE ... VALUE ...,
comp3 TYPE i VALUE 99,
comp4 TYPE i VALUE IS INITIAL, "Without the addition VALUE, or if IS INITIAL is specified,
"the content is initial.
comp5 TYPE local_structured_type,
...,
END OF struc.Alternatively, you can use the following syntax. Similar to above, a chained statement provides better readability.
DATA BEGIN OF struc.
DATA comp1 TYPE ... .
DATA comp2 TYPE ... VALUE ... .
... .
DATA END OF struc.💡 Note
- The keywords
CLASS-DATAandCONSTANTScan also be used to create structures. In principle, they represent special cases of the general statement shown above. See the ABAP Keyword Documentation for more information.- Structures can also be created inline using
DATA(...)orFINAL(...), as shown below.
Creating structures using existing structured types:
"Local structured type
TYPES: BEGIN OF struc_type,
comp1 TYPE i,
comp2 TYPE c LENGTH 5,
END OF struc_type.
"Creating a structure using a local structured type
DATA struc_1 TYPE struc_type.
"Creating structures based on globally available types from the DDIC
"Note: When referring to such types, you cannot provide start values for the individual components.
DATA: struc_2 TYPE some_ddic_structure,
struc_3 TYPE some_ddic_table,
struc_4 TYPE some_cds_view.
"Structure based on a structured type that is available in the public
"visibility section of a global class
DATA struc_5 TYPE cl_some_class=>struc_type.
"Creating structures by referring to local data objects and internal table types
DATA: struc_6 LIKE struc_1,
struc_7 LIKE LINE OF some_itab,
struc_8 TYPE LINE OF some_itab_type.Creating structures by inline declaration using DATA(...)
- This is particularly useful for declaring data objects at the operand positions where you actually need them.
- In this way, you can avoid an extra declaration of the structure in different contexts.
- You can also use the
FINALdeclaration operator to create immutable variables.
"Structures created inline instead of an extra declared variable
DATA struc_9 LIKE struc_1.
struc_9 = struc_1
"Type is derived from the right-hand structure; the content of struc is assigned, too.
DATA(struc_10) = struc_1.
FINAL(struc_11) = struc_9.
"Structures declared inline instead of an extra declared variable
"Example: SELECT statement
"Extra declaration
DATA struc_12 TYPE zdemo_abap_fli.
SELECT SINGLE *
FROM zdemo_abap_fli
WHERE carrid = 'LH'
INTO @struc_12.
"Inline declaration
SELECT SINGLE *
FROM zdemo_abap_fli
WHERE carrid = 'LH'
INTO @DATA(struc_13).
"Example: Loop over an internal table
DATA itab TYPE TABLE OF zdemo_abap_fli WITH EMPTY KEY.
... "itab is filled
"Extra declaration
DATA wa_1 LIKE LINE OF itab.
LOOP AT itab INTO wa_1.
...
ENDLOOP.
"Inline declaration
LOOP AT itab INTO DATA(wa_2).
...
ENDLOOP.Depending on the component type, the structure can be a flat structure, a nested structure, or a deep structure.
-
Flat structures contain only elementary types that have a fixed length, that is, there are no internal tables, reference types or strings as components. Nesting does not matter in this context. Even a nested structure is considered flat unless a substructure contains a deep component.
DATA: BEGIN OF struc, comp1 TYPE i, comp2 TYPE c LENGTH 15, comp3 TYPE p LENGTH 8 DECIMALS 2, ..., END OF struc.
-
Nested structures: At least one component of a structure is a substructure, that is, it refers to another structure. The following example has multiple substructures.
DATA: BEGIN OF address_n, BEGIN OF name, title TYPE string VALUE `Mr.`, prename TYPE string VALUE `Duncan`, surname TYPE string VALUE `Pea`, END OF name, BEGIN OF street, name TYPE string VALUE `Vegetable Lane`, num TYPE string VALUE `11`, END OF street, BEGIN OF city, zipcode TYPE string VALUE `349875`, name TYPE string VALUE `Botanica`, END OF city, END OF address_n.
-
Deep structures: Contains at least one internal table, reference type, or string as a component.
DATA: BEGIN OF address_d, name TYPE string VALUE `Mr. Duncan Pea`, street TYPE string VALUE `Vegetable Lane 11`, city TYPE string VALUE `349875 Botanica`, details TYPE TABLE OF some_table WITH EMPTY KEY, END OF address_d.
Although the following structure looks quite simple, it is not a flat structure, but a deep structure, because it contains strings.
DATA: BEGIN OF address, name TYPE string VALUE `Mr. Duncan Pea`, street TYPE string VALUE `Vegetable Lane 11`, city TYPE string VALUE `349875 Botanica`, END OF address.
💡 Note
- The data types of DDIC types are all flat (not nested) structures. Exception: Components of type
stringcan be contained.- Work areas of ABAP SQL statements cannot contain any deep components other than strings among others.
- Especially for assignments and comparisons of deep structures, the compatibility of the source and target structure must be taken into account.
- Structures can be accessed as a whole. You can also address the individual components of structures at the appropriate operand positions.
- To address the components, use the structure component selector
-. - For variables with reference to a structured data object, the object component selector
->can be used:...dref->comp .... The following syntax also works, but is less convenient:... dref->*-comp .... - ADT and the ABAP Editor provide code completion for structure components after the component selectors.
"Addressing components via the structure component selector
... struc-comp1 ...
... struc-comp2 ...
... struc-comp3 ...
"Examples for addressing the whole structure and individual components
IF struc IS INITIAL.
...
ENDIF.
IF struc-comp1 = 1.
...
ENDIF.
DATA(complete_struc) = struc.
DATA(comp_value) = struc-comp2.
"Type and data declarations
TYPES: type_1 TYPE structured_type-comp1,
type_2 LIKE struc-comp1.
DATA: var_1 TYPE structured_type-comp1,
var_2 LIKE struc-comp1.
"Variables with reference to a structured data object
DATA ref_struc_1 TYPE REF TO structured_type.
ref_struc_1 = NEW #( ).
"Excursion: Creating a reference variable using inline declaration
DATA(ref_struc_2) = NEW structured_type( ).
... ref_struc_1->comp1 ...
... ref_struc_1->*-comp1 ... "Using the dereferencing operator
... ref_struc_2->-comp2 ...
... ref_struc_2->*-comp2 ... "Using the dereferencing operatorNested components can be addressed using chaining:
... struc-substructure-comp1 ...
... address_n-name-title ...💡 Note
There are syntax options for dynamically accessing structure components. See the Dynamic Porgramming cheat sheet.
You can copy the content of a structure to another using the assignment operator =.
In the following example, it is assumed that the target and source structures are of compatible types. In general, note that special conversion and comparison rules apply to value assignments involving structures.
some_struc = another_struc.
"When creating a new structure by inline declaration, the type of
"the right-hand structure is derived and the content is assigned.
DATA(struc_inl) = some_struc.To assign values to individual structure components, use the component selector.
TYPES: BEGIN OF addr_struc,
name TYPE string,
street TYPE string,
city TYPE string,
END OF addr_struc.
DATA address TYPE addr_struc.
address-name = `Mr. Duncan Pea`.
address-street = `Vegetable Lane 11`.
address-city = `349875 Botanica`.- The
VALUEoperator can be used to construct the content of complex data objects such as structures or internal tables. - It is particularly useful because assigning values by addressing the structure components individually can be very cumbersome, especially when assigning values to structure components at the operand position.
- If the type of the operand can be inferred implicitly, the
#character can be used used before the parentheses. Otherwise, the type must be specified explicitly. - The
VALUEoperator and inline declarations can be used to create and populate structures in one go. - Note that there are special conversion and comparison rules for structures. See the ABAP Keyword Documentation for more details.
"# used: type of the operand can be implicitly derived
address = VALUE #( name = `Mr. Duncan Pea`
street = `Vegetable Lane 11`
city = `349875 Botanica` ).
"Declaring a structure inline
"Type used explicitly: type of the operand cannot be implicitly derived
DATA(addr) = VALUE addr_struc( name = `Mr. Duncan Pea`
street = `Vegetable Lane 11`
city = `349875 Botanica` ).
"Nesting value operators
TYPES: BEGIN OF struc_nested,
a TYPE i,
BEGIN OF nested_1,
b TYPE i,
c TYPE i,
END OF nested_1,
BEGIN OF nested_2,
d TYPE i,
e TYPE i,
END OF nested_2,
END OF struc_nested.
DATA str_1 TYPE struc_nested.
str_1 = VALUE #( a = 1
nested_1 = VALUE #( b = 2 c = 3 )
nested_2 = VALUE #( d = 4 e = 5 ) ).
"Inline declaration
"Component a is not specified here, i.e. its value remains initial.
DATA(str_2) = VALUE struc_nested( nested_1 = VALUE #( b = 2 c = 3 )
nested_2 = VALUE #( d = 4 e = 5 ) ).
"Apart from the VALUE operator, the NEW operator can be used to create
"a data reference variable (and populate the structure)
DATA(str_ref) = NEW struc_nested( a = 1
nested_1 = VALUE #( b = 2 c = 3 )
nested_2 = VALUE #( d = 4 e = 5 ) ).Using the instance operator NEW, you can create anonymous data objects, such as anonymous structures. You can access the components or the entire data objects by dereferencing. For more information, refer to the Dynamic Programming and Constructor Expressions cheat sheets.
"Creating a data reference variable
DATA addr_ref1 TYPE REF TO addr_struc.
"Populating the anonymous structure
addr_ref1 = NEW #( name = `Mr. Duncan Pea`
street = `Vegetable Lane 11`
city = `349875 Botanica` ).
addr_ref1->name = `Mrs. Jane Doe`.
"Declaring an anonymous structure/a data reference variable inline
DATA(addr_ref2) = NEW addr_struc( name = `Mr. Duncan Pea`
street = `Vegetable Lane 11`
city = `349875 Botanica` ).
addr_ref2->* = VALUE #( BASE addr_ref2->* name = `Mr. John Doe` ).- You can use statements with
MOVE-CORRESPONDINGand theCORRESPONDINGoperator to assign values to structure components, especially when assigning values from a source structure to a target structure which have incompatible types and/or differently named components. - Both are used to assign identically named components of structures to each other.
- The syntax also works for structures of the same type.
- Also note the special conversion and comparison rules for structures in this context.
💡 Note
- The
CL_ABAP_CORRESPONDINGsystem class is available for making assignments. See the ABAP Keyword Documentation for the details.- The
INTOclause of ABAP SQL statements has theCORRESPONDINGaddition. There, the following basic rule applies, which affects the value assignment: Without theCORRESPONDING ...addition, column names do not matter, only the position. With theCORRESPONDING ...addition, the position of the columns does not matter, only the name. See examples in the ABAP SQL cheat sheet.
The following examples demonstrate the value assignment using MOVE-CORRESPONDING statements and the CORRESPONDING operator with various additions.
The focus is on flat structures only.
"Moves identically named components; content in other components
"of the targets structure are kept.
MOVE-CORRESPONDING struc TO diff_struc.
"Initializes target structure; moves identically named components
diff_struc = CORRESPONDING #( struc ).
"Same effect as the first MOVE-CORRESPONDING statement;
"addition BASE keeps existing content
diff_struc = CORRESPONDING #( BASE ( diff_struc ) struc ).
"MAPPING addition: Specifying components of a source structure that are
"assigned to the components of a target structure in mapping
"relationships.
diff_struc = CORRESPONDING #( BASE ( diff_struc ) struc MAPPING comp1 = compa ).
"EXCEPT addition: Excluding components from the assignment.
diff_struc = CORRESPONDING #( BASE ( diff_struc ) struc EXCEPT comp1 ).Value assignments in deep structures
- In the context of deep structures, there are additional syntax variants available for
MOVE-CORRESPONDINGstatements and theCORRESPONDINGoperator. - The following examples focus on internal tables as structure components. Check out the syntax in action in the executable example.
"Nonidentical elementary component types are kept in target
"structure which is true for the below MOVE-CORRESPONDING statements;
"existing internal table content is replaced by content of
"the source table irrespective of identically named components
MOVE-CORRESPONDING deep_struc TO diff_deep_struc.
"Existing internal table content is replaced but the value
"assignment happens for identically named components only.
MOVE-CORRESPONDING deep_struc TO diff_deep_struc EXPANDING NESTED TABLES.
"Existing internal table content is kept; table content of the source
"structure are added but the value assignment happens like the first
"MOVE-CORRESPONDING statement without further syntax additions.
MOVE-CORRESPONDING deep_struc TO diff_deep_struc KEEPING TARGET LINES.
"Existing internal table content is kept; table content of the source
"structure are added; the value assignment happens like the statement
"MOVE-CORRESPONDING ... EXPANDING NESTED TABLES.
MOVE-CORRESPONDING deep_struc TO diff_deep_struc EXPANDING NESTED TABLES KEEPING TARGET LINES.
"Target structure is initialized; the value assignment for an internal
"table happens irrespective of identically named components.
diff_deep_struc = CORRESPONDING #( deep_struc ).
"Target structure is initialized; the value assignment for an internal
"table happens for identically named components only.
diff_deep_struc = CORRESPONDING #( DEEP deep_struc ).
"Nonidentical elementary component types are kept in target structure;
"internal table content is replaced; there, the value assignment
"happens like using the CORRESPONDING operator without addition.
diff_deep_struc = CORRESPONDING #( BASE ( diff_struc ) deep_struc ).
"Nonidentical elementary component types are kept in target structure;
"internal table content is replaced; there, the value assignment
"happens like using the CORRESPONDING operator with the addition DEEP.
diff_deep_struc = CORRESPONDING #( DEEP BASE ( diff_struc ) deep_struc ).
"Nonidentical elementary component types are kept in target structure;
"internal table content is kept, too, and table content of the
"source structure are added; there, the value assignment
"happens like using the CORRESPONDING operator without addition.
diff_deep_struc = CORRESPONDING #( APPENDING BASE ( diff_struc ) deep_struc ).
"Nonidentical elementary component types are kept in target structure;
"internal table content is kept, too, and table content of the
"source structure are added; there, the value assignment
"happens like using the CORRESPONDING operator with the addition DEEP.
diff_deep_struc = CORRESPONDING #( DEEP APPENDING BASE ( diff_struc ) deep_struc ).You can reset individual components to their initial values and clear the
entire structure using the CLEAR keyword.
CLEAR struc-component.
CLEAR struc.
"Note: An assignment using the VALUE operator without entries in the parentheses clears the structure.
struc = VALUE #( ). Structures are primarily used to process data from tables. In this context, structures often take on the role of a work area. The following code snippets cover only a selection. For more examples, see the cheat sheets about internal tables and ABAP SQL.
Reading a row from a database table into a structure that has a compatible type. Note that, since database tables are flat, the
target structure must also be flat. In the example below, the SINGLE
addition reads only a single row into the structure. It returns the first entry that matches the WHERE condition.
"Creating a structure with a compatible type
DATA ls_fli1 TYPE zdemo_abap_fli.
SELECT SINGLE FROM zdemo_abap_fli
FIELDS *
WHERE carrid = 'LH'
INTO @ls_fli1.
"Target structure declared inline
SELECT SINGLE FROM zdemo_abap_fli
FIELDS *
WHERE carrid = 'LH'
INTO @DATA(ls_fli2).Reading a row from a database table into a structure that has an incompatible type. Components in the structure with identical names are filled.
SELECT SINGLE FROM zdemo_abap_fli
FIELDS *
WHERE carrid = 'AA'
INTO CORRESPONDING FIELDS OF @ls_fli_diff.Reading a line from an internal table into a structure ...
... using a SELECT statement. Note the specified alias name and that ABAP variables like internal tables must be escaped with @. The addition INTO CORRESPONDING FIELDS OF also applies here.
SELECT SINGLE FROM @itab AS itab_alias
FIELDS *
WHERE ...
INTO @DATA(ls_struc).
"INTO CORRESPONDING FIELDS OF @some_existing_struc.... using a READ TABLE statement. The code snippet below shows the reading of a line into a work area, a field symbol, and a data reference variable, all of which
represent structured data objects that are declared inline. In the following example, a line is read based on the line number by
specifying INDEX. For more details, see the section Determining the target area in the cheat sheet Internal Tables.
READ TABLE itab INTO DATA(wa) INDEX 1.
READ TABLE itab ASSIGNING FIELD-SYMBOL(<fs>) INDEX 2.
READ TABLE itab REFERENCE INTO DATA(dref) INDEX 3.... using a table expression. The code snippet shows how to read a line into a structure declared inline. The index is given in square brackets.
DATA(ls_table_exp) = itab[ 3 ].Sequentially reading ...
... a row from a database table into a structure. A SELECT loop can be specified with the syntax SELECT ... ENDSELECT..
In the following example, the row found and returned in a structure declared inline can be processed further.
SELECT FROM zdemo_abap_fli
FIELDS *
WHERE carrid = 'AZ'
INTO @DATA(ls_sel_loop).
IF sy-subrc = 0.
...
ENDIF.
ENDSELECT.... a line from an internal table into a structure using a LOOP AT statement. There are many ways to specify the condition on which the loop is based. The following example covers the option of reading all lines sequentially into a field symbol declared inline. When using a field symbol, you can, for example, directly modify components.
LOOP AT itab ASSIGNING FIELD-SYMBOL(<fs>).
<fs>-comp1 = ...
...
ENDLOOP.Inserting a single row into a database table from a structure using ABAP SQL statements with
INSERT. The following statements can be considered as alternatives. The third statement shows that instead of inserting a row from an existing structure, you can create and fill a structure directly.
Note that you should avoid inserting a row with a particular key into the database table if a row with the same key already exists.
INSERT INTO dbtab VALUES @struc.
INSERT dbtab FROM @struc.
INSERT dbtab FROM @( VALUE #( comp1 = ... comp2 = ... ) ).Updating a single row in a database table from a structure using ABAP SQL statements with UPDATE. Note that this syntax changes the entire row and all of its components.
UPDATE dbtab FROM @struc.
UPDATE dbtab FROM @( VALUE #( comp1 = ... comp2 = ... ) ).If you want to update a database table row from a structure by specifying components to be changed without overwriting other components, you can use the following method. First, read the desired row from the database table into a structure. Then, use the VALUE operator with the BASE addition and specify the components to be changed.
SELECT SINGLE *
FROM dbtab
WHERE ...
INTO @DATA(wa).
UPDATE dbtab FROM @( VALUE #( BASE wa comp2 = ... comp4 = ... ) ).Updating or creating a single row in a database table from a structure using ABAP SQL statements with
MODIFY. If a row with the same key as specified in the structure already exists in the database table, the row is updated. If no row with the keys specified in the structure exists, a new row is created in the database table.
MODIFY dbtab FROM @struc.
MODIFY dbtab FROM @( VALUE #( comp1 = ... comp2 = ... ) ).Adding lines to and updating single lines in an internal table from a structure using INSERT,
APPEND, and MODIFY statements.
- Note that all statements, including
INSERTandMODIFY, are ABAP statements in this context, not ABAP SQL statements. - Both
INSERTandAPPENDadd one or more lines to an internal table. WhileAPPENDadds at the bottom of the internal table,INSERTcan be used to add lines at a specific position in the table. If you do not specify the position, the lines are also added at the bottom of the table. However, unlikeAPPEND,INSERTdoes not setsy-tabix. MODIFYchanges the content of an internal table entry.- Statements using the
VALUEoperator to directly create and populate the structures are also possible. For more information and code snippets, see the Internal Tables cheat sheet.
INSERT struc INTO TABLE itab.
APPEND struc TO itab.
MODIFY TABLE itab FROM struc.INCLUDE TYPEandINCLUDE STRUCTUREstatements are used in the context of local structures.- Structured data objects and types created with
... BEGIN OF... END OF ...can use this syntax to include components of another structure, whether it is a locally defined or global structure, without creating substructures. INCLUDE TYPEcan be used to include a structured type.- You can use
INCLUDE STRUCTUREto include a structure.
💡 Note
- They are not additions of
... BEGIN OF ... END OF ...but individual ABAP statements.- If you use a chained statement with a colon to declare the structure, the inclusion of other structures with these statements interrupts the chained statement, that is, the components of the included structures are included as direct components of the superstructure.
- By using the optional
ASaddition and specifying a name, the included components can be addressed by this common name as if they were actually components of a substructure.- The optional
RENAMING WITH SUFFIXaddition, followed by a name, gives the included components a suffix name to avoid naming conflicts with other components.
The following example shows how structured types and data objects are included in another structure. First, three structured types and a structured data object based on one of these types are created. Then, the types and the structure are included in the structured type address_type. The executable example demonstrates a structure that includes other structures in this way.
TYPES: BEGIN OF name_type,
title TYPE string,
prename TYPE string,
surname TYPE string,
END OF name_type,
BEGIN OF street_type,
name TYPE string,
num TYPE string,
END OF street_type,
BEGIN OF city_type,
zipcode TYPE string,
name TYPE string,
END OF city_type.
DATA city_struc TYPE city_type.
TYPES BEGIN OF address_type.
INCLUDE TYPE name_type AS name.
INCLUDE TYPE street_type AS street RENAMING WITH SUFFIX _street.
INCLUDE STRUCTURE city_struc AS city RENAMING WITH SUFFIX _city.
TYPES END OF address_type.💡 Note
- The executable example covers the following topics, among others:
- Creating structures and structured types
- Variants of structures
- Accessing, populating, and clearing structures
- Structures in the context of tables
- Including structures
- The steps to import and run the code are outlined here.
- Disclaimer