ABAP 内表 详解

老式的内表类型定义…
214

据悉基本型内表类型…
214

根据结构体类型内表类型…
215

老式的内表对象创建…
215

参照现有内表类型或者内表对象来创造…
215

参照现有结构类型或者组织对象来创造…
215

片种植内表对象等效创建…
215

拉动默认表头的内表的行类型不可知是内表…
216

DATA与WITH HEADER
LINE.
217

摩登内表的定义…
217

使用第二找寻引…
221

INDEX/ANY TABLE通用型内表…
222

内表整体操作…
222

内表间赋值…
222

较内表…
222

排序内表SORT…..
223

冲指定的字段进行排序
BY.
223

接字母顺序(字符语义)进行排序AS
TEXT.
224

稳定排序STABLE.
227

DESCRIBETABLE获取内表属性…
227

获内表数据行数
Lines()227

外表行操作…
227

单行操作…
227

多行操作…
228

适用所有种类内表的行操作…
228

INSERT向表中插行…
228

栽一行…
228

栽多行FROM…TO..
229

COLLECT合并…
229

READ 读取行…
230

点名搜索关键字段…
231

应用说明要字段进行读取…
231

利用其他重要字段进行读取…
232

盖履行首许段搜索…
233

USING
KEY.. 233

<result>指定额外处理选项…
233

点名工作区…
233

COMPARING比较读取的单行内容…
234

TRANSPORTING读取一行的一部分字段…
234

以字段符号…
235

MODIFY 修改行…
236

修改才条记下(TABLE KEY)…
236

修改多久记下(WHERE)…
237

DELETE 删除行…
237

巡回中插入或删除行…
237

删除单行(TABLE KEY)…
238

剔除多实施(WHERE)…
238

去除邻近重复行(ADJACENT DUPLICATE)…
239

LOOP在循环中拍卖行…
240

SUM..
240

AT.
241

适用索引表的行操作…
246

APPEND 附加行…
246

叠加单行…
246

外加多行FROM…
TO..
247

坐排序方式附加…
248

APPEND …SORTED
BY….. 248

USING
KEY. 249

INSERT插入到指定的寻找引位置…
250

栽单行…
250

栽多行FROM…TO..
251

READ读取指定索引位置及之行…
251

以索引表中开展第二划分搜索…
252

在内表中搜寻字符串…
253

MODIFY修改指定索引位置上的行…
254

改单行…
254

改时循环行…USING KEY
loop_key…..
254

利用WRITE TO进行修改…
255

DELETE删除指定索引位置上的行…
256

去单行…
256

巡回中删去行…USING KEY
loop_key…..
256

删去多行…
258

以循环利用FROM…TO限制行的读取范围…
259

用字段符号进行访问…
259

以表头替换工作区…
260

实用的Ranges内表

内表

老式的内表类型定义

老式内表只发业内内表一栽,使用OCCURS选项来定义了正式内表,这是ABAP3.0前的定义内表的做法了,在新版的ABAP不建议用,因为在新的版本被生三种内表类型(标准、排序、哈希)。

 

TYPES <t><type> OCCURS
<n>.

内表中行的数据类型在<type>中指定。要凭借定行的数据类型,可以行使 TYPE 或 LIKE 参数。

根据基本类型内表类型

如若去丢了 OCCURS 则象征是司空见惯档次而未是外表类型了
TYPES
vector TYPE i OCCURS 10.
假如只要带隐藏表头则必定要是增长WITH HEADER
LINE,否则默认没有,而且不得不于声明内表变量时加,而未可知当地方定义内表类型时加
DATA
vector TYPE vector WITH HEADER LINE.

vector =

  1. APPEND vector.

 

点的TYPES与下语句等效:

TYPES
vector TYPE STANDARD TABLE OF
i
        WITH
NON-UNIQUE DEFAULT KEY
       
INITIAL SIZE 10.

 

本示例创建内表数据类型 vector,其实践包含基本类型 I 字段。

 

流动:WITH HEADER LINE只能与DATA关键字并用,而非克同TYPES一起以,这也就是说,只有以分配了储存空间时才发生暗藏工作区这同样说,在概念内表类型时凡没的。

 

下这样啊得:

TYPES vector TYPE i.
DATA vector TYPE vector OCCURS **0** WITH HEADER LINE.
vector = 1.
APPEND vector.

因结构体类型内表类型

出于尚未加 occurs 选项,所以定义之凡一致组织类型
TYPES: BEGIN OF line,
         column1 TYPE i,
         column2
TYPE i,
         column3
TYPE i,
       END OF
line.
概念一外表类型而不是司空见惯品种
TYPES itab TYPE
line
OCCURS 10.

本示例创建内表数据类型itab,其实践和字段串line结构同样。

 

特别注意,上面代码不能够简单的状成如下形式,否则编译出错:

TYPES: BEGIN OF itab OCCURS 10,
         column1
TYPE i,
         column2
TYPE i,
         column3
TYPE i,
      
END OF itab.

即使用TYPES关键字定义内表类型时,不允直接当组织类型(在简要的门类后面又可以,如最上面的演示所示)后面长 OCCURS 选项来以原本也结构类型转换成内表类型,急需像前一样间接定义,但DATA关键字是得的,这种语法规则不行特别。

老式的内表对象创建

参照现有内表类型或者内表对象来创造

DATA
<f><type> [WITH HEADER
LINE].

流淌:<type>必须是一度存在的内表数据类型或内表数据对象(内表类型时行使TYPE 、内表对象下 LIKE)

 

TYPES type TYPE i OCCURS

  1. DATA vector TYPE type WITH HEADER
    LINE.

参照现有结构类型或者组织对象来创造

DATA
<f><type> OCCURS <n> [WITH HEADER
LINE].

横流:<type>可以是曾存在的构造类型或者组织对象(结构类型时行使TYPE 、结构对象下 LIKE),当然也得不是布局类型,而是内表类型或者骨干项目且可:

TYPES type TYPE
i.
DATA vector TYPE type OCCURS 0 WITH HEADER
LINE.

有数栽内表对象等模拟创建

本示例介绍如何下简单栽不同的步骤创建同内表。

TYPES vector_type TYPE i OCCURS 10.
DATA vector TYPE vector_type WITH HEADER LINE.

透过直接当 DATA 语句被运用 OCCURS 选项创建及方了平等的数据类型 VECTOR:

DATA vector TYPE i OCCURS 10 WITH HEADER LINE.DATA vector TYPE i OCCURS
10象征vector是一个内表而无是类型I的变量

OCCURS的作用就是将一般性类型转换为内表类型

 

l  苟创建既非引用现有对象,也无引用现有行结构的内表数据对象

DATA: BEGIN OF <f> OCCURS <n>,
  <component
declaration>,
  …
end of <f>.

拖欠语句会默认创建一个表头。相当给:

DATA itab TYPE STANDARD TABLE OF lineType
      WITH NON-UNIQUE DEFAULT KEY
      INITIAL SIZE n
      WITH HEADER LINE.

 

本示例会面自动创建默认表格工作区域 ITAB:

DATA: BEGIN OF itab OCCURS 10,
         column1 TYPE i,
         column2 TYPE i,
         column3 TYPE i,
       END OF itab.

 

可下这种措施勿会见自行创建隐式工作区,除非在OCCURS
10晚给丰富选项“WITH HEADER LINE”(使用DATA…LIKE/TYPE…OCCURS时莫会见创默认工作区,只有DATA: BEGIN OF … OCCURS
…才见面):

  DATA: BEGIN OF line,
          col1 TYPE i,
          col2 TYPE i,
        END OF line.
  DATA itab LIKE line OCCURS 10 .itab是一个内表而休是一个组织,与DATA itab LIKE standard table of line 等学

 

好像之还有语句:

TYPES tab TYPE|LIKE linetype OCCURS n.

DATA itab TYPE|LIKE linetype OCCURS n[WITH HEADER LINE].

相当于:

TYPES|DATA itab TYPE|LIKE STANDARD TABLE OF linetype
        WITH NON-UNIQUE DEFAULT KEY
        INITIAL SIZE n
[with header line].该选项就适用于DATA关键字,不克跟TYPES一起以

上述两种植样式都只适用于创造标准表,因为于原来的SAP版本被,标准表是唯一的内表类型。

拉动默认表头的内表的行类型不克是内表

设想创立带表头行的内表,行类型不能够直接是内表,但足以就此内表作为组件的结构:

TYPES t1  TYPE i  OCCURS 10 .
TYPES t2 TYPE  t1  OCCURS 10 .

TYPES t3 TYPE t2.
“由于t2的行类型还是内表,所以会见报错:with header lne
不克用来项目也内表类型时

*DATA d1 TYPE t3 WITH HEADER
LINE.
*DATA d1 TYPE t2 WITH HEADER
LINE.

“下面这种精神上同方  DATA d1 TYPE t2
WITH HEADER LINE. 语句是同样效果,所以也会见报错
*DATA d2 TYPE  t1  OCCURS 10  WITH HEADER
LINE.

“下面去丢 WITH HEADER LINE就足以了
DATA d2 TYPE  t1  OCCURS 10 .
“与方语句等效
*DATA d2 TYPE  t2
.

“现向外表d2遭到加以多少时,要通过以下步骤
DATA w_d1 LIKE LINE OF d2.”d2内表的行类型,还是一个内表,以下还得更加定义
DATA w_d1_2 LIKE LINE OF w_d1.”现在w_d1_2是一个组织对象了,该组织没有字段
w_d1_2 =
1.

APPEND w_d1_2 to w_d1 .
APPEND w_d1 to d2 .

 

“但作为内表内部组件是没有问题的(因为这时候的表头的色是一个布局,而非是一个内表)
TYPES:BEGIN OF  t3,
  t1s TYPE  t2,
  END OF t3.

“这里一定要添加 occurs 关键字后,才代表定义之变量是一个内表对象,否则表示一个构造对象,原因是TYPE引用的花色我是一个结构类型,则未是一个内表类型,除非TYPE引用的类我是一个内表类型,则就是不再要。
DATA d2 TYPE  t3  OCCURS 10  WITH HEADER
LINE.

DATA与WITH HEADER LINE

是不是带来表头需要以利用DATA定义内表对象时明确指定,如果非指定默认不见面带表头的:

TYPES: BEGIN OF line,
         column1 TYPE i,
         column2 TYPE i,
         column3 TYPE i,
       END OF line.
TYPES itab TYPE line OCCURS 10.
“定义内表对象,可是非带表头
DATA tab1 TYPE itab.
“定义内表对象,带表头
DATA tab2 LIKE tab1 WITH HEADER LINE.

新式内表的概念

TYPES dtype { {TYPE tabkind OF [REF
TO] type}
              | {LIKE tabkind OF
dobj} }
          [tabkeys]
            [INITIAL SIZE n].

tabkind:

… { {[STANDARD] TABLE}

| {SORTED TABLE}
    | {HASHED
TABLE}
    | {ANY
TABLE}
    | {INDEX
TABLE} } …

ANY TABLE 与 INDEX TABLE 通用型只用用在只能用当字段特号与形式参数中:

wwwlehu6.vip乐虎官网 1

tabkeys:

…[WITH[UNIQUE|NON-UNIQUE]{{KEY[primary_key[ALIAS key_name]COMPONENTS] comp1 comp2 …}|{DEFAULT
KEY}}]
 ”主键索引
[WITH{UNIQUE
HASHED}|{UNIQUE
SORTED}|{NON-UNIQUE
SORTED} KEY key_name COMPONENTS comp1 comp2 … ] …
“第二寻觅引,最多支持15单次搜索引

[{WITH|WITHOUT} FURTHER SECONDARY KEYS ] …

 

概念内表数据对象还足以直接行使ABAP字典中之内表类型,或下字典中之结构体或晶莹表类型作为内表的行类型

DATA itab { {TYPE [STANDARD]|SORTED|HASHED TABLE OF
[REF
TO] type}
          | {LIKE [STANDARD]|SORTED|HASHED TABLE OF
dobj} }
          [

[ WITH [UNIQUE | NON-UNIQUE]
{{KEY [primary_key [ALIAS key_name] COMPONENTS] comp1 comp2 …}
| {DEFAULT
KEY}
} ]”主键索引

[ WITH {UNIQUE
HASHED}|{UNIQUE
SORTED}|{NON-UNIQUE
SORTED}”secondary_key1,第二寻找引
KEY key_name COMPONENTS comp1 comp2 … 
]

[ WITHsecondary_key2 ]…”第二找寻引,最多支持15只伯仲摸索引

[INITIAL SIZE
n]
[WITH HEADER
LINE]
[VALUE IS
INITIAL]

 

 

type:可以是骨干项目,如DATA: itab TYPE TABLE OF
i.

REF TO:表示内表类型也援类型(该品种内表是因此来囤引用的,可针对某个内表)

INITIAL SIZE n:为内表指定初始行数。如果n为0,则会活动分配合适的行数。修改初始内存要求就用于嵌套表,对于极端外层内表没有必要,指定后反而恐影响性,所以一般不要指定。另外,该值对 APPEND…SORTED
BY…发异乎寻常的意图

 

tabkind取值如下

2  标准表(**STANDARD TABLE**),系统为该表的各一行数变动一个逻辑索引,自己内部维护着行号(Index)的编码。表的键值不唯,且并未以表键自动进行排序,支持通过索引访问和键访问两种办法。填充标准表时可以插到指定位置要本有行之后,程序对内表的寻址操作可以由此主要字或索引进行。在对表进行插入删除等操作时,各数据行在内存中之物理位置不转换,系统只重新排列各数据行的索引值。当经常用索引访问表的时候就摘标准表。

2  排序表(**SORTED TABLE**),也出一个逻辑索引,不同之处是排序表总是以其表关键字升序排序后临时进行仓储,排序内表自己之中也维护着行号的号,表的键值可以唯一要不唯,支持通过索引访问同键访问两栽方法。如果经常利用键来访问数,或者想多少能活动排序时,就就此破除序表。

2  哈希表(**HASHED TABLE**),哈希表通过哈希函数生成的表键来标识及快速访问表行,哈希表中的表键没有各个,其值在说明中要唯一,只允许通过表键来做客哈希表。寻址一个数据行的所急需时和表行数无关。如果内表非常非常而且要用主键访问,就因此哈希表。

 

各种类型内表充许的看方式(索引访问、关键字访问):标准内表主要是索引访问,排序内表主要是Key访问,而哈希内表只能通过Key来访问:

wwwlehu6.vip乐虎官网 2

wwwlehu6.vip乐虎官网 3

于索引类型的内表,当一个行操作语句执行了晚,SY-TABIX以返回该行的目录,成功SY-SUBRC返回0。

 

虽然索引比下要字定位行要赶早,但每当多数场面下,我们通过机要字定位一行数,因数量来数据库,我们不理解多少以哪行。

利用主要字定位一行数不同内表的效率比较如下:

2  标准表,取决于表底行数,随行数线性增加。(但为堪先行进行排序,再显以二瓜分查找查找)

2  排序表,取决于表的行数,随行数针对数级增长(系统默认就见面动二私分查找方式来查找)。

2  哈希表,与行数无关,在死数据量的情况下基于重大字查询是绝抢的

tabkeys表主键:

若不指定要字(注:只有标准表可以毫不指定索引类型与第一字,因为系统会受一个默认的关键字,即DEFAULTL KEY),则网会采取默认(标准)关键字,如果指定,则发出下列形式:

l  如果内表行结构是结构体,则足以指定结构体中之某几乎独字段作为内表关键字:

…WITH[UNIQUE|NON-UNIQUE]KEYcomp1 comp2 …

央留意:多单关键字的排序依次很重大,会潜移默化到表的排序方式

l  如果内表的百分之百实施都是出于中心型字段组成,或是由基本类型组成的构造类型字段:

…WITH[UNIQUE|NON-UNIQUE]KEYTABLE LINE|TABLE_LINE

TABLE LINE、TABLE_LINE:将表的整行作为Key,则可采取TABLE_LINE

l  如果不指定其他要字,则足以利用默认的标准要字,该项为默认选项:

…WITH[UNIQUE|NON-UNIQUE]DEFAULTKEY…

 

排序表在指定Key的类别时,可以是UNIQUE也可以是NON-UNIQUE,所以排序内表是否可储存重复的,则就是是看定义时指定的Key类型是UNIQUE还是NON-UNIQUE

 

标准表只能动用NON-UNIQUE(但足简简单单);排序表可以用NON-UNIQUE或UNIQUE(不能够简单);哈希表只能以UNIQUE(不克大概)。

 

于概念内表时,可以不因主要字,此时使用默认(标准)关键字,即一定给 WITH KEY DEFAULT
KEY。如果定义之是STANDARD TABLE,则连WITH KEY DEFAULT KEY选项都好略;但一旦是SORTED
TABLE与HASHED
TABLE,如是用指定为DEFAULT KEY时,不能够看略WITH KEY DEFAULT KEY,并且要确保该内表里发出可有作为默认Key的字段——如字符类型字段,否则不能够由此编译。

 

以概念排序表与哈希表时,一定要是拄定索引类型与根本字(可以指定为WITH KEY DEFAULT
KEY),否则编译通过不过。

 

DEFAULT KEY:默认标准Key为实践结构面临保有byte-type(x ,xstring, xsequence)类型和character-type(c, d, n, t, string,
clike)类型的备字段,其他任何类型且见面叫忽视;如果实行结构被还有子结构,则该子结构中之有着前面提到的型字段也会见吃抽取出来作为Key的均等片;内表类型的字段不见面成为默认Key的同组成部分;如果无byte-type、character-type类型字段,则默认是无见面来Key,:

DATA: BEGIN OF line0 OCCURS 0,
      i TYPE i ,
      c(1),
      END OF line0.
DATA: BEGIN OF line1,
      i TYPE i ,
      c(1),
      itab LIKE line0[],
      END OF line1.
DATA: BEGIN OF line2 OCCURS 0,
        i TYPE i ,
        c TYPE string,
        line LIKE line1,
      END OF line2.

line0-i = 1.
line0-c = ‘a’.
APPEND line0 .
line0-i = 2.
line0-c = ‘b’.
APPEND line0 .

line1-i = 3.
line1-c = ‘c’.
line1-itab = line0[].

line2-i = 4.
line2-c = ‘d’.
line2-line = line1.
APPEND line2.
LOOP AT  line2 .
  WRITE: / line2-i , line2-c.
ENDLOOP.

CLEAR: line1.
line1-i = 32.
line1-c = ‘c’.
CLEAR:line2.
line2-i = 5.
line2-c = ‘d’.
line2-line = line1.
“未安装line1-itab,但为克创新,这说明内表字段默认不见面当Key
MODIFY TABLE
line2.”根据重点字来窜内表
WRITE: / sy-subrc.
LOOP AT  line2 .
  WRITE: / line2-i , line2-c.
ENDLOOP.

 

虽说数字型字段默认(DEFUALT KEY)不当作主要字段,但好使KEY明确指定;在应用KEY明确指定要字段时,如果内表行包含结构组件,还可指定到该结构组件的某元素作为重点字段:

TYPES: BEGIN OF line0,
      i TYPE i ,
      c(1),
      END OF line0.
TYPES: BEGIN OF line1,
      i TYPE i ,
      c(1),
      itab TYPE line0,
      END OF line1.
DATA itab1 TYPE TABLE OF
line1 WITH KEY i
itab.
DATA itab2 TYPE TABLE OF
line1 WITH KEY i
itab****i.

利用第二寻觅引

譬如说数据库表一样,内表也堪创建多单目录,内表有三栽档次第二追寻引:

2  UNIQUE HASHED:           哈希算法第二物色引

2  UNIQUE SORTED:            唯一升序第二找引

2  NON-UNIQUE SORTED: 非唯一升序第二搜引

TYPES sbook_tab
      TYPE STANDARD
TABLE
      OF
sbook
      “主索引:如果假定吗主索引指定名称,则不得不利用预置的
primary_key,
      “但好由此后的 ALIAS
选项来改(注:ALIAS选项只能用来排序和哈希表)
      WITH NON-UNIQUE KEY
primary_key “ALIAS
my_primary_key

           COMPONENTS carrid connid fldate bookid
      “第一独次搜索引:唯一哈希算法
      WITH UNIQUE
HASHED KEY
hash_key
           COMPONENTS carrid connid fldate bookid
      “第二次之追寻引:非唯一升序排序索引
      WITH NON-UNIQUE
SORTED KEY
sort_key
           COMPONENTS customid.

 

其次寻引会影响如何行将被处理,以及处理顺序:

2  可以于READ TABLE
itab, LOOP AT itab, MODIFY itab, DELETE itab内表操作语词被经WITH [TABLE] KEY …
COMPONENTS或者USING
KEY选项指定key_name来使用第二寻找引

2  可以于INSERT
itab与APPEND语句被通过USING
KEY选项来运源内表的老二摸索引

 

DATA itab TYPE HASHED TABLE OF
dbtab
  WITH UNIQUE KEY
col1 col2 …

  “向内表itab中丰富大量的数据 
  …

READ TABLE
itab “使用无主键进行检索,搜索速度将会晤坏缓慢
           WITH KEY col3 = … col4 = …

          
ASSIGNING

地方程序中定义了一个哈希内表,在读取时莫以主键,在十分数据量的状下速度会十分缓慢,所以当追寻字段及创设第二寻找引:
DATA itab TYPE HASHED TABLE
OF
 dbtab
  WITH UNIQUE KEY
col1 col2 …

  “为无主键创建第二找寻引
  WITH NON-UNIQUE SORTED KEYsecond_key
    COMPONENTS col3 col4 …

  “向内表itab中添加大量的数据 
  …

READ TABLE
itab 冲第二搜索引进行搜索,会于地方程序快
           WITH TABLE
KEY
 second_key
           COMPONENTS col3 = … col4 = …

           ASSIGNING …

以循环内表的Where条件中,如果内表不是排序内表,则免会见以二分开查找,如果应用SORTED
KEY,则循环时,是否会用到第二瓜分查找?
LOOP AT itab USING
KEY
 second_key wherecol3=… col4=… .

ENDLOOP.

INDEX/ANY TABLE通用型内表

除开上面三种标准项目外,还有普普通通项目,即索引表(INDEX TABLE)和任意表(ANY TABLE),一般性项目可以用于类型定义中,但不克用来声明一个内表对象,因为其并没有指明任何明显的表类型,因而系统无法确定对那个操作办法。一般性项目还可用来指明字段符号和接口参数的类,其实际类型或者以运行期内才会确定。

wwwlehu6.vip乐虎官网 4

内表整体操作

内表间赋值

有数只内表添加应用批量增代表逐行

不推荐:

LOOP AT
int_fligh1.
  APPEND int_fligh1 TO int_fligh2.
ENDLOOP.

推荐:

Append lines of
int_fligh1 to int_fligh2.

 

APPEND LINES OF<itab1>
[FROM<n1>] [TO<n2>] TO<itab2>.

 

APPEND LINES OF A TO B.

 

行类型兼容的内表可以使用“=”直接进行赋值,前提是求履行结构可变换,规则参考这里Unicode fragment view of
structures。

于内表

EQ, =, NE, <>, ><, GE, >=, LE,
<=, GT, >, LT, <

 

正如专业:

预先比较单薄独内表的行数行,如果行数多之内表就坏;如果简单单内表的行数相等,将会见一行一行、一个字段一个字段的比较,如果字段本身是一个内表类型,则会递归比较;如果不是等比较时,只要某行某个字段不等就会见终止继续往后比。

排序内表SORT…

得经过内表的KEY对标准表哈希表**按说哈希表是休可知开展排序的,但ABAP里是可的,与Java不同)**进行排序:

SORT **<itab> [ASCENDING|DESCENDING] [AS
TEXT] [STABLE].**

SORT itab [STABLE]
          { {[ASCENDING|DESCENDING]
              [AS
TEXT]
              [BY {comp1 [ASCENDING|DESCENDING] [AS
TEXT]}
                  {comp2 [ASCENDING|DESCENDING] [AS
TEXT]}
                  …
]}
          | {[BY (otab)]} }.

 

该语句默认见面以内表所定义之持有主要字段(即primary table
key
)来拓展排序(在尚未用BY (otab)的状态下),关键字段排序的先后顺序依赖让标准键在内表中的Key定义的逐条。

 

默认是升序。

 

由于排序内表具有自动排序功能,因此用SORT关键字对排序内表进行排序没有其余意义,也以见面促成程序的编译错误

 

DATA: itab TYPE HASHED
TABLE
OF c WITH UNIQUE DEFAULT
KEY WITH HEADER LINE.
INSERT ‘3’ INTO TABLE
itab.
INSERT ‘2’ INTO TABLE
itab.
INSERT ‘1’ INTO TABLE
itab.
LOOP AT  itab.
  WRITE: / itab.
ENDLOOP.
SORT itab .
SKIP.
LOOP AT  itab.
  WRITE: / itab.
ENDLOOP.

3

2

1

 

1

2

3

冲指定的字段进行排序 BY

倘你生一个行类型为组织的内表,则于排序时得指定排序字段:

 

BY会取消前面的一体化排序字段,即非会见又因为默认的重要性字段来排序,关键字段不现影响排序结构,这些字段可以是其他类型,包括表格。如果指定多只第一字段,则网率先冲<F1>,然后根据<F2>,以此类推对记录进行排序。系统以BY 之前指定的排序方式(升序还是降序)将作 BY 之后指定的拥有字段的缺省排序方式(即BY后面没有点名排序方式时见面动用前指定的总体排序方式),且当么字段之后指定的排序方式将挂在 BY 之前指定的这些字段的排序方式。

 

可利用 (<name>) 代替<fi>进行动态设置,如果<name>在运转时也空,系统便将那个忽视,如果带有无效的零件名,则发出实时错误。对于其它在排序字段被以的字段,用户都只是指定偏移量和长度。

接字母顺序(字符语义)进行排序AS TEXT

CONVERT TEXT text INTOSORTABLECODE hex

据悉当用户操作环境来好成字符text所对应之排序字符索引串,此索引串是同用户眼前操作的条件有关,如语言、国家等。如中文环境平台下,中文字符串会冲中文的拼音来进行排序,这种排序规则就是是于里采用了任何一样栽专用来排序的编码,hex就是为此来储存这种排序编码的。

可以行使SET LOCALE来安用户所处语言环境

 

 

SET LOCALE LANGUAGE<lg>
[COUNTRY<cy>]

改时用户所处的语言环境

The fields <lg>, <cy>, and
<m> must be of type C and must have the same lengths as the
keyfields of table TCP0C. Table TCP0Cis a table, in which the
text environment is maintainedplatform-dependent.

SET LOCALE只影响SORT …
AS TEXT, TRANSLATE … TO

 

SET LOCALE LANGUAGE ”

当lg为空时,会再也设置为报到时之言语环境

 

SORT <itab> … AS TEXT …
.

依据用户眼前所处的语言环境来进行排序(如中文环境下,中文字符按拼音的排序规则来开展排序),如果非指定该选择,则会默认使用Unicode排序

要是需要排序的字符串只有ASCII字符,则从未必要采取该选择

 

publicclass T {

    publicstaticvoid main(String[]
args) throws UnsupportedEncodingException
{

        String str = “的”;

        byte[] b
= “的”.getBytes(“utf-8”);

      

        for (byte c : b) {

            System.out.print(byteToHex(c));

        }

      

    }

 

    publicstatic String
byteToHex(byte b) {

        return Integer.toHexString((b &
0x000000FF) | 0xFFFFFF00).substring(6)

               
.toUpperCase();

    }

}

E79A84

 

wwwlehu6.vip乐虎官网 5

wwwlehu6.vip乐虎官网 6

 

 

DATA: BEGIN OF line,
  c TYPE string,
  b TYPE xstring,
  x TYPE xstring,
  END OF line.
“在变之前先行得要装当前所假设使用的语言环境
SET LOCALE LANGUAGE ‘1’ COUNTRY ‘CN’.
DATA: itab LIKE STANDARD TABLE OF line WITH HEADER LINE WITH NON-UNIQUE KEY c.

PERFORM append USING ‘的’.
PERFORM append USING ‘边’.
PERFORM append USING ‘二’.
PERFORM append USING ‘安’.
PERFORM append USING ‘长’.

WRITE: / ‘–原始顺序–‘.
LOOP AT itab.
  WRITE: / itab-c,itab-b,itab-x.
ENDLOOP.
SKIP.
SORT itab BY c.
WRITE: / ‘–按字符的Unicode编码进行排序–‘.
LOOP AT itab.
  WRITE: / itab-c,itab-b,itab-x.
ENDLOOP.
SKIP.
SORT itab BY b.
WRITE: / ‘–直接按字符的UTF8编码所对应之数字进行排序–‘.
LOOP AT itab.
  WRITE: / itab-c,itab-b,itab-x.
ENDLOOP.
SKIP.
SORT itab BY c AS TEXT.
WRITE: / ‘–按中文语义(拼音)进行排序–‘.
LOOP AT itab.
  WRITE: / itab-c,itab-b,itab-x.
ENDLOOP.
SKIP.
WRITE: / ‘–按中文字符所对应之排序Key来拓展排序–‘.
SORT itab BY x.
LOOP AT itab.
  WRITE: / itab-c,itab-b,itab-x.
ENDLOOP.

FORM append  USING  value(p_0059).
  itab-c = p_0059.
  DATA : l_con TYPE  REF  TO  cl_rpe_convert.
  CREATE  OBJECT l_con.
  CALL METHOD l_con->string_to_xstring
    EXPORTING
      input  = itab-c
    IMPORTING
      output = itab-b.
  CONVERT TEXT itab-c INTO SORTABLE CODE itab-x.
 
APPEND  itab.
ENDFORM.

–原始顺序–

的 E79A84
C6D501050105

边 E8BEB9
C57301050105

二 E4BA8C
C77201050105

安 E5AE89
A901050105

长 E995BF
C5F401050105

 

—-按字符的Unicode编码进行排序—-

二 E4BA8C
C77201050105

安 E5AE89
A901050105

的 E79A84
C6D501050105

边 E8BEB9
C57301050105

长 E995BF
C5F401050105

 

–直接按字符的UTF8编码所对应的数字进行排序–

二 E4BA8C
C77201050105

安 E5AE89
A901050105

的 E79A84
C6D501050105

边 E8BEB9
C57301050105

长 E995BF
C5F401050105

 

–按中文语义(拼音)进行排序–

安 E5AE89
A901050105

边 E8BEB9
C57301050105

长 E995BF
C5F401050105

的 E79A84
C6D501050105

二 E4BA8C
C77201050105

 

–按中文字符所对应之排序Key来进展排序–

安 E5AE89
A901050105

边 E8BEB9
C57301050105

长 E995BF
C5F401050105

的 E79A84
C6D501050105

二 E4BA8C
C77201050105

政通人和排序STABLE

SORT <itab> …
STABLE.

假定对数组中冒出的任意a[i],a[j](i<j),其中a[i]==a[j],在拓展排序以后a[i]定出现在a[j]之前,则当该排序是泰之。(相等的数量不见面更交换位置,排序后仍旧后维持原来顺序)。

 

无清楚怎么,去丢 STABLE 选项好像还是风平浪静之,难道默认就是政通人和排序?

DESCRIBETABLE获取内表属性

DESCRIBETABLE

取内表数据行数 Lines()

… lines( arg ) …

The function lines determines the number of lines in
an internal table. The argument arg must be an internal
table.

内表行操作

单行操作

wwwlehu6.vip乐虎官网 7

多行操作

wwwlehu6.vip乐虎官网 8

适用所有项目内表的行操作

于该节中列有之操作适用所有类型的内表。如果您以操作前知道内表的类,请以合适的操作,比如,使用 APPEND…TO 语句填入充索引内表,使用 INSERT…INTO TABLE 来填充Hash表或通用性类型(ANY
TABLE、INDEX
TABLE),这样效率会强有。

INSERT向表中插入入行

INSERT wa|{INITIAL
LINE}|{LINES OF jtab [FROM
idx1] [TO
idx2]
[USING KEY
key_name|(name)]} 
INTO {TABLE
itab}
{ ASSIGNING <fs>
[CASTING] }|{ REFERENCE INTO
dref }.

 

未克望排序表中插入重复的数量,否则抛大。

倘往哈希表中插重得的数目,不见面打作用,也未会见扔大。

 

l  于UNIQUE 的排序表或哈希表插入重复的多寡经常,不会见废弃大,但数据未见面被插进去,即同APPEND是免雷同的

插入一行

INSERT <line> INTO TABLE<itab>.

<line>可以是一个工作区或者是 INITIAL
LINE。

 

一经为一个 unique key 内表中插重复的数据实施,则SY-SUBRC to
4。

 

为不同档次表中插入的情:

2  标准表:会以内表最后新增行,与 APPEND 效果等同。

2  排序表:会根据说明要字段插入到相当的位置。如果是一个 non-unique 内表,会用再度的行插入到已有数据行的前头。所花费的年月会趁表中的数额多成对数形式之长。

2  哈希表:使用哈希算根据表关键字计算出所插入的职务,哈希表不见面为数据行的增加而快减慢。

插入多行FROM…TO

INSERT LINES OF <itab1> [FROM
<n1>] [TO <n2>] INTO
TABLE
<itab2>.

<itab1> and
<itab2>要拥有相当的行类型。系统将祭单条插入规则一条条插入到<itab2>中。如果<itab1>是一个索引类型的申,则可指定要插入的第一履<n1>与终极一执<n2>数据的目录。

 

在于表格大小和插地点的异,用该办法将一个报表插入到另外一个遭遇之快慢比在循环中逐行进行扦插要及早接近20倍。

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
col3 TYPE c,
END OF line.
DATA: itab LIKE STANDARD TABLE OF line,
      jtab LIKE SORTED TABLE OF line
            WITH NON-UNIQUE KEY col1 col2.
DO 2 TIMES.
  line-col1 = sy-index. line-col2 = sy-index ** 2.line-col3 = ‘a’.
  APPEND line TO itab.
  line-col1 = sy-index. line-col2 = sy-index ** 3.line-col3 = ‘b’.
  APPEND line TO jtab.
ENDDO.
“会拿重新的行插入到已有数据行的前方
INSERT lines of itab INTO TABLE
jtab.
LOOP AT jtab INTO line.
  WRITE: / sy-tabix, line-col1, line-col2,line-col3.
ENDLOOP.

        
1           1           1  a

        
2           1           1  b

        
3           2           4  a

        
4           2           8  b

COLLECT合并

COLLECT [<wa>INTO]
<itab>{ ASSIGNING<fs>
[CASTING] } | { REFERENCEINTO dref }.

<itab>必须是扁结构,所有其他非关键字段的字段必须是数字型(I、F、P):

DATA: BEGIN OF line,
col1 TYPE c,
col2 TYPE i,
col3 TYPE c,
END OF line.
DATA: itab like STANDARD TABLE OF line
        WITH HEADER LINE WITH NON-UNIQUE key col1.
itab-col1 = ‘a’.
itab-col2 = 1.
itab-col3 = ‘b’.
APPEND itab.
itab-col1 = ‘a’.
itab-col2 = 2.
itab-col3 = ‘c’.
“编译出错:非要字段必须是 I P F
数字型
*COLLECT itab INTO
itab.

 

COLLECT语句以一个面临所有相同关键字段值的行中同名的数字字段的价共到同一漫漫记下上,只有非表关键字段被长;当于内表中找找不顶指定的受难为加行时,COLLECT语句之力量以及APPEND语句是一致的,即用一个工作区的情节补充加至内表中。使用COLLECT操作的内表有一个范围,即该的履结构中,除了表键字段以外的有所字段都不能不是数字型(i、p、f)

 

倘单独用 COLLECT 语句填入内表,则无见面出现更条目,因此适用于统计表的构造。

 

差品类的内表统计情况:

ü  标准表:系统会挨个查找是否就有的尽,所花费时间会随着表底行数线性增加,如果原始表里存重的推行,则单独会以及第一履行统一。SY-TABIX存储了COLLECT操作所对应之插入或联合索引号。

ü  排序表:系统采取二划分查找法搜索已经在的实践,索引的周转的时日会趁着行数的增多成对数级的增多。SY-TABIX存储了COLLECT操作所对应之插或合并索引号

ü  哈希表:系统采取哈希算法查找已在的履行,在运COLLECT后,SY-TABIX的值还见面是0,因为哈希表没有索引。

 

DATA: BEGIN OF line,
col1(3) TYPE c,
col2(2) TYPE n,
col3 TYPE i,
END OF line.
DATA itab LIKE SORTED TABLE OF line
      WITH NON-UNIQUE KEY col1 col2.
line-col1 = ‘abc’. line-col2 = ’12’. line-col3 = 3.
COLLECT line INTO itab.
WRITE / sy-tabix.
line-col1 = ‘def’. line-col2 = ’34’. line-col3 = 5.
COLLECT line INTO itab.
WRITE / sy-tabix.
line-col1 = ‘abc’. line-col2 = ’12’. line-col3 = 7.
COLLECT line INTO itab.
WRITE / sy-tabix.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2, line-col3.
ENDLOOP.

        
1

        
2

        
1

abc 12        
10

def 34         
5

READ 读取行

READ TABLE itab { 
{FROM
wa [USING
KEY key_name|(name)]}
| {WITH TABLE
KEY
 [key_name|(name) COMPONENTS] {comp_name1|(name1)} = dobj1 {comp_name2|(name2)} = dobj2 …}
| WITH
KEY
 {comp1 = dobj1 comp2 = dobj2 … [BINARY
SEARCH
]} | {key_name|(name) COMPONENTS comp1 = dobj1 comp2 = dobj2 …}
|INDEX
idx
[USING
KEY key_name|(name)] }
{INTO wa [[COMPARING { {comp1
comp2
…}|{ALL FIELDS}|{NO
FIELDS} }] [TRANSPORTING{ {comp1
comp2
…}|{ALL
FIELDS} }]]}| {ASSIGNING<fs> [CASTING]} | {REFERENCE INTO
dref} | {TRANSPORTING NO
FIELDS}..

comp1
comp2
 …
… { comp_name[-sub_comp][{+off(len)}|{->attr}] }
| {(name)} …

 

要是未指定USING KEY选项,则默认会使primary table
key。

若是内表定义了亚解除序索引sorted secondary
key,则可使用 USING KEY 选项来指定这个次去掉序索引,即读取时,根据这第二免去序Key排序之后的目录来读取,但未能够用secondary hashed key.

苟内表的secondary key 存在,使用了USING KEY时,INDEX选项好用至不同种类的内表中(比如可以叫Hash内表创建一个次脱序索引sorted secondary
key,则在读取此Hash内表时,可以下索引INDEX方式来读取) 

 

sy-subrc

sy-tabix

0

找到记录

sy-tabix为主或第二索引值primary or secondary table index used,如果是hash key,则sy-tabix为0

2

找到记录,但COMPARING时相应字段不同

sy-tabix为主或第二索引值primary or secondary table index used,如果是hash key,则sy-tabix为0

4

记录没找到,且未读取到内表尾部

如果READ TABLE语句中明确地使用BINARY SEARCH方式读取、或者读取时使用了USE KEY、WITH [TABLE] KEY key_name选项明确的指定通过UNIQUE SORTED、NON-UNIQUE SORTED类型的第二辅助索引来方式来读取的、又或者读取的内表本身就是排序类型,则sy-tabix的值为待查记录在该内表中本应该出现的位置索引,除些之外,sy-tabix的值是不确定的

8

记录没有找到,且读取到内表尾部了
如果通过了二分搜索,且探索到尾部都还没有搜到时,sy-tabix的值为rows + 1

指定搜索关键字段

招来关键字段可以是说明要字段,也不过为是其余非表关键字段。

设若是non-unique的内表,有再度时,会回去第一久数据。

采用说明要字段进行读取

READ TABLE<itab>FROM <wa><result>.

或者

READ TABLE <itab>WITH TABLE KEY<k1> =
<f1> …<kn>
= <fn><result>.

 

首先种植之<wa>必须同行类型兼容,以表明要字为觅条件,且值来自<wa>,如果相应关键字段的价值吗空,则相当有的笔录,如果拥有重大字还为空,则会读取第一执

老二栽也是行使成套表要字段上搜索,k1…kn可以动态指定(如(<ni>) =
<fi>.)。

 

一旦当读取时,未采取第二辅助索引Key,而是采取的默认的primary table key ,则不同的色的内表读取的方不雷同:

ü  标准表:顺序搜索,查找时间会随着条目的充实而线性增加

ü  排序表:二瓜分查找,查找时间会趁机条目的多而针对数级增加

ü  哈希表:使用哈希算法进行查询,查找时间不依靠让条目数

 

DATA: BEGIN OF line,
         col1
TYPE c,
         col2
TYPE p DECIMALS 5,
      END OF line.
DATA itab LIKE line OCCURS 10 WITH HEADER
LINE.
DO 5 TIMES.
  line-col1 = sy-index.  line-col2 = SQRT( sy-index ).
  APPEND line TO
itab.
ENDDO.

CLEAR: itab,line.
itab-col1 = ‘2’.
READ TABLE itab INTO line.条件来自表头关键字段,并拿翻开找到的结果存入到工作区
WRITE: / sy-subrc, itab-col2, line-col2.

CLEAR: itab,line.
itab-col1 = ‘2’.
READ TABLE itab.条件来自表头关键字段,并以翻开找到的结果存入表头
WRITE: / sy-subrc, itab-col2, line-col2.

    0          
0.00000           1.41421

    0          
1.41421           0.00000

 

用其他重要字段进行读取

万一采用其它非表关键字段为准绳进行搜时,可以行使以下语句:

READ TABLE<itab>WITH KEY=
<key><result>.

或者

READ TABLE <itab> WITH KEY<k1> = <f1>
… <kn> = <fn><result>.

 

于第一单告知句被,key是一个工作区,并且布满内表的尽的保有字段都见面作找条件。注:一定是整行,而不是内表本身那些重要字段所构成的字段,也就是说与内表本身要字段没有其余关系,请圈下面示例:

DATA: BEGIN OF line,
         col1 TYPE c,
         col2 TYPE n,
         col3 TYPE i,
      END OF line,
      line2 LIKE line.
DATA: itab LIKE STANDARD TABLE OF line WITH HEADER LINE WITH KEY col1 col2 .
line-col1 = ‘1’.
line-col2 = ‘1’.
line-col3 = 10.
APPEND line TO itab.
line-col1 = ‘2’.
line-col2 = ‘2’.
line-col3 = 20.
APPEND line TO itab.
CLEAR: line.
line-col1 = ‘1’.
line-col2 = ‘1’.
“注:这里不克省略下面语句,否则查找无至
line-col3 = 10.
READ TABLE itab INTO line2 WITH KEY = line.
WRITE: / sy-subrc, line2-col1.

“**如果行类型本身便是主导项目时
DATA: itab2 TYPE STANDARD TABLE OF i WITH HEADER LINE with KEY TABLE_LINE.
itab2 = 2.
append itab2.
itab2 = 1.
append itab2.
READ TABLE itab2 WITH KEY = 2.
WRITE: / sy-subrc,
itab2.

 

每当次只告知词被,这里的 k1…kn 不肯定是内表中确的首要字段,只要是内表行组件即可。如果 k1…kn 要交运行时才了解,则好利用(‘ key ‘) =
<f>
的格式来动态指定要比的字段,如果 key 为空,则会忽视比较。

 

如上二种点儿栽方法于具有表都是顺序搜索,所用时间就表底数据量增加或者线性增加。

坐尽首字段寻找

倘以内表的行首定义为主要字,请以 WITH KEY 选项

READ TABLE <itab>WITH
KEY<k><result>.

<k>不可知包含内表或含有内表的布局。

DATA: BEGIN OF
line,
         i TYPE i,
         c TYPE c,
      END OF line.
DATA itab LIKE line OCCURS 10.
line-i = 10.
line-c = ‘a’.
append line to itab.
CLEAR: line.
“以率先单字段为key
READ TABLE
itab INTO line WITH KEY 10.
WRITE: / sy-subrc, line-c.

   0   
a

USING KEY

READ TABLE itab {FROM wa [USING KEY
key_name|(name)]}

 

DATA: sflight_tab TYPE HASHED TABLE OF
sflight
                  WITH UNIQUE KEY
primary_key  COMPONENTS carrid connid
fldate
                  WITH NON-UNIQUE SORTED
KEY
 occupied_seats COMPONENTS seatsocc,
      sflight_wa 
LIKE LINE OF
sflight_tab.

DO 10 TIMES.
  “使用排序第二追寻引,这样便是Hash类型的内表,也得以用INDEX方式来读取Hash内表
 
READ TABLE
sflight_tab
       INDEX sy-index USING
KEY
 occupied_seats
       INTO sflight_wa.
  …
ENDDO.

 

指定额外处理选项”><result>指定额外处理选项

而可指定一些格外的挑选项来吃系统如何处理查找到数据。

点名工作区

卿可以将找到的数据行存储到一个包含<result>选项之工作区中:

READ TABLE <itab><key> INTO
<wa>[COMPARING
<f1><f2> …|ALL FIELDS]

[TRANSPORTING
<f1><f2> …|ALL FIELDS|NO
FIELDS].

这里的<fi>可以是动态指定的((<ni>))

COMPARING比较读取的单行内容

系根据<key>(关键字段)读取指定的单行并事先囤到<wa>工作区中,读取行之后,将表明及工作区<wa>中的照应组件进行比。

… <F1>
…<fn>
表示只是比较指定的字段,

… ALL FIELDS意味着于有组件

 

如果系统查找依据指定<key>找到了对应的条文,且进行比较的字段内容千篇一律,则将 SY-SUBRC 设置为0,如果进行比的字段内容不同,则回值 2;如果系统基于<key>找不交条目,则含有 4。如果系统找到条目,则无论比较结实如何,都拿其读入目标区域。

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE HASHED TABLE OF line WITH UNIQUE KEY col1.
DO 3 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  INSERT line INTO TABLE itab.
ENDDO.
line-col1 = 2. line-col2 = 3.
READ TABLE itab FROM line INTO line COMPARING
col2.
WRITE: ‘SY-SUBRC =’, sy-subrc.
WRITE: / line-col1, line-col2.

SY-SUBRC =    
2

        
2           4

 

DATA: BEGIN OF
line,
         col1
TYPE i,
         col2
TYPE i,
         col3
TYPE i,
      END OF line.
DATA itab LIKE line OCCURS 10.
DO 10 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  line-col3 = sy-index ** 3.
  APPEND line TO itab.
ENDDO.
CLEAR: line.
line-col1 = 2. line-col2 = 4.
“只要根据重点字或者索引条件在内表中读取到对应数据,不管该数据行是否
“与COMPARING
指定的字段相符,都见面盖存储到工作区中。
READ TABLE
itab INTO line INDEX 4 COMPARING col1 col2.
WRITE: / sy-subrc, sy-tabix,line-col1,line-col2,line-col3.
CLEAR: line-col3.
“也可动用主要字KEY来读取指定行还拓展比较
READ TABLE itab INTO line WITH KEY col1 = 4 col2 = 16 COMPARING col1 col2.
WRITE: / sy-subrc, sy-tabix,line-col1,line-col2,line-col3.

    2          
4           4          16          64

    0          
4           4          16          64

TRANSPORTING读取一行的有些字段

系基于<key>(关键字段)条件查找对应的条款后,只拿<result>中指定的组件字段存储到工作区域受到。

 

… NO FIELDS表示未导任何组件,此种植情况下,READ语句只影响系字段 SY-SUBRC 和 SY-TABIX(前提条件是索引表),并且以TRANSPORTING NO FIELDS情况下,如果指定了<wa>,则会忽视掉。

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE SORTED TABLE OF line WITH UNIQUE KEY col1.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  INSERT line INTO TABLE itab.
ENDDO.
CLEAR line.
READ TABLE itab WITH TABLE KEY col1 = 3INTO line TRANSPORTING col2.主键没有被传
WRITE: ‘SY-SUBRC =’, sy-subrc,
/ ‘SY-TABIX
=’, sy-tabix.
WRITE: / line-col1, line-col2.

SY-SUBRC =    
0

SY-TABIX
=          3

        
0           9

 

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE SORTED TABLE OF line WITH UNIQUE KEY col1.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  INSERT line INTO TABLE itab.
ENDDO.
READ TABLE itab WITH KEY col2 = 16 TRANSPORTING NO FIELDS.
WRITE: ‘SY-SUBRC =’, sy-subrc,
/ ‘SY-TABIX
=’,
sy-tabix.

SY-SUBRC =    
0

SY-TABIX
=          4

利用字段符号

wwwlehu6.vip乐虎官网 9

您得拿查到的数目行赋值给指定的字段符号:

READ TABLE <itab><key>ASSIGNING<FS>.

 

赢得更多的信,请参见运字段符号进行走访

 

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE HASHED TABLE OF line WITH UNIQUE KEY col1.
FIELD-SYMBOLS <fs> LIKE LINE OF itab.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  INSERT line INTO TABLE itab.
ENDDO.
READ TABLE itab WITH TABLE KEY col1 = 2 ASSIGNING <fs>.
<fs>-col2 = 100.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.

        
1           1

         2        
100

        
3           9

        
4          16

 

MODIFY 修改行

MODIFY

{ TABLE
itab
[USING
KEY key_name|(name)] | {itab INDEX idx [USING KEY key_name|(name)]} | {itab [USING KEY
loop_key]} } FROM
wa
[TRANSPORTINGcomp1 comp2…] [{ASSIGNING <fs> [CASTING]} | {REFERENCE INTO
dref}]
|itab FROM wa [USING KEY key_name|(name)] TRANSPORTING
comp1 comp2… WHERE log_exp|(cond_syntax) }.

 

comp1
comp2
 …
… { comp_name[-sub_comp][{+off(len)}|{->attr}] }
| {(name)} …

修改单独条记下(TABLE KEY)

MODIFY TABLE <itab>[USING
KEY 
key_name|(name)]FROM<wa>
[TRANSPORTING<f1><f2> …].

此间的<wa>扮演双重身份,不仅指定了使修改的履(条件),还连要修改的新的价值。系统为周表底拥有主要字段来搜寻要修改的实行。

 

USING KEY:如果不以这个选项,则会动用默认的主键primary table
key来修改相应行

 

要是找到要改的尽,则拿<wa>中兼有非关键字段的始末拷贝到相应的数量行中对应的字段上, SY-SUBRC设置也 0,否则 SY-SUBRC 设置为4。如果是 NON-UNIQUE 类型的阐发,且找到多漫长时才修改第一修数。

 

好以 TRANSPORTING 选项修改部分非关键字段。

 

Fi可以是动态指定(<ni>) ,如果ni 为空,则运行时会见忽视。

 

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE HASHED TABLE OF line WITH UNIQUE KEY
col1.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  INSERT line INTO TABLE itab.
ENDDO.
line-col1 = 2. line-col2 = 100.
MODIFY TABLE itab FROM line.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.

        
1           1

         2        
100

        
3           9

        
4          16

改多久记下(WHERE)

MODIFY <itab> FROM <wa> TRANSPORTING<f1><f2>
… WHERE <cond>.

该语句会修改满蒙极的差不多规格数据。逻辑表达式<cond>中的各子表达式的率先独操作数必须是外表行结构的零部件。

 

这里的TRANSPORTING **举凡必的**,与上面MODIFY中的TRANSPORTING不一样。

 

倘是标准表,可以当TRANSPORTING后面指定修改字段为表关键字段,但排序表与哈希表则未克改主要字段。

 

如至少发生相同长数为成功修改了,则SY-SUBRC为0,否则也4。

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE HASHED TABLE OF line WITH UNIQUE KEY
col1.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  INSERT line INTO TABLE itab.
ENDDO.
line-col2 = 100.
MODIFY itab FROM line TRANSPORTING col2 WHERE ( col2 > 1 ) AND ( col1 < 4 ).
LOOP AT
itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.

        
1           1

         2        
100

         3        
100

        
4          16

DELETE 删除行

DELETE { {TABLEitab {FROM wa [USING KEY key_name|(name)]} | {WITH TABLE
KEY [key_name|(name) COMPONENTS] {comp_name1|(name1)}=dobj1 {comp_name2|(name2)}=dobj2…}} | {itab INDEX idx [USING KEY key_name|(name)]} | {itab [USING KEY
loop_key]}
| itab [USING KEY key_name|(name)] [FROM idx1] [TO
idx2] [WHERE log_exp|(cond_syntax)]
| ADJACENT DUPLICATES
FROM itab [USING KEY key_name|(name)] [COMPARING {comp1
comp2
 …}|{ALL FIELDS}]…
}

 

comp1
comp2
 …
… { comp_name[-sub_comp][{+off(len)}|{->attr}] }
| {(name)} …

 

循环中插或去行

极不用以循环中插或去行,因为可能会见生出不必要的题目:插入操作会使插入位置后的履行的sy-tabix 都加1(只针对索引表),删除则会是于删去行后所有行的目录都减1;如果是插,则下次轮回还是打当前受通历行的背后开始就遍历,但找引增加1了;但如果是去的是眼前遍历的行,则下次去或延续就删除下一行数,并且删除后下次循环的目录还是和上次同一(所以会接二连三去,不见面隔行删除) ,

循环中插入入行央参见这里

循环中去除行请参见这里

 

下为能去除所有行:

LOOP AT itab_person FROM 1 to 1.
  DELETE itab_person.
ENDLOOP.

删除单行(TABLE KEY)

DELETE TABLE<itab>FROM<wa>.

或者

DELETE TABLE <itab> WITH TABLE KEY <k1> = <f1> …
<kn> = <fn>.

 

有数单报告句子都是根据表的主要字段进行删减的,第二栽而将所有表关键字段写及,不同第一种的凡可运用动态的字段名。

 

如若成功删除,则SY-SUBRC设置为0,否则也4。如果是 non-unique 内表,且满足条件的生差不多规格数据常常,只见面去除第一条。

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE HASHED TABLE OF line WITH UNIQUE KEY
col1.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  INSERT line INTO TABLE itab.
ENDDO.
line-col1 = 1.
DELETE TABLE itab: FROM line,
WITH TABLE KEY col1 = 3.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.

        
2           4

        
4          16

删去多推行(WHERE)

DELETE<itab>WHERE<cond>.

 

假设至少有同等长长的数据让成功删除,则SY-SUBRC为0,否则也4。

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE HASHED TABLE OF line WITH UNIQUE KEY
col1.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  INSERT line INTO TABLE itab.
ENDDO.
DELETE itab WHERE ( col2 > 1 ) AND ( col1 < 4 )**.
**LOOP AT
itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.

  
1           1

        
4          16

除去邻近重复行(ADJACENT DUPLICATE)

DELETE ADJACENT DUPLICATES FROM
<itab>

[COMPARING<f1><f2>

|ALL FIELDS].

系从内表<itab>中删去所有邻近重复条目。

以偏下情形下代表记录重复:

_      如果没 COMPARING 选项,则所外说明来规范要字段的始末交互同时。

_      如果有 COMPARING 选项…. COMPARING
<F1><F2> … 
,指定字段<F1><F2> … 的情节要一律才算是更。也足以经过描写入 (<name>) 代替<F1>在运作时当括号中动态指定字段名。如果<name>在运行时为空,则网以那个忽视。如果含有无效的零件名,则会发出实时错误。

_      如果用 COMPARING 选项…. COMPARING ALL
FIELDS 
,内表行所有字段的内容必须互相同时才总算还。

 

假设系统找到并删除至少一个再次条目,则以 SY-SUBRC 设置为0。否则,将那个安也4。

 

流淌,在非采取COMPARING 选项时,要去重复数据之前,一定要准内表的要字声明的一一来拓展排序,才会去重复数据,否则不见面去掉;如果指定了COMPARING 选项,则需要依据指定的较字段顺序进行排序(如COMPARING
<F1><F2>时,则要sort by
<F1><F2>,而非可知是sort by
<F2><F1>),才会去所有又数据。

 

DATA: BEGIN OF line,
        col1 TYPE i,
        col2 TYPE c,
      END OF line.
DATA itab LIKE line OCCURS 10.
line-col1 = 1. line-col2 = ‘A’. APPEND line TO itab.
line-col1 = 1. line-col2 = ‘A’. APPEND line TO itab.
line-col1 = 1. line-col2 = ‘B’. APPEND line TO itab.
line-col1 = 2. line-col2 = ‘B’. APPEND line TO itab.
line-col1 = 3. line-col2 = ‘B’. APPEND line TO itab.
line-col1 = 4. line-col2 = ‘B’. APPEND line TO itab.
line-col1 = 5. line-col2 = ‘A’. APPEND line TO itab.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.
“**所有字段相同时才好不容易还
DELETE ADJACENT DUPLICATES FROM itab COMPARING ALL FIELDS.
SKIP TO LINE 3.
LOOP AT itab INTO line.
  WRITE: /14 line-col1, line-col2.
ENDLOOP.
“**指定字段重复时
DELETE ADJACENT DUPLICATES FROM itab COMPARING col1.
SKIP TO LINE 3.
LOOP AT itab INTO line.
  WRITE: /28 line-col1, line-col2.
ENDLOOP.
“**根据说明要字段col2来判断是否又
DELETE ADJACENT DUPLICATES FROM itab.
SKIP TO LINE 3.
LOOP AT itab INTO line.
  WRITE: /42 line-col1, line-col2.
ENDLOOP.

         1 
A         1  A          1  A          1  A

         1 
A         1  B          2  B          2  B

         1 
B         2  B          3  B          5  A

         2 
B         3  B          4  B

         3 
B         4  B          5  A

         4 
B         5  A

         5 
A

LOOP在循环中处理行

LOOP AT
itab {INTO wa}|{ASSIGNING
<fs>
[CASTING]}|{REFERENCE INTO
dref}|{TRANSPORTING NO
FILDS}
[[USING KEY key_name|(name)] [FROM idx1] [TO idx2] [WHERE log_exp|(cond_syntax)]].

ENDLOOP.

 

FROM … TO: 只适用于标准表与排序表

WHERE …  : 适用于所有品类的内表

 

要是没有经过USING KEY选项之key_name,则循环读取的次第和申底品类相关:

l  标准表与排序表:会照primary table index索引的逐一一修一条之轮回,且当循环里SY-TABIX为即在处理行的索引号。

l  哈希表:由于表没有排序,所以照插入的依次来循环处理,注,此时SY-TABIX 总是0,如:

DATA: hash TYPE HASHED TABLE OF i WITH HEADER LINE WITH UNIQUE KEY TABLE_LINE.
INSERT 4 INTO TABLE hash.
INSERT 2 INTO TABLE hash.
INSERT 3 INTO TABLE hash.
INSERT 1 INTO TABLE hash.
LOOP AT  hash.
  WRITE:
/ sy-tabix, hash.
ENDLOOP.

         0          
4

         0          
2

         0          
3

         0          
1

 

足嵌套LOOP,当上或去某层LOOP时,SY-TABIX会根据在相应变更。在ENDLOOP后面,如果至少发生同一条数为拍卖,则SY-SUBRC 为0,否则也4。

 

如果循环的凡哈希表,则sy-tabix恒为0。

可以于循环内表时多及删除时执行:If you insert or delete
lines in the statement block of a LOOP ,
this will have the following effects:

  • If you insert lines behind(后面) the current line, these new
    lines will be processed in the subsequent loop(下一致蹩脚巡回) passes. An endless
    loop(可能会见唤起死循环) can
    result.
  • If you delete lines behind the current line, the deleted
    lines will no longer be processed in the subsequent loop
    passes.
  • If you insert lines in front of the current line, the
    internal loop counter is increased by one with each inserted line.
    This affects sy-tabix in the subsequent loop
    pass(这会潜移默化于继的循环过程SY-TABIX。).
  • If you delete lines in front of the current line, the
    internal loop counter is decreased by one with each deleted line.
    This affects sy-tabix in the subsequent loop
    pass.
SUM

要是于循环处理期间计算内表中数字字段的始末之与:

SUM.

系统只能在 LOOP – ENDLOOP 块中处理该语句。

若以 AT – ENDAT 块中使 SUM,则网计算时行组中所有实行的数字字段之与连以其描绘副工作区域受到相应的字段。

 

倘有内表行的机件是外一个表,则毫不以 SUM 语句。

DATA: BEGIN OF line,
         col1 TYPE i,
         col2 TYPE i,
      END OF line.
DATA itab LIKE line OCCURS 10.
DO 3 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  APPEND line TO itab.
ENDDO.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2.
  “统计后会将统计的结果临时存入工作区
  SUM.
  WRITE: / line-col1, line-col2.
ENDLOOP.
SKIP.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.

         1          
1

         6         
14

         2          
4

         6         
14

         3          
9

         6         
14

 

         1          
1

         2          
4

         3          
9

AT

AT <line>.

<statement
block>

ENDAT**.**

 

<line>

含义

FIRST

内表的第一行时触发

LAST

内表的最后一行时触发

NEW <f>

相邻数据行中相同<f>字段构成一组,在循环到该组的开头时触发

END Of <f>

相邻数据行中相同<f>字段构成一组,在循环到该组的最末时触发

 

当利用AT…… ENDAT之前,一当即只要事先随这些报告句被的组件名进行排序,且排序的逐条要跟以AT…… ENDAT语句被动用各个一致。并且排序和声明的次第决定了事先以哪个分组,接照再比如哪个进行分组,最后重复比如哪个进行分组,这和SQL中之Group By 的一一是千篇一律的意思。

 

用在AT……
ENDAT语句被的受的零件名非自然要是构造面临的主要字段,但这些字段一定要以出现在AT关键字后面的下各个以构造最前边进行宣示,且这些零件的宣示中莫克插入其他零件的扬言。如现亟待依照<f1>, <f2>,
….,多字段的相继来用于AT……
ENDAT语句子被,则率先需在组织面临本<f1>, <f2>,
….,多字段的依次以构造最前方都宣示,然后以<f1>, <f2>,
….,多配段来排序的,最后在循环中本如下的各个片题序(请留意在AT END
OF的次第与AT NEW 是反的):

LOOP AT <itab>.

AT FIRST. … ENDAT.

AT NEW <f1>. …… ENDAT.

AT NEW <f2>. …… ENDAT.

…….

<single line
processing>

…….

AT END OF
<f2>….
ENDAT.

AT END OF <f1>. … ENDAT.

AT LAST. …. ENDAT.

ENDLOOP.

<single line
processing>块专门为此来处理所有非分组字段。你可拍卖所有分组字段,但若出现时,请遵以上顺序来书写代码块。

 

可以使动态方式 (‘F1’) 来安字段名称。

 

========================================================

假使循环的内表不是自己定义的,有时无法以分组的字段按梯次声明在合,所以用团结实现这些功能,下面是和谐实现AT NEW与AT END OF(另一样便宜是在循环内表时可以使Where条件语句)(注:使用这种单纯需要以分组的各个排序即可,如一旦分成bukrs与bukrs anlkl两组时,需要依照BY bukrs
anlkl排序,而不能够是BYanlkl bukrs):

DATA: lp_bukrs TYPE bukrs, “上一行bukrs字段的值
     
lp_anlkl TYPE anlkl. “上一行anlkl字段的价值

“下面要按bukrs,bukrs
anlkl分成两组
SORT itab_data BY bukrs anlkl.
DATA: i_indx  TYPE i
.

DATA: lwa_data  Like itab_data 
LOOP AT itab_datawhere flg = **‘X**’.

i_indx  = sy-tabix.
  “**********AT NEW
对现阶段分组首行进行拍卖

IF  itab_data-bukrs <> lp_bukrs. “Bukrs组
     
“………
   
ENDIF.
   
IF  itab_data-bukrs <> lp_bukrs OR itab_data-anlkl <> lp_anlkl. “bukrs anlkl
分组
     
“………
   
ENDIF.
   
IF  itab_data-bukrs <> lp_bukrs OR itab_data-anlkl <> lp_anlkl OR  itab_data-.. <> lp_.. . “bukrs anlkl ..
分组
     
“………
   
ENDIF.

 
“**********一般说来循环处理
 
“………

 
“**********AT END OF
对目前分组末行进行拍卖 

 DATA :
l_nolast1,l_nolast12 .不是分组中极末行

 
此要要清一下,以防该代码直接写在表格程序的风波里,而休是Form里(直接在Report程序事件里时常,l_nolast1,l_nolast12以见面变成全局变量)
 
CLEAR:  l_nolast1,l_nolast12,l_nolast…
    DO.
     
i_indx  = i_indx  + 1.
     
READ TABLE
itab_data INTO lwa_data  INDEX  i_indx.”尝试读博下一行
     
IF sy-subrc <> 0.”当前执行都是内表中最终一行
       
EXIT.
       
“如果第一分组字段都出了转变,则象征当前行有着分组中之末尾执行
       
“注:即使出N
独分组,这里为无非待看清第一分组字段是否发生变化,不
       
“需要对任何分组进行判定,即这里不欲丰富任何 ELSEIF
分支
     
ELSEIF lwa_data-bukrs <> itab_data-bukrs.
       
EXIT.
     
ENDIF.
********判断满足条件的产一致履行不是分组最的一条龙
     
“如果Loop循环中从未Where条件,则可以以下条件 lwa_data-flg =
‘X’ 删除即可
     
IF sy-subrc = 0 AND lwa_data-flg = ‘X’ .
       
IF lwa_data-bukrs = itab_data-bukrs .”判断当前实践是不是是 bukrs
分组最后执行
         
l_nolast1 = ‘1’.
         
IF lwa_data-nanlkl = itab_data-nanlkl .”判断当前实行是不是是 bukrs nanlkl
分组最后执行
           
l_nolast2 = ‘1’.
           
IF lwa_data-.. = itab_data-…”判断当前履行是不是是 bukrs nanlkl
..分组最后执行
             
l_nolast.. = ‘1’.
           
ENDIF.
         
ENDIF.
         
EXIT.”只要上至者句所在外层If,表示找到了相同长达满Where条件的生一行数,因此,只要找到这样的数目就是足以判明时分组是否已终结,即如果找到这么的多少就不要再行向后头找了,则脱离以防继续朝生搜寻
       
ENDIF.
     
ENDIF.

  
 ENDDO.

 

   IF l_nolast..IS INITIAL”处理 bukrs nanlkl
..分组
     
……
    ENDIF.

    IF l_nolast2 IS INITIAL
.”处理 bukrs nanlkl
分组
     
……
    ENDIF.
   
IF l_nolast1 IS INITIAL
.”处理 bukrs
分组
     
……
    ENDIF.

  lp_bukrs
= itab_data-bukrs.
 
lp_anlkl = itab_data-anlkl.

lp_.. = itab_data-.. .
ENDLOOP.

========================================================

 

 

若果上到 AT…<f1>…ENDAT 块中时时,当前工作区(或表头)中的从<f1>往后,但非包<f1>(按照在组织被扬言的次序)所有字段的字符类型字段会以星号(*)号来填充,而数字字设置为初始值(注:在测试过程中发现String类型不见面下*来填充,而是设置成empty
String,所以只有稳长度类型的非数字基本类型才装也*)。如果当 AT 块中动用了SUM,则会用富有数字型字段统计出用存入当前工作区(或表头);但若偏离AT….ENDAT块后,又见面以手上遍历的推行恢复至工作区(或表头)中。

 

以出口时最好以祭在AT……ENDAT语句子被之字段输出在最前面,并且以在这些话语的采用各个来挨家挨户输出,而另字段放在后面进行输出。

 

DATA: BEGIN OF
line,
      C2、C3组件称为声明的逐一一定要同于AT……
ENDAT块中运用的顺序一致,即这里不可知将C3声明在C2之前,且不能够于C2以及C3之间插入其他字段的声明
      c2(5) TYPE c,
      c3(5) TYPE c,
      c4(5) TYPE c,
      i1 TYPE i,
      i2 TYPE i,
      c1(5) TYPE c,
      END OF
line.

应用在AT……
ENDAT语句被之字段不自然要是是重大字段
DATA: itab LIKE TABLE OF line WITH HEADER LINE WITH
NON-UNIQUE KEY i1.
PERFORM append USING 2 ‘b’ ‘bb’ ‘bbb’ ‘2222’

  1. PERFORM append USING 3 ‘c’ ‘aa’ ‘aaa’ ‘3333’
  2. PERFORM append USING 4 ‘d’ ‘aa’ ‘bbb’ ‘4444’
  3. PERFORM append USING 5 ‘e’ ‘bb’ ‘aaa’ ‘5555’
  4. PERFORM append USING 6 ‘f’ ‘bb’ ‘bbb’ ‘6666’
  5. PERFORM append USING 7 ‘g’ ‘aa’ ‘aaa’ ‘7777’
  6. PERFORM append USING 8 ‘h’ ‘aa’ ‘bbb’ ‘8888’
  7. SORT itab ASCENDING BY c2 c3.
    LOOP AT itab.
      WRITE: / itab-c2,itab-c3,itab-c1,itab-c4,itab-i1,itab-i2.
    ENDLOOP.
    SKIP.
    LOOP AT itab.
      AT FIRST.
        WRITE:/ ‘>>>> AT FIRST’.
      ENDAT.

  AT NEW c2.
    WRITE: / ‘    >>>> Start of’
,
itab-c2.
  ENDAT.

  AT NEW c3.
    WRITE: / ‘        >>>> Start of’
,
itab-c2,
itab-c3.
  ENDAT.
  就如一致来 AT
块,则表头的多寡而会卷土重来成时受全部历行的内容
 
WRITE: / itab-c2,itab-c3,itab-c1,itab-c4,itab-i1,itab-i2.
  AT END OF c3.
    SUM.
    WRITE: / itab-c2,itab-c3,itab-c1,itab-c4,itab-i1,itab-i2.
    WRITE: / ‘        <<<< End of’
,
itab-c2,
itab-c3.
  ENDAT.

  AT END OF c2.
    SUM.
    WRITE: / itab-c2,itab-c3,itab-c1,itab-c4,itab-i1,itab-i2.
    WRITE: / ‘    <<<< End of’
,
itab-c2.
  ENDAT.
  AT LAST.
    SUM.
    WRITE: / itab-c2,itab-c3,itab-c1,itab-c4,itab-i1,itab-i2.
    WRITE:/ ‘<<<< AT LAST’.
  ENDAT.
ENDLOOP.

TYPES: c5(5) TYPE c.
FORM append  USING    value(p_i1) TYPE i
                     
value(p_c1) TYPE c5
                      value(p_c2) TYPE c5
                      value(p_c3) TYPE c5
                      value(p_c4) TYPE c5
                      value(p_i2) TYPE i.
  itab-i1 = p_i1.
  itab-c1 = p_c1.
  itab-c2 = p_c2.
  itab-c3 = p_c3.
  itab-c4 = p_c4.
  itab-i2 = p_i2.
  APPEND itab.
ENDFORM.

aa    aaa   c    
3333           3          33

aa    aaa   g    
7777           7          77

aa    bbb   d    
4444           4          44

aa    bbb   h    
8888           8          88

bb    aaa   a    
1111           1          11

bb    aaa   e    
5555           5          55

bb    bbb   b    
2222           2          22

bb    bbb   f    
6666           6          66

 

>>>>
AT FIRST

>>>>
Start of aa

>>>>
Start of aa    aaa

aa    aaa   c    
3333           3          33

aa    aaa   g    
7777           7          77

aa    aaa  
***** *****          10         110

<<<<
End of aa    aaa

>>>>
Start of aa    bbb

aa    bbb   d    
4444           4          44

aa    bbb   h    
8888           8          88

aa    bbb  
***** *****          12         132

<<<<
End of aa    bbb

aa    *****
***** *****           22         242

<<<<
End of aa

>>>>
Start of bb

>>>>
Start of bb    aaa

bb    aaa   a    
1111           1          11

bb    aaa   e    
5555           5          55

bb    aaa  
***** *****           6          66

<<<<
End of bb    aaa

>>>>
Start of bb    bbb

bb    bbb   b    
2222           2          22

bb    bbb   f    
6666            6          66

bb    bbb  
***** *****           8          88

<<<<
End of bb    bbb

bb    *****
***** *****           14         154

<<<<
End of bb

*****
***** ***** *****            36        
396

<<<<
AT LAST

 

 

  DATA: BEGIN OF th_mseg OCCURS 10,
      matnr TYPE mard-matnr,
      werks TYPE mard-werks,
      lgort TYPE mard-lgort,
      shkzg TYPE mseg-shkzg,
      menge TYPE mseg-menge,
      budat TYPE mkpf-budat,
LOOP AT th_mseg.
  AT END OF shkzg.
    sum.
    WRITE: / th_mseg-matnr, th_mseg-werks,th_mseg-lgort,
             th_mseg-shkzg,th_mseg-menge,th_mseg-budat.
  ENDAT.
ENDLOOP.

AS-101            
2300 0001 S           10.000  ****.**.**

AS-100            
2300 0002 S           10.000  ****.**.**

AS-100            
2300 0001 S           20.000  ****.**.**

wwwlehu6.vip乐虎官网 10

此外,其实这个统计和SQL里的分组(Group By)统计原理是同的,Group By 后面要明白指定分组的字段,如上面程序采取SQL分组写法应该也 Group By matnr werks lgort
shkzg,但当ABAP里而就待以matnr werks lgort
shkzg按照先后顺序在组织定义之极致前方进行宣示就只是发挥了Group
By那种意义,而且无自然要是拿matnr werks lgort
shkzg这四个字段全部据此当AT语句块被AT
NEW、AT END OF
shkzg才对,其实像面程序一样,只写AT END OF
shkzg这一个说话,前面三个字段matnr werks
lgort都得以无用在AT语句被起,因为ABAP默认会按照在构造被声明的顺序以shkzg前面的字段也统统用当了分组意义当中了。

适用索引表的行操作

随即同一节中兼有操作才适用于索引表(标准表与排序表)

APPEND 附加行

APPEND wa|{INITIAL
LINE} |
{LINES OF jtab [FROM
idx1] [TO
idx2]
[USING KEY
key_name|(name)]}
       TO itab
[SORTED BY
comp]
[{ ASSIGNING <fs>
[CASTING] } | { REFERENCE INTO
dref
}]

 

l  APPEND/INSERT操作不克用于Hash表

l  APPEND/INSERT用于排序表时条件:附加/插入时必定要按部就班Key的升序来附加;如果是Unique排序表,则非能够附加/插入重附的多寡,就跟INSERT…INTO
TABLE是未均等的

外加单行

APPEND  {<wa>|INITIAL LINE} [TO
<itab>].

 

SY-TABIX存储了附加行所当的索引号。

假使itab带有表头,则可大概TO
<itab>选项,直接以 APPEND<itab>

 

 

DATA: BEGIN OF line1,
col1(3) TYPE c,
col2(2) TYPE n,
col3 TYPE i,
END OF line1,
tab1 LIKE TABLE OF line1.

DATA: BEGIN OF line2,
field1(1) TYPE c,
field2
LIKE tab1,“**嵌套内表**
END OF
line2,
tab2 LIKE TABLE OF line2.

line1-col1 = ‘abc’. line1-col2 = ’12’. line1-col3 = 3.
APPEND line1 TO tab1.
line1-col1 = ‘def’. line1-col2 = ’34’. line1-col3 = 5.
APPEND line1 TO tab1.
line2-field1 = ‘A’. line2-field2 = tab1.
APPEND line2 TO tab2.

REFRESH tab1.
line1-col1 = ‘ghi’. line1-col2 = ’56’. line1-col3 = 7.
APPEND line1 TO tab1.
line1-col1 = ‘jkl’. line1-col2 = ’78’. line1-col3 = 9.
APPEND line1 TO tab1.
line2-field1 = ‘B’. line2-field2 = tab1.
APPEND line2 TO tab2.
LOOP AT tab2 INTO line2.
  WRITE: / line2-field1.
  LOOP AT line2-field2 INTO line1.
    WRITE: /2 line1-col1, line1-col2, line1-col3.
  ENDLOOP.
ENDLOOP.

A

abc 12         
3

def 34         
5

B

ghi 56         
7

jkl 78         
9

叠加多行FROM… TO

APPENDLINESOF<itab1> [FROM<n1>]
[TO<n2>] TO<itab2>.

若简单 FROM 或 TO ,则<itab1>可以是随便档次的阐明,但行类型要与<itab2>兼容,且<itab2>只能是索引表;如果没简单,则<itab1>只能是摸索引类型的内表(索引表、标准表)

拖欠办法较在循环中一行行附加要尽早3至4加倍。语句运行了晚,SY-TABIX存储了最后一个附加行所于的目。与单选一样,对于排序表,不克违反唯一约束(唯一索引排序表)与升序排序规则,否则运行时见面报错。

DATA: BEGIN OF line,
col1 TYPE c,
col2 TYPE i,
END OF line.
DATA: itab LIKE TABLE OF line,
jtab LIKE itab.
DO 3 TIMES.
  line-col1 = sy-index. line-col2 = sy-index ** 2.
  APPEND line TO itab.
  line-col1 = sy-index. line-col2 = sy-index ** 3.
  APPEND line TO jtab.
ENDDO.
APPEND LINES OF jtab FROM 2 TO 3 TO itab.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.

1         
1

2         
4

3         
9

2         
8

3        
27

因为排序方式附加

APPEND <wa> TO <itab> SORTED BY
<f>.

当朝着内表加入数据时会因<f>的降序位置来插入到相应岗位,不自然是终极位置。注,不可知指定排序方式,默认就是降序,另外不克指定多独字段。而且该选项就称给标准表,不能够用于排序表。

 

鉴于效率方面的原因,建议用 SORT 语词针对表进行排序。

DATA: BEGIN OF itab OCCURS 2,
         column1 TYPE i,
         column2 TYPE i,
         column3 TYPE i,
       END OF itab.
itab-column1 = 1. itab-column2 = 2. itab-column3 = 3.
APPEND itab SORTED BY column2.
itab-column1 = 4. itab-column2 = 5. itab-column3 = 6.
APPEND itab SORTED BY column2.
itab-column1 = 7. itab-column2 = 8. itab-column3 = 9.
APPEND itab SORTED BY column2.
LOOP AT itab.
  WRITE: / itab-column2.
ENDLOOP.

        
8

        
5

一旦使用 SORTED BY 选项,表格只能分包 OCCURS 参数中指定的行数。如果长的行数比指定的只要多,则抛最后一实行(这对于开创限定长度的排序列表非常有因此,比如取最好可怜前十长长的记下)。

APPEND …SORTED BY…

APPEND <wa>TO <itab> SORTED
BY <f>.

该语句只适用于standard table。新附加行不一定会附加到内表<itab>的尾巴,在插入的常会指向字段<f>进行较(采用降序比较)找到插入位置,将超过n(n为内表定义语句被的INITIAL SIZE 选项中所指定的n)行之外的最后一实施去,只保留前n漫长记下。

流淌:此种APPEND只适用于正规内表。一种植用来取前n条应用(根据字段<f>进行降序排序),在概念内表<itab>时,应在INITIAL SIZE 选项中指定所获的前n漫长的值,并且以采取过程,不要和APPEND <wa> TO
<itab>混用,并且于应用前,<itab>需要为空,否则会混杂。

DATA: BEGIN OF
line,
  col1 TYPE i,
  col2 TYPE i,
END
OF line.
“这里的2针对后面的APPEND语句产生震慑:保留前2称为的记录
DATA itab LIKE TABLE OF line INITIAL
SIZE 2.
line-col1 = 1. line-col2 = 2.
APPEND line TO
itab SORTED BY col2 .
LOOP AT itab INTO line.
  WRITE: / line-col2.
ENDLOOP.
SKIP.
line-col1 = 3. line-col2 = 4.
APPEND line TO
itab SORTED BY col2.
LOOP AT itab INTO line.
  WRITE: / line-col2.
ENDLOOP.
SKIP.
line-col1 = 5. line-col2 = 6.
APPEND line TO
itab SORTED BY col2.
LOOP AT itab INTO line.
  WRITE: / line-col2.
ENDLOOP.

wwwlehu6.vip乐虎官网 11

USING KEY 

 

TYPES:BEGIN OF tab_type ,
    a TYPE i,
    b TYPE i,
    c TYPE i,
    d TYPE i,
    e TYPE i,
  END OF  tab_type .

DATA
itab
      TYPE STANDARD TABLE  OF
tab_type
      WITH NON-UNIQUE KEY
primary_key COMPONENTS a
      WITH UNIQUE HASHED KEY
hash_key COMPONENTS b
      WITH NON-UNIQUE SORTED KEY
sort_key COMPONENTS c
      WITH HEADER
LINE.

DATA itab2 LIKE itab[] WITH HEADER
LINE.

itab-a = 3.itab-b = 5.itab-c = 5.itab-d = 6.itab-e = 1.
APPEND itab.
itab-a = 6.itab-b = 8.itab-c = 4.itab-d = 1.itab-e = 2.
APPEND itab.
itab-a = 1.itab-b = 3.itab-c = 2.itab-d = 4.itab-e = 3.
APPEND itab.
itab-a = 4.itab-b = 7.itab-c = 6.itab-d = 1.itab-e = 4.
APPEND itab.

APPEND LINES OF
itab FROM 2 to 3  USING KEY 
primary_key to itab2.
LOOP AT itab2.
  WRITE: itab2-a.
ENDLOOP.
CLEAR: itab2[].

NEW-LINE.
以次招来引sort_key的排序方式(升序),取index 2
到 3
的记录,并附加到
itab2吃
APPEND LINES OF itab FROM 2 to 3  **USING
KEY** sort_key to itab2.
LOOP AT itab2.
  WRITE: itab2-a.
ENDLOOP.

“下面告诉句出错:
hash
key不支持之种用法,原因是 hash
本身并未索引概念可言
APPEND LINES OF itab FROM 2
to 3  USING KEY hash_key to itab2.

 

6          
1

        
6           3

 

INSERT插入到指定的目位置

INSERT wa|{INITIAL
LINE}|{LINES OF jtab [FROM
idx1] [TO
idx2]
[USING KEY
key_name|(name)]} 
INTO
{itab INDEX
idx}|{itab} 
{ ASSIGNING <fs>
[CASTING] }|{ REFERENCE INTO
dref }.

栽单行

INSERT {<wa>|INITIALLINE}  INTO <itab> [INDEX
<idx>].

 

苟不使 INDEX 选项,则以新的行插入到当下实施之前(索引为当下行索引),则当前行及后面的所有行的目都见面向后更换一个位置,且索引会自动加1。

 

设若itab是带动表头的索引类型内表,可以简单INTO
<itab>、INDEX <idx>选项,直接以INSERT<itab>,但这个报句只可在LOOP AT
<itab>(此时匪克利用USING KEY选项)循环中一直采用(这跟APPEND不顶相同,APPEND没有这样的限量),并且新栽的行会放在眼前循环行的前头

 

要使用 INDEX 选项,则将新行插入到有索引<idx>的行之前。插入后,新条目索引为<idx>,后面所有行索引加 1(注:插入操作不影响时正值循环的SY-TABIX原有的值)。如果表格包含<idx> – 1 条条框框,系统将新条令附加到最终的共处表格行之后。如果表格的条规小于<idx> –
1,系统无法插入条目并拿 SY-SUBRC 设置为4。

 

但会在 LOOP – ENDLOOP 循环,可以概括 INDEX 选项,表示在当下循环行前插入新行(此时<idx>隐含设置成SY-TABIX),下次巡回还是碰头于当前循环行的下一行开始拍卖,即非会见潜移默化循环,但于插入的行不会被循环到了。

 

未克向 unique 排序表中插入重复值,另外为排序表中插入值时莫克背排序表的默认排序规则,否则运行时错。

 

 

巡回中插或删除行:

DATA: BEGIN OF line,
         col1 TYPE i,
         col2 TYPE i,
      END OF line.
DATA itab LIKE line OCCURS 10.
DO 2 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  APPEND line TO itab.
ENDDO.
“在循环中插行后,下次循环的行还是脚下履行的后行,循环连续的,但索引号增1了
LOOP AT itab INTO line.
  WRITE: / sy-tabix.
  line-col1 = 3 * sy-tabix. line-col2 = 5 * sy-tabix.
  INSERT line INTO itab.”未指定INDEX选项,所以当当下行前安插
  WRITE: sy-tabix.
ENDLOOP.
LOOP AT itab INTO line.
  WRITE: / sy-tabix, line-col1, line-col2.
ENDLOOP.
SKIP.
LOOP AT itab INTO line.
 
“会去除所有索引大于1之数据实行,删除后下次循环的目还是与上次平
 
IF sy-tabix > 1.
    DELETE itab INDEX sy-tabix.
  ENDIF.
ENDLOOP.
LOOP AT itab INTO line.
  WRITE: / sy-tabix, line-col1, line-col2.
ENDLOOP.

        
1           1

        
3           3

        
1           3           5

        
2           1           1

        
3           9          15

        
4           2           4

 

        
1           3           5

安插多行FROM…TO

INSERT LINES OF <itab1> [FROM
<n1>] [TO <n2>] INTO <itab2>
[INDEX <idx>].

要是简单 FROM 或 TO ,则<itab1>可以是随便档次的表,但行类型要和<itab2>兼容;如果没简单,则<itab1>只能是寻找引类型的内表(索引表、标准表)。

依让数据量与插入的职,这种插入比在循环中一条条安插要抢。

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA: itab LIKE TABLE OF line,
jtab LIKE itab.
DO 3 TIMES.
  line-col1 = sy-index. line-col2 = sy-index ** 2.
  APPEND line TO itab.
  line-col1 = sy-index. line-col2 = sy-index ** 3.
  APPEND line TO jtab.
ENDDO.
INSERT lines of itab FROM 2 TO 3 INTO jtab INDEX 1.
LOOP AT jtab INTO line.
  WRITE: / sy-tabix, line-col1, line-col2.
ENDLOOP.

        
1           2           4

        
2           3           9

        
3           1           1

        
4           2           8

        
5           3          27

READ读取指定索引位置上的履行

READ TABLE极致全语法规虽说明央参考这里

READ TABLE <itab> INDEX
<idx> <result>.

<result>请参考这里。该语句只见面宣读取<idx>所在位置的执行,只会读取一行,这与行使 key 为规范来读取是相同的(以key为条件读取时可能会见现出多长长的,但才获得第一长条)。

 

根据索引来读取数据要于使用Key来读取行速度要赶紧。

 

此的TABLE关键字不能够简单,这跟DELETE、MODIFY些微单根本字勿太一样,这有限个举足轻重字在针对包含表头的索引类型内表进行操作时,语句中没TABLE关键字。

足简单INDEX
<idx>选项,直接用READ TABLE
<itab>,此时会面默认从 itab 内表的表头<wa>作为规范,此时说话即为简易了FROM
<wa>选项之READ TABLE
<itab> FROM <wa>语句。如果<wa>中相应的根本字段为空,则会配合有记录,如果所有重点字段为空,则直读取第一行数据

 

只要找到数据行则SY-SUBRC为0,且SY-TABIX存储时找到的多寡行索引,如果无找到,则SY-SUBRC为非0。

 

DATA: BEGIN OF line,
  col1 TYPE i,
  col2 TYPE i,
END OF line.
DATA itab LIKE SORTED TABLE OF line WITH UNIQUE KEY col1.
FIELD-SYMBOLS <fs> LIKE LINE OF itab.
DO 20 TIMES.
  line-col1 = sy-index.
  line-col2 = 2 * sy-index.
  APPEND line TO itab.
ENDDO.
READ TABLE itab INDEX 7 ASSIGNING <fs> .
WRITE:/ sy-subrc, sy-tabix.
WRITE: / <fs>-col1,
<fs>-col2.

  0          
7

        
7          14

当索引表中展开第二分割查找

READ TABLE <itab> WITH KEY =
<f><result>BINARY SEARCH.

READ TABLE <itab> WITH KEY <k1> =
<f1> … <kn> = <fn>
<result>

BINARY SEARCH.

 

BINARY SEARCH选项只能于以key方式读取的语句,不克坐index方式读取。

 

万一是为key的措施读取标准表时,可以用二分效仿搜索代替顺序搜索,但对标准表,必须事先接照查找的主要字展开升序排序继有义。

 

对排序表,使用key进行读取行时,不欲先以Sort关键字展开排序(也未能够针对排序表再进行排序,否则会拧),但于READ语句子被得以动用BINARY
SEARCH
选项。

 

除此以外,哈希表,则不能够采用二分割查找选项BINARY SEARCH(原因可以是哈希比亚分叉查找要尽快吧),但能够用SORT语句子针对Hash表进行排序,而且富有排序效果(这个比奇怪,有接触像Java的Treemap集合了):

TYPES: BEGIN OF line,
    i TYPE i,
  END OF line.
DATA: itab TYPE HASHED TABLE OF line WITH HEADER LINE WITH UNIQUE KEY i.
itab-i = 1.
INSERT  itab INTO TABLE itab.
itab-i = 2.
INSERT  itab INTO TABLE itab.
LOOP AT  itab .
  WRITE: / itab-i.
ENDLOOP.
可本着Hash表进行排序
SORT itab DESCENDING.
SKIP.
LOOP AT  itab .
  WRITE: / itab-i.
ENDLOOP.
“但切莫能够应用BINARY SEARCH选项
*READ TABLE itab WITH TABLE
KEY i = 2 BINARY SEARCH.

        
1

        
2

 

        
2

        
1

 

 

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE STANDARD TABLE OF line.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  APPEND line TO itab.
ENDDO.
“注:二分叉查找时不得不是准升序排序
*SORT itab BY col2
DESCENDING.
SORT itab BY col2.”默认就是升序
READ TABLE itab WITH KEY col2 = 16 INTO line BINARY SEARCH.
WRITE: ‘SY-SUBRC =’,
sy-subrc.

SY-SUBRC =    
0

以内表中找找字符串

SEARCH <itab> FOR
<str><options>.

拿会招来整个内表行,如果找到,SY-SUBRC为0,SY-TABIX存储找到的字符串所于行索引,SY-FDPOS存储了所查看找到的字符串位置在内表行内(前面所有字段都见面算在里面)的职务,具体算法请参见Search搜索字符串。

 

各个字段只能是C、N、D、T固定长度的字符类型字段(书上说其他项目且可能,但试了瞬间String类型也酷)。<str>支持之模式以及<options>选项可以参见Search搜索字符串。

 

DATA: BEGIN OF line,
  index(2) TYPE n,
  text(10) TYPE c,
END OF line.
DATA itab LIKE SORTED TABLE OF line WITH UNIQUE KEY index.
DATA num(2) TYPE n.
DO 3 TIMES.
  line-index = sy-index.
  num = sy-index.
  CONCATENATE ‘aastring’ num INTO line-text.
  APPEND line TO itab.
ENDDO.

LOOP AT itab INTO line.
  WRITE: / line-index,line-text.
ENDLOOP.
SEARCH itab FOR ‘string02’ AND MARK.
READ TABLE itab INTO line INDEX sy-tabix.
WRITE: / sy-subrc,sy-fdpos,line-index,line-text.

01
aastring01

02
aastring02

03
aastring03

    0      4  02
aaSTRING02

一经将方index字段声明在text字段后面,则上面的sy-fdpos的结果虽然为2。

MODIFY修改指定索引位置上之执行

MODIFY

{ TABLE
itab
[USING
KEY key_name|(name)] | {itab INDEX idx [USING KEY key_name|(name)]} | {itab [USING KEY
loop_key]} } FROM
wa
[TRANSPORTINGcomp1 comp2…] [{ASSIGNING <fs> [CASTING]} | {REFERENCE INTO
dref}]
|itab FROM wa [USING KEY key_name|(name)] TRANSPORTING
comp1 comp2… WHERE log_exp|(cond_syntax) }.

 

comp1
comp2
 …
… { comp_name[-sub_comp][{+off(len)}|{->attr}] }
| {(name)} …

改单行

MODIFY<itab>[INDEX<idx>] FROM<wa>[TRANSPORTING<f1><f2>
… ].

 

假定没有 INDEX 选项,你只能当循环中采取该语句,在这个种植情形下,每次循环中<idx>会默认设置为SY-TABIX,即当前遍历的号行。

 

若改动的标准表,则重要字段是可以为改动的。

 

 

当修改的凡排序表时,你无能够将第一字段修改成其他价值,否则运行时错。在改排序表时,如果没有采取TRANSPORTING选项,则<wa>的key字段必须同如改的行key字段值相同;如果指定了TRANSPORTING选项,则该选择后面不能够对接key字段,但这时<wa>中之key字段会忽略掉(此时是不是跟修改的行key字段相同没有干了)。

 

<fi>支持动态名称。

DATA: scarr_tab TYPE SORTED TABLE OF
scarr
               WITH UNIQUE KEY
carrid,
      scarr_wa
TYPE scarr.
scarr_wa-currcode = ‘EUR’.
SELECT * FROM scarr INTO TABLE
scarr_tab.
READ TABLE
scarr_tab WITH TABLE KEY
carrid = ‘xxx’ TRANSPORTING NO
FIELDS.
MODIFY scarr_tab INDEX sy-tabix FROM scarr_wa TRANSPORTING
currcode.

改时循环行…USING KEY loop_key…

MODIFY itab [USINGKEY loop_key] FROM<wa>

此语句只能用当LOOP AT内表循环语句被,并且这 USING KEY
loop_key 选项也堪略(其实默认就是简约的),其中 loop_key 是预定义的,不可知转:

 

LOOP
AT scarr_tab INTO scarr_wa.

MODIFY scarr_tab USING
KEYloop_keyFROM scarr_wa.

ENDLOOP.

使<itab>是含有表头的内表,则可以直接下MODIFY
<itab>语句,且这语句只适用于LOOP AT循环语句被

 

TYPES: BEGIN OF line ,
  key ,
  val TYPE i ,
  END OF line .
DATA: itab1 TYPE line OCCURS 0 WITH HEADER LINE
.
DATA: itab2 TYPE line OCCURS 0 WITH HEADER LINE
.
itab1-key = ‘a’.
itab1-val = 1.
APPEND itab1.
itab1-key = ‘b’.
itab1-val = 2.
APPEND itab1.
itab2-key = ‘A’.
itab2-val = 0.
APPEND itab2.
LOOP AT itab1.
  WRITE: / ‘itab1 index: ‘ , sy-tabix.
  READ TABLE itab2 INDEX 1 TRANSPORTING NO FIELDS.
  WRITE: / ‘itab2 index: ‘, sy-tabix.
  itab1-val = itab1-val + 1.
  “在循环中好运用下简洁方式来窜内表,修改的内表行为时正巧让循环的履行,即使循环中采用了READ
TABLE语词
  “读取了其他内表而导致了sy-tabix
发生了变更,因为以下语句不是因sy-tabix来窜的(如果也寻引内表时,使用MODIFY itab1 INDEX
sy-tabix语句进行改动时,反而不科学 。而且该语句还适用于Hash内表,需于MODIFY后面长TABLE根本字后再适用于Hash表)
  MODIFY itab1.
ENDLOOP.
LOOP AT itab1.
  WRITE:/ itab1-key, itab1-val .
ENDLOOP.
WRITE:/ itab2-key, itab2-val .

itab1
index:           1

itab2
index:           1

itab1
index:           2

itab2
index:           1

a         
2

b         
3

A         
0

 

 

下WRITE TO进行改动

WRITE <f> TO <itab> INDEX
<idx>.

<itab>必须只能是标准表,且<itab>的行字段都是使是C、N、D、T类型的字段,否则编译出错。

 

当改动时,<itab>需要采用偏移量的方式来定位要改的内容,可以参见

 

DATA: BEGIN OF line,
      c ,
      text(72),
 END OF line.
DATA code LIKE  TABLE OF line WITH HEADER LINE WITH NON-UNIQUE KEY c.
code-c = ‘a’.
code-text = ‘This is the first
line.’.
APPEND code.
code-c = ‘b’.
code-text = ‘This is the second line. It is
ugly.’.
APPEND code.
code-c = ‘c’.
code-text = ‘This is the third and final
line.’.
APPEND code.
“**偏移量是赖当一切行所有字段组成的字符串的偏移量,这里连了面前 c
字段

WRITE ‘
NIC.’ TO code+31 INDEX 2.
LOOP AT code .
  WRITE: / code-c , code-text.
ENDLOOP.

a This is the
first line.

b This is the
second line. It is NIC.

c This is the
third and final line.

DELETE删除指定索引位置上之履

DELETE { {TABLEitab {FROM wa [USING KEY key_name|(name)]} | {WITH TABLE
KEY [key_name|(name) COMPONENTS] {comp_name1|(name1)}=dobj1 {comp_name2|(name2)}=dobj2…}} | {itab INDEX idx [USING KEY key_name|(name)]} | {itab [USING KEY
loop_key]}
| itab [USING KEY key_name|(name)] [FROM idx1] [TO
idx2] [WHERE log_exp|(cond_syntax)]
| ADJACENT DUPLICATES
FROM itab [USING KEY key_name|(name)] [COMPARING {comp1
comp2
 …}|{ALL FIELDS}]…
}

 

comp1
comp2
 …
… { comp_name[-sub_comp][{+off(len)}|{->attr}] }
| {(name)} …

剔除单行

DELETE<itab>
[INDEX<idx>].

使省略<index>选项,则DELETE
<itab>语句只能用当循环语句被。被去除行后所有行的索引号都用减一。

巡回中剔除行…USING KEY loop_key…

DELETE itab [USINGKEY loop_key]

此语句只能用当LOOP AT内表循环语句被,并且这 USING KEY
loop_key 选项也可简简单单(其实默认就是略的),其中 loop_key 是预定义的,不可知改变:

 

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE SORTED TABLE OF line WITH UNIQUE KEY
col1.
DO 5 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  APPEND line TO itab.
ENDDO.
“删除索引号为3的行实质齐抹的凡原索引号为4底执行,
“删除索引号为4之新型会败,因为此时独自来3行数据了
DELETE itab INDEX: 2, 3, 4.
WRITE: ‘SY-SUBRC =’, sy-subrc.
SKIP.
LOOP AT itab INTO line.
  WRITE: / sy-tabix, line-col1, line-col2.
ENDLOOP.

SY-SUBRC
=     4

        
1           1           1

        
2           3           9

        
3           5          25

 

 

DATA: BEGIN OF
line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE TABLE OF line.
DO 5 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  APPEND line TO itab.
ENDDO.
LOOP AT itab INTO line.
  IF line-col1 < 4.
    “在循环中可连接去
    DELETE itab.
 
ENDIF.
ENDLOOP.
LOOP AT itab INTO line.
  WRITE: / sy-tabix, line-col1, line-col2.
ENDLOOP.

        
1           4          16

        
2           5          25

 

 

 

DATA: itab TYPE TABLE OF i WITH HEADER
LINE.
APPEND 1 TO itab.
APPEND 2 TO itab.
APPEND 3 TO itab.
APPEND 4 TO itab.
APPEND 5 TO itab.

LOOP AT itab.”循环内表本身可以循环去所有,但下的标准是单去2、3、5的笔录
  IF itab = 2 OR itab = 3 OR itab = 5.
    DELETE itabindex sy-tabix.“index
sy-tabix**可以省

  ENDIF.
ENDLOOP.
LOOP AT  itab.
  WRITE: / itab.
ENDLOOP.
FREE itab.

APPEND 1 TO itab.
APPEND 2 TO itab.
APPEND 3 TO itab.
APPEND 4 TO itab.
APPEND 5 TO itab.
DO 5 TIMES.由此DO xx
TIMES方式不克循环去所有
  DELETE itab INDEX sy-index.
ENDDO.
WRITE:/.
LOOP AT  itab.
  WRITE: / itab.
ENDLOOP.

FREE itab.

APPEND 1 TO itab.
APPEND 2 TO itab.
APPEND 3 TO itab.
APPEND 4 TO itab.
APPEND 5 TO itab.
DO 5 TIMES.这么吗可以去除所有执行
  DELETE itab INDEX 1.
ENDDO.
WRITE:/.
LOOP AT  itab.
  WRITE: / itab.
ENDLOOP.

1

        
4

 

        
2

        
4

去除多行

DELETE<itab> [FROM<n1>]
[TO<n2>]
[WHERE<condition>].

单少而指定一个尺度。

If at least one line is deleted, the system
sets SY-SUBRC to 0, otherwise to 4.

 

如果没有使用USING
KEY选项,或者keyname指定为primary table
key,则选择项FROM … TO 只能用在 index tables 类型的内表,在斯种状态下,FROM … TO 中指定的行索引值为primary table
index 。

假设经过USING
KEY选项中keyname设置为sorted secondary
key,则FROM …
TO可以使用到Hash内表,在斯种植状态下,FROM … TO 中指定的行索引值为secondary table
index 。

 

 

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE TABLE OF line.
DO 8 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  APPEND line TO itab.
ENDDO.
“删除索引为3暨7的履行,且删除条件是col2不止等于25
DELETE itab FROM 3 TO 7 WHERE col2 >= 25.
LOOP AT itab INTO line.
  WRITE: / line-col1, line-col2.
ENDLOOP.

        
1           1

        
2           4

        
3           9

        
4          16

        
8          64

以循环使用FROM…TO限制行的读取范围

LOOP AT <itab><result> [FROM
<n1>] [TO <n2>]
<condition>.

<statement block>

ENDLOOP.

 

巡回处理的过程以及 LOOP以循环中处理行是平的

 

以动用FROM或WHERE筛选行时,循环中使用控制主要字 AT (如,AT first)有或无会见做事,原因是接触的行被筛选掉了。

 

FROM 和 TO 选项限制系统要读取的行数。WHERE 选项还是会遍历整个内表来抉择合适的履,为了提高效率,应该尽量采取 FROM 和 TO 选项先行来界定读取的限制。

DATA: BEGIN OF line,
col1 TYPE i,
col2 TYPE i,
END OF line.
DATA itab LIKE SORTED TABLE OF line WITH UNIQUE KEY
TABLE
LINE.
DO 10 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  APPEND line TO itab.
ENDDO.
LOOP AT itab INTO line FROM 4 TO 8 WHERE col2 > 16 and col2 < 64.
  WRITE: / sy-tabix, line-col2.
ENDLOOP.

        
5          25

        
6          36

        
7          49

用字段符号进行访问

当由内表中READ条目或LOOP时,可以使用以下字符符号选项:

… ASSIGNING <FS>

 

字符符号会直接针对对应行所当的内存,与做事区域不同的凡,工作区是间接的拜访内表,而字符符号是直接访问内表中的行所在的内存。

 

经字段符号修改字段时,不要对排序表与哈希表的Key字段进修改,否则运行时会见错。另外,在LOOP中动用字段符号时,不可知动用SUM,因为SUM只对工作区域来操作的。

 

以身作则参考:采取字段符号

 

当使用字段符号读取时不需事先用内表行拷贝到工作区域,修改时为无待事先改工作区的始末,然后再以工作区拷贝到内表中,而是径直对内表行进行操作。使用字段符号操作内表行能能提高效率。

 

当用字段符号指定读取的表行后,系统会报该字段符号的分红信息,如果对的表行被删了,则系统会自动应用字段处于无分配状态,此时IF <fs> IS
ASSIGNED表达式为实在。

 

而以是LOOP中应用删除了字段符号指向的内表行,则未可知更指向拖欠字段符号进行ASSIGN,
UNASSIGN这些操作,但若未是LOOP循环里是足以的。

 

DATA: BEGIN OF line,
  col1 TYPE i,
  col2 TYPE i,
END OF line.
DATA itab LIKE SORTED TABLE OF line WITH UNIQUE KEY col1.
FIELD-SYMBOLS <fs> LIKE LINE OF itab.
DO 4 TIMES.
  line-col1 = sy-index.
  line-col2 = sy-index ** 2.
  APPEND line TO itab.
ENDDO.
READ TABLE itab WITH TABLE KEY col1 = 2 ASSIGNING <fs>.
<fs>-col2 = 100.
READ TABLE itab WITH TABLE KEY col1 = 3 ASSIGNING <fs>.
“<fs>指向的行被删除,则IS
ASSIGNED逻辑表达式将为假
DELETE itab INDEX 3.
IF <fs> IS ASSIGNED.
  WRITE ‘<FS> is
assigned!’.
ENDIF.
LOOP AT itab ASSIGNING <fs>.
  WRITE: / <fs>-col1, <fs>-col2.
ENDLOOP.

        
1           1

         2        
100

        
4          16

 

假如itab本身是一个字段符号的内存,则也可动用LOOP AT itab into
<fs>.

用表头替换工作区

wwwlehu6.vip乐虎官网 12

实用的Ranges内表

 

DATA: BEGIN OF gr_t001 OCCURS 0,
        sign   TYPE c LENGTH 1 VALUE ‘I’,
        option TYPE c LENGTH 2 VALUE ‘eq’,
        low    LIKE t001-bukrs,
        high   LIKE t001-bukrs,
      END OF gr_t001.

 

可由此Ranges内表的IN表达式来都行的判定有记录是否就当拖欠内表中设有,这好比Java中的聚合判断有值是否当集聚中在一样,非常实用

RANGES: s_ebeln1 FOR
ekko-ebeln.

 
s_ebeln1-sign = ‘I’.
  s_ebeln1-option = ‘EQ’.
  s_ebeln1-low = ‘xxxxxxxxxx’.
  APPEND s_ebeln1.起来经常一定要投入一个尺码,否则 th_alv-ebeln in
s_ebeln1恒为真

 
CLEAR: s_ebeln1.
  LOOP AT th_alv WHERE checkbox NE space.
    精彩纷呈使用s_ebeln1不只是于OPENSQL中以In,只要是当逻辑表达式中都能利用
    IF NOT th_alv-ebeln IN s_ebeln1.
      s_ebeln1-sign = ‘I’.
      s_ebeln1-option = ‘EQ’.
      s_ebeln1-low = th_alv-ebeln.
      APPEND s_ebeln1.使不存在,则增加
    ENDIF.
  ENDLOOP.

You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图