内部嵌套分组 table
Nested grouping in internal table
我想获取所有行，这些行对字段 anln1 和 anln2 具有不同的条目。
为此，我需要一个合适的 OpenSQL 语句。
例如有以下 table:
anln1 | anln2 | datum | psp | przt
------------------------------------------
10007 | 0 | 20140101 | 12345678 | 1
10007 | 0 | 20140101 | 11111111 | 99
10007 | 1 | 20140101 | 12345678 | 1
10007 | 1 | 20140101 | 11111111 | 99
anln1 + anln2 的所有条目应重复 datum、psp 和 przt 如果有另一个子编号，例如anln2=1.
不幸的是，我的 table 违反了此规范（SQLFiddle：http://sqlfiddle.com/#!2/f5d1f）：
anln1 | anln2 | datum | psp | przt
------------------------------------------
10000 | 0 | 20140101 | 12345678 | 60
10000 | 0 | 20140101 | 11111111 | 40
10000 | 1 | 20140101 | 11111111 | 100
10000 | 2 | 20140101 | 11111111 | 100
10000 | 3 | 20140101 | 22222222 | 100
10001 | 0 | 20140101 | 12312312 | 100
10001 | 1 | 20140101 | 12312312 | 100
10001 | 2 | 20140101 | 12312312 | 100
10002 | 0 | 20140101 | 11111111 | 100
10003 | 0 | 20140101 | 11111111 | 100
10004 | 0 | 20140101 | 11111111 | 100
10005 | 0 | 20140101 | 22222222 | 100
10005 | 1 | 20140101 | 33333333 | 100
10006 | 0 | 20140101 | 11111111 | 20
10006 | 0 | 20140101 | 22222222 | 80
10006 | 1 | 20140101 | 11111111 | 30
10006 | 1 | 20140101 | 11111111 | 70
10007 | 0 | 20140101 | 12345678 | 1
10007 | 0 | 20140101 | 11111111 | 99
10007 | 1 | 20140101 | 12345678 | 1
10007 | 1 | 20140101 | 11111111 | 99
作为我的查询的结果，我需要识别所有违反我的规范的行。正确的行应该被忽略。
正确的行是 anln1 为 10001、10002、10003、10004、10007 的行。
所以，结果应该是这样的：
anln1 | anln2 | datum | psp | przt
------------------------------------------
10000 | 0 | 20140101 | 12345678 | 60
10000 | 0 | 20140101 | 11111111 | 40
10000 | 1 | 20140101 | 11111111 | 100
10000 | 2 | 20140101 | 11111111 | 100
10000 | 3 | 20140101 | 22222222 | 100
10005 | 0 | 20140101 | 22222222 | 100
10005 | 1 | 20140101 | 33333333 | 100
10006 | 0 | 20140101 | 11111111 | 20
10006 | 0 | 20140101 | 22222222 | 80
10006 | 1 | 20140101 | 11111111 | 30
10006 | 1 | 20140101 | 11111111 | 70
我尝试使用 GROUP BY、HAVING 和 COUNT(...) > 1，但没有得到有用的结果。这甚至可以用 (Open)SQL 解决吗？
真诚期待您的帮助！请使用我的 SQLFiddle (http://sqlfiddle.com/#!2/f5d1f) 来尝试一下。
选择 anln2 <> 0 的条目后，我使用内部 table。
首先我将选择的结果排序如下：
SORT gt_internaltable BY anln1 anln2 datum psp przt.
然后我遍历了内部 table 并删除了所有双重条目...
LOOP AT gt_internaltable INTO gs_tablerow.
AT NEW anln1.
CLEAR g_count.
ENDAT.
g_count = g_count + 1.
AT END OF anln1.
IF g_count > 1. " delete double entries
DELETE gt_internaltable WHERE anln1 = gs_tablerow-anln1
AND anln2 = gs_tablerow-anln2
AND datum = gs_tablerow-datum
AND psp = gs_tablerow-psp
AND przt = gs_tablerow-przt.
ENDIF.
ENDAT.
ENDLOOP.
最后，在gt_internaltable.
中留下了违反我规范的条目列表
我不认为它可以通过 OpenSQL 实现。
以下是使用分组的现代 ABAP 语法实现此目的的方法：
TYPES: BEGIN OF ty_anla,
anln1 TYPE anln1,
anln2 TYPE anln2,
datum TYPE erdat,
psp TYPE c LENGTH 8,
przt TYPE i,
END OF ty_anla,
tty_anla TYPE STANDARD TABLE OF ty_anla WITH NON-UNIQUE KEY primary_key COMPONENTS anln1.
DATA: lt_input TYPE tty_anla,
lt_output TYPE tty_anla.
lt_output = lt_input =
VALUE #( ( anln1 = 10000 anln2 = 0 datum = '20140101' psp = 12345678 przt = 60 )
( anln1 = 10000 anln2 = 0 datum = '20140101' psp = 11111111 przt = 40 )
( anln1 = 10000 anln2 = 1 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10000 anln2 = 2 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10000 anln2 = 3 datum = '20140101' psp = 22222222 przt = 100 )
( anln1 = 10001 anln2 = 0 datum = '20140101' psp = 12312312 przt = 100 )
( anln1 = 10001 anln2 = 1 datum = '20140101' psp = 12312312 przt = 100 )
( anln1 = 10001 anln2 = 2 datum = '20140101' psp = 12312312 przt = 100 )
( anln1 = 10002 anln2 = 0 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10003 anln2 = 0 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10004 anln2 = 0 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10005 anln2 = 0 datum = '20140101' psp = 22222222 przt = 100 )
( anln1 = 10005 anln2 = 1 datum = '20140101' psp = 33333333 przt = 100 )
( anln1 = 10006 anln2 = 0 datum = '20140101' psp = 11111111 przt = 20 )
( anln1 = 10006 anln2 = 0 datum = '20140101' psp = 22222222 przt = 80 )
( anln1 = 10006 anln2 = 1 datum = '20140101' psp = 11111111 przt = 30 )
( anln1 = 10006 anln2 = 1 datum = '20140101' psp = 11111111 przt = 70 )
( anln1 = 10007 anln2 = 0 datum = '20140101' psp = 12345678 przt = 1 )
( anln1 = 10007 anln2 = 0 datum = '20140101' psp = 11111111 przt = 99 )
( anln1 = 10007 anln2 = 1 datum = '20140101' psp = 12345678 przt = 1 )
( anln1 = 10007 anln2 = 1 datum = '20140101' psp = 11111111 przt = 99 )
).
LOOP AT lt_input ASSIGNING FIELD-SYMBOL(<fs_inp>) USING KEY primary_key GROUP BY ( anln1 = <fs_inp>-anln1 index = GROUP INDEX size = GROUP SIZE ) REFERENCE INTO DATA(common_anln1).
LOOP AT GROUP common_anln1 ASSIGNING FIELD-SYMBOL(<fs_member>) GROUP BY ( datum = <fs_member>-datum psp = <fs_member>-psp przt = <fs_member>-przt index = GROUP INDEX size = GROUP SIZE ) REFERENCE INTO DATA(common_key).
DATA(common_key_size) = common_key->*-size.
EXIT.
ENDLOOP.
CHECK common_anln1->*-size = common_key_size.
DELETE lt_output WHERE anln1 = common_anln1->*-anln1.
ENDLOOP.
在这里，我们首先按 ANLN1 键分组，然后在这些组中检查 datum+psr+psp 键 ，以便组大小相等 。这意味着所有 ANLN1 都拥有相同的密钥。
在结果中 lt_output 你会看到想要的结果：
10000 0 2014-01-01 12345678 60
10000 0 2014-01-01 11111111 40
10000 1 2014-01-01 11111111 100
10000 2 2014-01-01 11111111 100
10000 3 2014-01-01 22222222 100
10005 0 2014-01-01 22222222 100
10005 1 2014-01-01 33333333 100
10006 0 2014-01-01 11111111 20
10006 0 2014-01-01 22222222 80
10006 1 2014-01-01 11111111 30
10006 1 2014-01-01 11111111 70
10007 0 2014-01-01 12345678 1
10007 0 2014-01-01 11111111 99
10007 1 2014-01-01 12345678 1
10007 1 2014-01-01 11111111 99
10007 在这里是因为根据您的定义，它不是正确的行 anln1 + anln2 的所有条目都应重复其数据、psp 和 przt 的组合。不同的 10007 anln2 值有不同的 psp 值。
我想获取所有行，这些行对字段 anln1 和 anln2 具有不同的条目。 为此，我需要一个合适的 OpenSQL 语句。
例如有以下 table:
anln1 | anln2 | datum | psp | przt
------------------------------------------
10007 | 0 | 20140101 | 12345678 | 1
10007 | 0 | 20140101 | 11111111 | 99
10007 | 1 | 20140101 | 12345678 | 1
10007 | 1 | 20140101 | 11111111 | 99
anln1 + anln2 的所有条目应重复 datum、psp 和 przt 如果有另一个子编号，例如anln2=1.
不幸的是，我的 table 违反了此规范（SQLFiddle：http://sqlfiddle.com/#!2/f5d1f）：
anln1 | anln2 | datum | psp | przt
------------------------------------------
10000 | 0 | 20140101 | 12345678 | 60
10000 | 0 | 20140101 | 11111111 | 40
10000 | 1 | 20140101 | 11111111 | 100
10000 | 2 | 20140101 | 11111111 | 100
10000 | 3 | 20140101 | 22222222 | 100
10001 | 0 | 20140101 | 12312312 | 100
10001 | 1 | 20140101 | 12312312 | 100
10001 | 2 | 20140101 | 12312312 | 100
10002 | 0 | 20140101 | 11111111 | 100
10003 | 0 | 20140101 | 11111111 | 100
10004 | 0 | 20140101 | 11111111 | 100
10005 | 0 | 20140101 | 22222222 | 100
10005 | 1 | 20140101 | 33333333 | 100
10006 | 0 | 20140101 | 11111111 | 20
10006 | 0 | 20140101 | 22222222 | 80
10006 | 1 | 20140101 | 11111111 | 30
10006 | 1 | 20140101 | 11111111 | 70
10007 | 0 | 20140101 | 12345678 | 1
10007 | 0 | 20140101 | 11111111 | 99
10007 | 1 | 20140101 | 12345678 | 1
10007 | 1 | 20140101 | 11111111 | 99
作为我的查询的结果，我需要识别所有违反我的规范的行。正确的行应该被忽略。 正确的行是 anln1 为 10001、10002、10003、10004、10007 的行。
所以，结果应该是这样的：
anln1 | anln2 | datum | psp | przt
------------------------------------------
10000 | 0 | 20140101 | 12345678 | 60
10000 | 0 | 20140101 | 11111111 | 40
10000 | 1 | 20140101 | 11111111 | 100
10000 | 2 | 20140101 | 11111111 | 100
10000 | 3 | 20140101 | 22222222 | 100
10005 | 0 | 20140101 | 22222222 | 100
10005 | 1 | 20140101 | 33333333 | 100
10006 | 0 | 20140101 | 11111111 | 20
10006 | 0 | 20140101 | 22222222 | 80
10006 | 1 | 20140101 | 11111111 | 30
10006 | 1 | 20140101 | 11111111 | 70
我尝试使用 GROUP BY、HAVING 和 COUNT(...) > 1，但没有得到有用的结果。这甚至可以用 (Open)SQL 解决吗？
真诚期待您的帮助！请使用我的 SQLFiddle (http://sqlfiddle.com/#!2/f5d1f) 来尝试一下。
选择 anln2 <> 0 的条目后，我使用内部 table。
首先我将选择的结果排序如下：
SORT gt_internaltable BY anln1 anln2 datum psp przt.
然后我遍历了内部 table 并删除了所有双重条目...
LOOP AT gt_internaltable INTO gs_tablerow.
AT NEW anln1.
CLEAR g_count.
ENDAT.
g_count = g_count + 1.
AT END OF anln1.
IF g_count > 1. " delete double entries
DELETE gt_internaltable WHERE anln1 = gs_tablerow-anln1
AND anln2 = gs_tablerow-anln2
AND datum = gs_tablerow-datum
AND psp = gs_tablerow-psp
AND przt = gs_tablerow-przt.
ENDIF.
ENDAT.
ENDLOOP.
最后，在gt_internaltable.
中留下了违反我规范的条目列表我不认为它可以通过 OpenSQL 实现。
以下是使用分组的现代 ABAP 语法实现此目的的方法：
TYPES: BEGIN OF ty_anla,
anln1 TYPE anln1,
anln2 TYPE anln2,
datum TYPE erdat,
psp TYPE c LENGTH 8,
przt TYPE i,
END OF ty_anla,
tty_anla TYPE STANDARD TABLE OF ty_anla WITH NON-UNIQUE KEY primary_key COMPONENTS anln1.
DATA: lt_input TYPE tty_anla,
lt_output TYPE tty_anla.
lt_output = lt_input =
VALUE #( ( anln1 = 10000 anln2 = 0 datum = '20140101' psp = 12345678 przt = 60 )
( anln1 = 10000 anln2 = 0 datum = '20140101' psp = 11111111 przt = 40 )
( anln1 = 10000 anln2 = 1 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10000 anln2 = 2 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10000 anln2 = 3 datum = '20140101' psp = 22222222 przt = 100 )
( anln1 = 10001 anln2 = 0 datum = '20140101' psp = 12312312 przt = 100 )
( anln1 = 10001 anln2 = 1 datum = '20140101' psp = 12312312 przt = 100 )
( anln1 = 10001 anln2 = 2 datum = '20140101' psp = 12312312 przt = 100 )
( anln1 = 10002 anln2 = 0 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10003 anln2 = 0 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10004 anln2 = 0 datum = '20140101' psp = 11111111 przt = 100 )
( anln1 = 10005 anln2 = 0 datum = '20140101' psp = 22222222 przt = 100 )
( anln1 = 10005 anln2 = 1 datum = '20140101' psp = 33333333 przt = 100 )
( anln1 = 10006 anln2 = 0 datum = '20140101' psp = 11111111 przt = 20 )
( anln1 = 10006 anln2 = 0 datum = '20140101' psp = 22222222 przt = 80 )
( anln1 = 10006 anln2 = 1 datum = '20140101' psp = 11111111 przt = 30 )
( anln1 = 10006 anln2 = 1 datum = '20140101' psp = 11111111 przt = 70 )
( anln1 = 10007 anln2 = 0 datum = '20140101' psp = 12345678 przt = 1 )
( anln1 = 10007 anln2 = 0 datum = '20140101' psp = 11111111 przt = 99 )
( anln1 = 10007 anln2 = 1 datum = '20140101' psp = 12345678 przt = 1 )
( anln1 = 10007 anln2 = 1 datum = '20140101' psp = 11111111 przt = 99 )
).
LOOP AT lt_input ASSIGNING FIELD-SYMBOL(<fs_inp>) USING KEY primary_key GROUP BY ( anln1 = <fs_inp>-anln1 index = GROUP INDEX size = GROUP SIZE ) REFERENCE INTO DATA(common_anln1).
LOOP AT GROUP common_anln1 ASSIGNING FIELD-SYMBOL(<fs_member>) GROUP BY ( datum = <fs_member>-datum psp = <fs_member>-psp przt = <fs_member>-przt index = GROUP INDEX size = GROUP SIZE ) REFERENCE INTO DATA(common_key).
DATA(common_key_size) = common_key->*-size.
EXIT.
ENDLOOP.
CHECK common_anln1->*-size = common_key_size.
DELETE lt_output WHERE anln1 = common_anln1->*-anln1.
ENDLOOP.
在这里，我们首先按 ANLN1 键分组，然后在这些组中检查 datum+psr+psp 键 ，以便组大小相等 。这意味着所有 ANLN1 都拥有相同的密钥。
在结果中 lt_output 你会看到想要的结果：
10000 0 2014-01-01 12345678 60
10000 0 2014-01-01 11111111 40
10000 1 2014-01-01 11111111 100
10000 2 2014-01-01 11111111 100
10000 3 2014-01-01 22222222 100
10005 0 2014-01-01 22222222 100
10005 1 2014-01-01 33333333 100
10006 0 2014-01-01 11111111 20
10006 0 2014-01-01 22222222 80
10006 1 2014-01-01 11111111 30
10006 1 2014-01-01 11111111 70
10007 0 2014-01-01 12345678 1
10007 0 2014-01-01 11111111 99
10007 1 2014-01-01 12345678 1
10007 1 2014-01-01 11111111 99
10007 在这里是因为根据您的定义，它不是正确的行 anln1 + anln2 的所有条目都应重复其数据、psp 和 przt 的组合。不同的 10007 anln2 值有不同的 psp 值。