Question

我正在创建一个具有三个组件的类型结构，其中之一是对数据的类型引用。然后，我创建了这种结构的类型表。

问题是，如何向该表添加数据？

这是我要写的一份新报告，以固定我的日常工作。在其中，我必须始终读取一个包含三个组成部分的表，并且我总是知道其中两个组成部分。

它将始终具有三个组成部分，但是在处理时间中只有一个被发现。

这样，我当前正在使用整个表类型对数据的引用。然后在处理期间，我找出了我需要的这种结构的类型，并根据它创建了我的表。

这里的问题是，即使我知道其中的两个组件，整个过程仍然是动态的，因此我必须在将类型ref导入/导入到数据的方法中使用它，这并不方便。

下面的方法将始终将表类型ref返回到data，这是完全动态的（类型ref to data），但是表格的结构始终是这样的：

组件1->输入pc261。
组件2->输入pay99_international。
compoment 3->好吧，这永远是个蒙昧的嘿嘿

methods get_payroll
   importing it_rgdir        type hrpy_tt_rgdir
   returning value(rt_value) type ref to data.

method get_payroll.
   field-symbols: <lt_payroll> type standard table.
   create data rt_value type standard table of (mv_py_struct_type).
   assign rt_value->* to <lt_payroll>.
   ...
endmethod.

我的目的是让返回值具有另一种类型，即已知类型，通过它我可以更轻松地使用两个已知组件。

我的想法是创建一个只有未知字段作为数据引用的类型，而不是有一个表。

这样，我将能够在方法内部使用它而不必如此“动态”地工作，尽管它只能完美地工作，但仅通过阅读代码就很难理解。

types begin of gty_s_generic_payroll.
   types evp   type pc261.
   types inter type pay99_international.
   types nat   type ref to data.
   types end of gty_s_generic_payroll.

types gty_t_generic_payroll type table of gty_s_generic_payroll.

问题是，如何使用上面声明的类型为gty_t_generic_payroll的Itab？

我必须以某种方式创建组件3，但是我不知道该怎么做...

最后，我有一个通用的字段符号，即类型表，它包含两个已知的组件以及在处理期间发现的第三个组件。

那么我如何将该字段符号的内容传递给表类型gty_t_generic_payroll？

data lt_payroll            type ref to data.
field-symbols <lt_payroll> type any table.
lt_payroll = mo_payroll->get_payroll( lt_rgdir ). "this will return type ref to data
assign lt_payroll->* to <lt_payroll>.

现在<lt_payroll>具有我需要的所有值，但这是一个动态表，即使我知道它存在，我也无法使用<lt_payroll>[1]-inter。

因此，我必须以某种方式将全部内容传递给另一个类型为gty_t_generic_payroll的变量，以便我至少可以使用inter和evp组件，而不必继续进行动态工作，这很难

尽管如此，我确实可以使用完全动态的表，但我只需要将其传递给另一个类型为gty_t_generic_payroll的类型。不知道如何进行。

Answer 1

给出目标结构和表，如下所示：

TYPES:
  BEGIN OF payroll_row_type,
    known_first_component  TYPE something_we_know,
    known_second_component TYPE something_else_we_know,
    discovered_component   TYPE REF TO data,
  END OF payroll_row_type.

TYPES payroll_table_type TYPE STANDARD TABLE OF payroll_row WITH EMPTY KEY.

如果您现在还有另一个表，则该表在运行时的类型为：

TYPES:
  BEGIN OF discovered_row_type,
    known_first_component  TYPE something_we_know,
    known_second_component TYPE something_else_we_know,
    known_third_component  TYPE some_data_type,
  END OF discovered_row_type.

TYPES discovered_table_type TYPE STANDARD TABLE OF discovered_row WITH EMPTY KEY.

您可以使用

DATA source TYPE discovered_table_type.
DATA target TYPE payroll_table_type.
DATA resolved_component TYPE REF TO DATA.

DATA(descriptor) = 
  cl_abap_elemdescr=>describe_by_data( source_row-known_third_component ).

LOOP AT source INTO DATA(source_row).

  DATA(target_row) =
    VALUE payroll_row_type(
      known_first_component  = source_row-known_first_component
      known_second_component = source_row-known_second_component ).

  CREATE DATA target_row-discovered_component TYPE descriptor.
  ASSIGN source_row-known_third_component TO FIELD-SYMBOL(<source_component>).
  ASSIGN target_row-discovered_component TO FIELD-SYMBOL(<target_component>).
  <target_component> = <source_component>.

  INSERT target_row INTO TABLE target.

ENDLOOP.

Answer 2

这个问题和答案可能会让将来的访客感到困惑（实际问题是什么？），所以这是我的两分钱。

问题摘要：

您调用了一个外部代码（1），该代码为您提供了动态生成的内部表，但是您知道所有组件始终相同，只是其中的一个组件有所不同，但位置相同，因此您希望静态地引用其组件，只是变化的组件除外。

（1）因此，您无法适应它。
您的解决方法是静态定义一个等效的内部表，而变化的组件将被定义为数据引用类型（指向任何数据对象的指针），然后通过从动态内部表中复制数据来对其进行初始化
您需要另一个更好的解决方案，因为您的解决方案会占用额外的内存（两个内部表）并降低性能（复制过程）。

答案：

没有更好的解决方案

Answer 3

看起来我能够将值从完全通用的表（数据类型为ref）传递到另一个1/3通用的表（类型为gty_t_generic_payroll）：

  methods get_payroll
    importing it_rgdir        type hrpy_tt_rgdir
    returning value(rt_value) type gty_t_generic_payroll.

  method get_payroll.

    data lt_payroll     type gty_t_generic_payroll.
    data lt_payroll_aux type ref to data.

    field-symbols: <lt_payroll_aux> type standard table.

    create data lt_payroll_aux type standard table of (mv_py_struct_type).

    assign lt_payroll_aux->* to <lt_payroll_aux> .

    call function ' '.

    call function ' '
      exporting
             = mv_relid
             = mv_pernr
             = xsdbool( gs_parm-use_natio <> abap_true )
      tables
             = it_rgdir
             = <lt_payroll_aux> "table with the values I need
      exceptions
             = 0.

    if sy-subrc <> 0.
      return.
    endif.

    loop at <lt_payroll_aux> assigning field-symbol(<ls_payroll_aux>).

      assign component 1 of structure <ls_payroll_aux> to field-symbol(<evp>).
      assign component 2 of structure <ls_payroll_aux> to field-symbol(<inter>).
      assign component 3 of structure <ls_payroll_aux> to field-symbol(<nat>).

      data(ls_value) = value gty_s_generic_payroll(
        evp   = <evp>
        inter = <inter>
      ).

      get reference of <nat> into ls_value-nat.

      append ls_value to rt_value. "returning table, with values I need and 
                                   "now with 2/3 known types

    endloop.

  endmethod.

最终，我完成了所需的工作，但是不幸的是，我确实失去了很多性能，因为我现在必须在结果中循环两次。

填充动态表
执行报告的实际过程（至少得到报告的大声笑）

这是唯一的方法，因为我不能简单地使用insert lines of dynamic_itab to not_so_dynamic_itab，因为第三个组件是引用。

静态引用动态内部表的组件（仅1个组件有所不同）

3 个答案: