1

我想获取所有行，它们对字段 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 ) 试一试。

4

2 回答 2

0

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

于 2015-06-30T10:25:25.960 回答
0

我认为通过 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.

在这里，我们首先按ANLN1key 分组，然后在这些组中检查datum+psr+pspkey以使组大小相等。这意味着所有 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 组合。不同的 10007anln2值有不同的psp值。

于 2020-10-07T15:12:29.383 回答