内部表中的嵌套分组

Question

我想获取所有行，这些行对字段 anln1 和 anln2 具有不同的条目。 为此，我需要一个合适的 OpenSQL 语句。

例如有下表：

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

如果存在另一个子编号，例如 anln2=1，则anln1 + anln2 的所有条目应重复其datum 、 psp和przt的组合。

不幸的是，我的表违反了这个规范（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 ) 尝试一下。

Answer 1

在选择 anln2 <> 0 的条目后，我处理了一个内部表。

首先，我像这样对选定的结果进行排序：

 SORT gt_internaltable BY anln1 anln2 datum psp przt. 

然后我遍历了内部表并删除了所有双条目......

 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 中。

Answer 2

我不认为它可以通过 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 的所有条目都应重复它们的 datum、psp 和 przt 组合。 不同的 10007 anln2值有不同的psp值。