倒叙开头段

倒叙开头段

2017-08-26 10:11:16

第一种方法：

sed -n '2p' afile | grep '[[:upper:]]' -o | tr -d '\n' | cut -c1-100 | rev

处理第二行 grep:提取大写字母 o: 不显示非结果 tr:删除换行 Cut：截取1-100个字符 rev:逆序

head -n 2 afile | tail -n 1

那第二种方法:

head -n 2 afile | tail -n 1 | grep '[[:upper:]]' -o | tr -d '\n'| cut -c1-100 | rev

更多相关内容

倒叙特写式开头公开课教学教案.doc
2021-09-30 20:35:58

倒叙特写式开头公开课教学教案.doc

收起
ORACLE 索引结构--倒叙索引：
2021-05-01 02:04:47

本帖最后由 sunyunyi 于 2018-11-10 10:58 编辑ORACLE 倒叙索引：作者简介：----------------------------------------------------@ 孙显鹏，海天起点oracle技术专家，十年从业经验@ 精通oracle内部原理，擅长调优...

本帖最后由 sunyunyi 于 2018-11-10 10:58 编辑

ORACLE 倒叙索引：

作者简介：

----------------------------------------------------

@ 孙显鹏，海天起点oracle技术专家，十年从业经验

@ 精通oracle内部原理，擅长调优和解决疑难问题

@ 致力于帮助客户解决生产中的问题，提高生产效率。

@ 爱好：书法，周易，中医。微信：sunyunyi_sun

@ 易曰：精义入神，以致用也！

@ 调优乃燮理阴阳何其难也！

-----------------------------------------------------

下面我们看看倒叙索引内部结构是什么样子，是不是索引键值就是倒叙排列呢？

答案肯定不是，因为oracle不可能为索引建立两个不同的结构。

create user zfy identified by zfy default tablespace test;

grant dba to zfy;

conn zfy/zfy

alter session set nls_date_format='yyyy-mm-dd hh24:mi:ss';

create table tb_ti as select rownum id,'wolf' col0,'wits' col1 from dual connect by level<=10000;

create index idx_tb_ti on tb_ti(id desc);

exec sys.dbms_stats.gather_table_stats ( OwnName => 'ZFY',TabName => 'TB_TI',Estimate_Percent => NULL,Method_Opt => 'FOR ALL COLUMNS SIZE 1 ',Cascade => True ,No_Invalidate => false);

select object_name,object_id from dba_objects where object_name in ('TB_TI','IDX_TB_TI');

OBJECT_NAM  OBJECT_ID

---------- ----------

TB_TI       73553

IDX_TB_TI    73554

alter session set events 'immediate trace name treedump level 73554';

/u02/app/oracle/diag/rdbms/testdb/testdb/trace/testdb_ora_642.trc

----- begin tree dump

branch: 0x14000a3 20971683 (0: nrow: 23, level: 1)

leaf: 0x14000a4 20971684 (-1: row:449.449 avs:817)

leaf: 0x14000a5 20971685 (0: row:449.449 avs:816)

leaf: 0x14000a6 20971686 (1: row:449.449 avs:817)

leaf: 0x14000a7 20971687 (2: row:449.449 avs:816)

leaf: 0x14000a8 20971688 (3: row:449.449 avs:817)

leaf: 0x14000a9 20971689 (4: row:449.449 avs:816)

leaf: 0x14000aa 20971690 (5: row:449.449 avs:817)

leaf: 0x14000ab 20971691 (6: row:449.449 avs:816)

leaf: 0x14000ac 20971692 (7: row:449.449 avs:817)

leaf: 0x14000ad 20971693 (8: row:449.449 avs:816)

leaf: 0x14000ae 20971694 (9: row:449.449 avs:817)

leaf: 0x14000af 20971695 (10: row:449.449 avs:816)

leaf: 0x14000b1 20971697 (11: row:449.449 avs:817)

leaf: 0x14000b2 20971698 (12: row:449.449 avs:816)

leaf: 0x14000b3 20971699 (13: row:449.449 avs:817)

leaf: 0x14000b4 20971700 (14: row:449.449 avs:816)

leaf: 0x14000b5 20971701 (15: row:449.449 avs:817)

leaf: 0x14000b6 20971702 (16: row:449.449 avs:816)

leaf: 0x14000b7 20971703 (17: row:449.449 avs:817)

leaf: 0x14000b8 20971704 (18: row:449.449 avs:816)

leaf: 0x14000b9 20971705 (19: row:449.449 avs:817)

leaf: 0x14000ba 20971706 (20: row:449.449 avs:816)

leaf: 0x14000bb 20971707 (21: row:122.122 avs:6144)

----- end tree dump

首先分析枝节点

select to_number('000a3','xxxxxxx') from dual; --163

alter system dump datafile 5 block 163;

Block header dump:  0x014000a3

Object id on Block? Y

seg/obj: 0x11f52  csc:  0x0000000000169aa6  itc: 1  flg: E  typ: 2 - INDEX

brn: 0  bdba: 0x14000a0 ver: 0x01 opc: 0

inc: 0  exflg: 0

Itl          Xid                Uba       Flag  Lck       Scn/Fsc

0x01 0xffff.000.00000000  0x00000000.0000.00  C--- 0  scn  0x0000000000169aa6

Branch block dump

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

header address 140043605704780=0x7f5e715f004c

kdxcolev 1

KDXCOLEV Flags = - - -

kdxcolok 0

kdxcoopc 0x80: opcode=0: iot flags=--- is converted=Y

kdxconco 2

kdxcosdc 0

kdxconro 22

kdxcofbo 72=0x48

kdxcofeo 7858=0x1eb2

kdxcoavs 7786

kdxbrlmc 20971684=0x14000a4

kdxbrsno 0

kdxbrbksz 8056

kdxbr2urrc 8

row#0[8047] dba: 20971685=0x14000a5

col 0; len 3; (3):  3d 9f cb

col 1; TERM

row#1[8038] dba: 20971686=0x14000a6

col 0; len 3; (3):  3d a3 fc

col 1; TERM

row#2[8029] dba: 20971687=0x14000a7

col 0; len 3; (3):  3d a8 c9

col 1; TERM

row#3[8020] dba: 20971688=0x14000a8

col 0; len 3; (3):  3d ac fa

col 1; TERM

row#4[8011] dba: 20971689=0x14000a9

col 0; len 3; (3):  3d b1 c7

col 1; TERM

row#5[8002] dba: 20971690=0x14000aa

col 0; len 3; (3):  3d b5 f8

col 1; TERM

row#6[7993] dba: 20971691=0x14000ab

col 0; len 3; (3):  3d ba c5

col 1; TERM

row#7[7984] dba: 20971692=0x14000ac

col 0; len 3; (3):  3d be f6

col 1; TERM

row#8[7975] dba: 20971693=0x14000ad

col 0; len 3; (3):  3d c3 c3

col 1; TERM

row#9[7966] dba: 20971694=0x14000ae

col 0; len 3; (3):  3d c7 f4

col 1; TERM

row#10[7957] dba: 20971695=0x14000af

col 0; len 3; (3):  3d cc c1

col 1; TERM

row#11[7948] dba: 20971697=0x14000b1

col 0; len 3; (3):  3d d0 f2

col 1; TERM

row#12[7939] dba: 20971698=0x14000b2

col 0; len 3; (3):  3d d5 bf

col 1; TERM

row#13[7930] dba: 20971699=0x14000b3

col 0; len 3; (3):  3d d9 f0

col 1; TERM

row#14[7921] dba: 20971700=0x14000b4

col 0; len 3; (3):  3d de bd

col 1; TERM

row#15[7912] dba: 20971701=0x14000b5

col 0; len 3; (3):  3d e2 ee

col 1; TERM

row#16[7903] dba: 20971702=0x14000b6

col 0; len 3; (3):  3d e7 bb

col 1; TERM

row#17[7894] dba: 20971703=0x14000b7

col 0; len 3; (3):  3d eb ec

col 1; TERM

row#18[7885] dba: 20971704=0x14000b8

col 0; len 3; (3):  3d f0 b9

col 1; TERM

row#19[7876] dba: 20971705=0x14000b9

col 0; len 3; (3):  3d f4 ea

col 1; TERM

row#20[7867] dba: 20971706=0x14000ba

col 0; len 3; (3):  3d f9 b7

col 1; TERM

row#21[7858] dba: 20971707=0x14000bb

col 0; len 3; (3):  3d fd e8

col 1; TERM

----- end of branch block dump -----

End dump data blocks tsn: 6 file#: 5 minblk 163 maxblk 163

我们分析下：

从分支节点可以看到叶节点还是按照升序排列的，但是分支节点临界值并不是id列的实际值，

3d 9f cb 这些值是怎来的呢？我还不清楚。

我们看看第一个叶节点：

select to_number('14','xxxxxxx')/4 from dual; --5

select to_number('000a4','xxxxxxx') from dual; --164

alter system dump datafile 5 block 164;

row#0[8019] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3c fd ff                -10000 -id的最大值，怎么变成3c fd ff

col 1; len 6; (6):  01 40 00 9e 00 5c

row#1[8005] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b 9b ff             -9999

col 1; len 6; (6):  01 40 00 9e 00 5b

row#2[7991] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b 9c ff             -9998

col 1; len 6; (6):  01 40 00 9e 00 5a

row#3[7977] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b 9d ff

col 1; len 6; (6):  01 40 00 9e 00 59

row#4[7963] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b 9e ff

col 1; len 6; (6):  01 40 00 9e 00 58

row#5[7949] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b 9f ff

col 1; len 6; (6):  01 40 00 9e 00 57

row#6[7935] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b a0 ff

col 1; len 6; (6):  01 40 00 9e 00 56

row#7[7921] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b a1 ff

col 1; len 6; (6):  01 40 00 9e 00 55

row#8[7907] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b a2 ff

col 1; len 6; (6):  01 40 00 9e 00 54

row#9[7893] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b a3 ff

col 1; len 6; (6):  01 40 00 9e 00 53

row#10[7879] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b a4 ff

col 1; len 6; (6):  01 40 00 9e 00 52

row#11[7865] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b a5 ff

col 1; len 6; (6):  01 40 00 9e 00 51

row#12[7851] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d 9b a6 ff

我们查看第一个叶子信息：

row#0[8019] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3c fd ff

col 1; len 6; (6):  01 40 00 9e 00 5c

select to_number('0009e','xxxxxxx') from dual; --158

select to_number('0005c','xxxxxxx') from dual; --92

alter system dump datafile 5 block 158;

tab 0, row 92, @0x1954

tl: 16 fb: --H-FL-- lb: 0x0  cc: 3

col  0: [ 2]  c3 02

col  1: [ 4]  77 6f 6c 66

col  2: [ 4]  77 69 74 73

end_of_block_dump

End dump data blocks tsn: 6 file#: 5 minblk 158 maxblk 158

select dump (10000,16) from dual;

Typ=2 Len=2: c3,2

10000的dump值为 c3 02 ，但是在倒叙索引下的键值却变成了3c fd ff，oracle内部做了加工处理。

但是加工处理的结构3c fd ff还是最小值，

select to_number('000bb','xxxxxxx') from dual; --187

select to_number('000ba','xxxxxxx') from dual; --186

alter system dump datafile 5 block 187;

row#0[8018] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d fd e8 ff ---3d fd e8 就是最后一个叶块的开始id值，也就是分支节点最后一个值

col 1; len 6; (6):  01 40 00 83 00 79

row#1[8004] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d fd e9 ff

col 1; len 6; (6):  01 40 00 83 00 78

row#2[7990] flag: -------, lock: 0, len=14

col 0; len 4; (4):  3d fd ea ff

col 1; len 6; (6):  01 40 00 83 00 77

row#3[7976] flag: -------, lock: 0, len=14

......

row#113[6528] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e f5 ff

col 1; len 6; (6):  01 40 00 83 00 08

row#114[6515] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e f6 ff

col 1; len 6; (6):  01 40 00 83 00 07

row#115[6502] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e f7 ff

col 1; len 6; (6):  01 40 00 83 00 06

row#116[6489] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e f8 ff

col 1; len 6; (6):  01 40 00 83 00 05

row#117[6476] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e f9 ff

col 1; len 6; (6):  01 40 00 83 00 04

row#118[6463] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e fa ff

col 1; len 6; (6):  01 40 00 83 00 03

row#119[6450] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e fb ff

col 1; len 6; (6):  01 40 00 83 00 02

row#120[6437] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e fc ff

col 1; len 6; (6):  01 40 00 83 00 01

row#121[6424] flag: -------, lock: 0, len=13

col 0; len 3; (3):  3e fd ff

col 1; len 6; (6):  01 40 00 83 00 00

----- end of leaf block Logical dump -----

----- end of leaf block dump -----

End dump data blocks tsn: 6 file#: 5 minblk 187 maxblk 187

dump 最后一个id=3e fd ff col1=01 40 00 83 00 00

select to_number('00083','xxxxxxx') from dual; --131

alter system dump datafile 5 block 131;

tab 0, row 0, @0x1f70

tl: 16 fb: --H-FL-- lb: 0x0  cc: 3

col  0: [ 2]  c1 02    id=1

col  1: [ 4]  77 6f 6c 66

col  2: [ 4]  77 69 74 73

也就是说id=1的c1 02通过倒叙索引id变成了3e fd ff，而3e fd ff在所有索引键值中却变成了最大值。

我们看看这个值是什么意思：

3c fd ff

select to_number('3d','xxxxxxx') from dual; --61

select to_number('fd','xxxxxxx') from dual; --253

select to_number('ff','xxxxxxx') from dual; --255

61 开头应该是负数，计算方式为：

指数=62-61=1

数字1= (101-253)*100^(1-0) = -152*100=-15200

FF 应该有特殊含义，其实注意到col 0; len 3; (3):这个括号里的3不是number型，

number型应该为2才对，这个可能有特殊含义。到目前为止我还不清楚该计算方式。

负数应该是以102结尾。

比如正常-10000的oracle内部 100进制表示方式应该是：

select dump(-10000) from dual;

Typ=2 Len=3: 60,100,102

指数=62-60=2

数字1 =(101-100)*100^2=1*10000

102 代表-号

这个问题有待于深入研究！

下面是正常索引的信息，可以作为对比参考。

create table tb_tia as select rownum id,'wolf' col0,'wits' col1 from dual connect by level<=10000;

create index idx_tb_tia on tb_tia(id);

exec sys.dbms_stats.gather_table_stats ( OwnName => 'ZFY',TabName => 'TB_TIA',Estimate_Percent => NULL,Method_Opt => 'FOR ALL COLUMNS SIZE 1 ',Cascade => True ,No_Invalidate => false);

select object_name,object_id from dba_objects where object_name in ('TB_TIA','IDX_TB_TIA');

----------

IDX_TB_TIA 73702

TB_TIA    73701

alter session set events 'immediate trace name treedump level 73702';

----- begin tree dump

branch: 0x14000e3 20971747 (0: nrow: 21, level: 1)

leaf: 0x14000e4 20971748 (-1: row:485.485 avs:824)

leaf: 0x14000e5 20971749 (0: row:479.479 avs:816)

leaf: 0x14000e6 20971750 (1: row:479.479 avs:816)

leaf: 0x14000e7 20971751 (2: row:479.479 avs:816)

leaf: 0x14000e8 20971752 (3: row:479.479 avs:816)

leaf: 0x14000e9 20971753 (4: row:478.478 avs:830)

leaf: 0x14000ea 20971754 (5: row:479.479 avs:816)

leaf: 0x14000eb 20971755 (6: row:479.479 avs:816)

leaf: 0x14000ec 20971756 (7: row:479.479 avs:816)

leaf: 0x14000ed 20971757 (8: row:478.478 avs:830)

leaf: 0x14000ee 20971758 (9: row:479.479 avs:816)

leaf: 0x14000ef 20971759 (10: row:479.479 avs:816)

leaf: 0x14000f1 20971761 (11: row:479.479 avs:816)

leaf: 0x14000f2 20971762 (12: row:479.479 avs:816)

leaf: 0x14000f3 20971763 (13: row:478.478 avs:830)

leaf: 0x14000f4 20971764 (14: row:479.479 avs:816)

leaf: 0x14000f5 20971765 (15: row:479.479 avs:816)

leaf: 0x14000f6 20971766 (16: row:479.479 avs:816)

leaf: 0x14000f7 20971767 (17: row:479.479 avs:816)

leaf: 0x14000f8 20971768 (18: row:478.478 avs:830)

leaf: 0x14000f9 20971769 (19: row:418.418 avs:1731)

----- end tree dump

select to_number('14','xxxxxxx')/4 from dual; --5

select to_number('000e3','xxxxxxx') from dual; --227

alter system dump datafile 5 block 227;

Block header dump:  0x014000e3

Object id on Block? Y

seg/obj: 0x11fe6  csc:  0x000000000016fc2a  itc: 1  flg: E  typ: 2 - INDEX

brn: 0  bdba: 0x14000e0 ver: 0x01 opc: 0

inc: 0  exflg: 0

Itl          Xid                Uba       Flag  Lck       Scn/Fsc

0x01 0xffff.000.00000000  0x00000000.0000.00  C--- 0  scn  0x000000000016fc2a

Branch block dump

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

header address 140466161524812=0x7fc0d3a9204c

kdxcolev 1

KDXCOLEV Flags = - - -

kdxcolok 0

kdxcoopc 0x80: opcode=0: iot flags=--- is converted=Y

kdxconco 2

kdxcosdc 0

kdxconro 20

kdxcofbo 68=0x44

kdxcofeo 7876=0x1ec4

kdxcoavs 7808

kdxbrlmc 20971748=0x14000e4

kdxbrsno 0

kdxbrbksz 8056

kdxbr2urrc 0

row#0[8047] dba: 20971749=0x14000e5

col 0; len 3; (3):  c2 05 57

col 1; TERM

row#1[8038] dba: 20971750=0x14000e6

col 0; len 3; (3):  c2 0a 42

col 1; TERM

row#2[8029] dba: 20971751=0x14000e7

col 0; len 3; (3):  c2 0f 2d

col 1; TERM

row#3[8020] dba: 20971752=0x14000e8

col 0; len 3; (3):  c2 14 18

col 1; TERM

row#4[8011] dba: 20971753=0x14000e9

col 0; len 3; (3):  c2 19 03

col 1; TERM

row#5[8002] dba: 20971754=0x14000ea

col 0; len 3; (3):  c2 1d 51

col 1; TERM

row#6[7993] dba: 20971755=0x14000eb

col 0; len 3; (3):  c2 22 3c

col 1; TERM

row#7[7984] dba: 20971756=0x14000ec

col 0; len 3; (3):  c2 27 27

col 1; TERM

row#8[7975] dba: 20971757=0x14000ed

col 0; len 3; (3):  c2 2c 12

col 1; TERM

row#9[7966] dba: 20971758=0x14000ee

col 0; len 3; (3):  c2 30 60

col 1; TERM

row#10[7957] dba: 20971759=0x14000ef

col 0; len 3; (3):  c2 35 4b

col 1; TERM

row#11[7948] dba: 20971761=0x14000f1

col 0; len 3; (3):  c2 3a 36

col 1; TERM

row#12[7939] dba: 20971762=0x14000f2

col 0; len 3; (3):  c2 3f 21

col 1; TERM

row#13[7930] dba: 20971763=0x14000f3

col 0; len 3; (3):  c2 44 0c

col 1; TERM

row#14[7921] dba: 20971764=0x14000f4

col 0; len 3; (3):  c2 48 5a

col 1; TERM

row#15[7912] dba: 20971765=0x14000f5

col 0; len 3; (3):  c2 4d 45

col 1; TERM

row#16[7903] dba: 20971766=0x14000f6

col 0; len 3; (3):  c2 52 30

col 1; TERM

row#17[7894] dba: 20971767=0x14000f7

col 0; len 3; (3):  c2 57 1b

col 1; TERM

row#18[7885] dba: 20971768=0x14000f8

col 0; len 3; (3):  c2 5c 06

col 1; TERM

row#19[7876] dba: 20971769=0x14000f9

col 0; len 3; (3):  c2 60 54

col 1; TERM

----- end of branch block dump -----

End dump data blocks tsn: 6 file#: 5 minblk 227 maxblk 227

select to_number('000e4','xxxxxxx') from dual; --228

alter system dump datafile 5 block 228;

Block header dump:  0x014000e4

Object id on Block? Y

seg/obj: 0x11fe6  csc:  0x000000000016fc2a  itc: 2  flg: E  typ: 2 - INDEX

brn: 0  bdba: 0x14000e0 ver: 0x01 opc: 0

inc: 0  exflg: 0

Itl          Xid                Uba       Flag  Lck       Scn/Fsc

0x01 0x0000.000.00000000  0x00000000.0000.00  ---- 0  fsc 0x0000.00000000

0x02 0xffff.000.00000000  0x00000000.0000.00  C--- 0  scn  0x000000000016fc2a

Leaf block dump

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

header address 140466161524836=0x7fc0d3a92064

kdxcolev 0

KDXCOLEV Flags = - - -

kdxcolok 0

kdxcoopc 0x80: opcode=0: iot flags=--- is converted=Y

kdxconco 2

kdxcosdc 0

kdxconro 485

kdxcofbo 1006=0x3ee

kdxcofeo 1830=0x726

kdxcoavs 824

kdxlespl 0

kdxlende 0

kdxlenxt 20971749=0x14000e5

kdxleprv 0=0x0

kdxledsz 0

kdxlebksz 8032

row#0[8020] flag: -------, lock: 0, len=12

col 0; len 2; (2):  c1 02

col 1; len 6; (6):  01 40 00 c3 00 00

row#1[8008] flag: -------, lock: 0, len=12

col 0; len 2; (2):  c1 03

col 1; len 6; (6):  01 40 00 c3 00 01

row#2[7996] flag: -------, lock: 0, len=12

col 0; len 2; (2):  c1 04

col 1; len 6; (6):  01 40 00 c3 00 02

row#3[7984] flag: -------, lock: 0, len=12

col 0; len 2; (2):  c1 05

col 1; len 6; (6):  01 40 00 c3 00 03

row#4[7972] flag: -------, lock: 0, len=12

col 0; len 2; (2):  c1 06

col 1; len 6; (6):  01 40 00 c3 00 04

row#5[7960] flag: -------, lock: 0, len=12

col 0; len 2; (2):  c1 07

col 1; len 6; (6):  01 40 00 c3 00 05

row#6[7948] flag: -------, lock: 0, len=12

col 0; len 2; (2):  c1 08

col 1; len 6; (6):  01 40 00 c3 00 06

row#7[7936] flag: -------, lock: 0, len=12

col 0; len 2; (2):  c1 09

col 1; len 6; (6):  01 40 00 c3 00 07

row#8[7924] flag: -------, lock: 0, len=12

...

row#480[1882] flag: -------, lock: 0, len=13

col 0; len 3; (3):  c2 05 52

col 1; len 6; (6):  01 40 00 c4 00 5e

row#481[1869] flag: -------, lock: 0, len=13

col 0; len 3; (3):  c2 05 53

col 1; len 6; (6):  01 40 00 c4 00 5f

row#482[1856] flag: -------, lock: 0, len=13

col 0; len 3; (3):  c2 05 54

col 1; len 6; (6):  01 40 00 c4 00 60

row#483[1843] flag: -------, lock: 0, len=13

col 0; len 3; (3):  c2 05 55

col 1; len 6; (6):  01 40 00 c4 00 61

row#484[1830] flag: -------, lock: 0, len=13

col 0; len 3; (3):  c2 05 56

col 1; len 6; (6):  01 40 00 c4 00 62

----- end of leaf block Logical dump -----

----- end of leaf block dump -----

End dump data blocks tsn: 6 file#: 5 minblk 228 maxblk 228

收起

展开全文

oracle查询倒叙
python的list中元组倒序排列和列表生成式去掉列表的开头和结尾数据和多可迭代对象根据下标排序
2021-10-30 15:12:09
相同成绩的按照名字升序排序： list的列表生成式去掉列表的开头和结尾数据生成新列表并且合并字符串内容 list=['1','2','3','4','5'] #去掉开头结尾 list2 = [list[a] for a in range(len(list)) if a not in ...
语法

sort()方法语法：
```
list.sort( key=None, reverse=False)
```
参数

参数
- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值

该方法没有返回值，但是会对列表的对象进行排序。

#x[1]表示元组中索引为1的元素

意思就是将list中元祖的顺序按照元祖中索引为1的元素的大小进行升序排列

与之用法相同的方法还有sortedt()------------------------------------------------------------------------------------

语法

sorted 语法：
```
sorted(iterable, key=None, reverse=False)  
```
参数说明：
- iterable -- 可迭代对象。
- key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
- reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
返回值

返回重新排序的列表。

sort 与 sorted的区别：sort ()是应用在 list 上的方法，无返回值，sorted () 可以对所有可迭代的对象进行排序操作，返回的是一个新的 list

sorted（）的补充可以通过 key 的值来进行数组/字典的排序

多列排序先按照成绩降序排序，相同成绩的按照名字升序排序：

list的列表生成式去掉列表的开头和结尾数据生成新列表并且合并字符串内容
```
list=['1','2','3','4','5']
#去掉开头结尾
list2 = [list[a] for a in range(len(list)) if a not in [0, len(list)-1]]
#合并列表字符串内容
str1 = ''.join(list2)
print(str1)
```
多个可迭代对象同时按下标排序

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同

zip(*)利用 * 号操作符，可以将元组解压为列表。

zip 在Python3中返回值为 zip对象<zip object at 0x020F3580>

因为sort 是应用在 list 上的方法，无返回值，所以处理大量数据的效率相较于sorted ()更高
收起
展开全文
排序算法 python 列表生成式

vi查找行开头结尾

千次阅读 2016-05-30 16:13:56

vi 查找是/，查找下一个是n，前一个是？ /^[^1] 不以1开头的行 /[^1] 所有行的非1元素 /^[1] 所有1开头的行 /[1]$ 所有1结尾的行 /[^1]$ 所有非1结尾的行

查找是/，查找下一个是n，前一个是？

/^[^1] 不以1开头的行

/[^1] 所有行的非1元素

/^[1] 所有1开头的行

/[1]$ 所有1结尾的行

/[^1]$ 所有非1结尾的行

多行删除，复制

1,10d 删除1到10行

yy 复制 np 复制元素n倍写到指定位置

光标在第n行，myy复制n及其下的m-1行

esc: 命令模式与插入模式的切换

一、vi查找: 当你用vi打开一个文件后，因为文件太长，如何才能找到你所要查找的关键字呢？在vi里可没有菜单-〉查找，

不过没关系,你在命令模式下敲斜杆(/)这时在状态栏（也就是屏幕左下脚）就出现了 “/”然后输入你要查找的关键字

敲回车就可以了。如果你要继续查找此关键字，敲字符n就可以继续查找了。值得注意的是“/”是向下查找，而“?”

是向上查找，而在键盘定义上“?”刚好是“/”的上档符.

二、VI替换：vi/vim 中可以使用：s 命令来替换字符串§以前只会使用一种格式来全文替换，今天发现该命令有很多种写法（vi 真是强大啊飕还有很多需要学习），记录几种在此，方便以后查询§

：s/vivian/sky/ 替换当前行第一个 vivian 为 sky
：s/vivian/sky/g 替换当前行所有 vivian 为 sky
：n，$s/vivian/sky/ 替换第 n 行开始到最后一行中每一行的第一个 vivian 为 sky
：n，$s/vivian/sky/g 替换第 n 行开始到最后一行中每一行所有 vivian 为 sky
n 为数字，若 n 为 .，表示从当前行开始到最后一行
：%s/vivian/sky/（等同于：g/vivian/s//sky/）替换每一行的第一个 vivian 为 sky
：%s/vivian/sky/g（等同于：g/vivian/s//sky/g）替换每一行中所有 vivian 为 sky

　　可以使用 # 作为分隔符，此时中间出现的 / 不会作为分隔符

：s#vivian/#sky/# 替换当前行第一个 vivian/ 为 sky/
：%s+/oradata/apras/+/user01/apras1+ （使用+ 来替换 / ）： /oradata/apras/替换成/user01/apras1/

1.：s/vivian/sky/ 替换当前行第一个 vivian 为 sky

：s/vivian/sky/g 替换当前行所有 vivian 为 sky

2. ：n，$s/vivian/sky/ 替换第 n 行开始到最后一行中每一行的第一个 vivian 为 sky

：n，$s/vivian/sky/g 替换第 n 行开始到最后一行中每一行所有 vivian 为 sky
（n 为数字，若 n 为 .，表示从当前行开始到最后一行）

3. ：%s/vivian/sky/（等同于：g/vivian/s//sky/）替换每一行的第一个 vivian 为 sky

：%s/vivian/sky/g（等同于：g/vivian/s//sky/g）替换每一行中所有 vivian 为 sky

4. 可以使用 # 作为分隔符，此时中间出现的 / 不会作为分隔符

：s#vivian/#sky/# 替换当前行第一个 vivian/ 为 sky/

5. 删除文本中的^M
　　问题描述：对于换行，window下用回车换行（0A0D）来表示，linux下是回车（0A）来表示§这样，

将window上的文件拷到unix上用时，总会有个^M.请写个用在unix下的过滤windows文件的换行符（0D）

的shell或c程序§

§ 使用命令：cat filename1 | tr -d “^V^M” > newfile；
§ 使用命令：sed -e “s/^V^M//” filename > outputfilename.需要注意的是在1、2两种方法中，^V和^M指的是Ctrl+V和Ctrl+M.你必须要手工进行输入，而不是粘贴§
§ 在vi中处理：首先使用vi打开文件，然后按ESC键，接着输入命令：%s/^V^M//.
§ ：%s/^M$//g

　　如果上述方法无用，则正确的解决办法是：

§ tr -d \"\\r\" < src >dest
§ tr -d \"\\015\" dest
§ strings A>B

6. 其它
　　利用：s 命令可以实现字符串的替换§具体的用法包括：

：s/str1/str2/ 用字符串 str2 替换行中首次出现的字符串 str1
：s/str1/str2/g 用字符串 str2 替换行中所有出现的字符串 str1
：§，$ s/str1/str2/g 用字符串 str2 替换正文当前行到末尾所有出现的字符串 str1
：1，$ s/str1/str2/g 用字符串 str2 替换正文中所有出现的字符串 str1
：g/str1/s//str2/g 功能同上

　　从上述替换命令可以看到：g 放在命令末尾，表示对搜索字符串的每次出现进行替换；不加 g，

表示只对搜索字符串的首次出现进行替换；g 放在命令开头，表示对正文中所有包含搜索字符

串的行进行替换操作§

收起

展开全文

【顺序结构】：三位数倒叙问题（题解）
2022-07-26 13:32:54

（如果反转后首位为0，仍输出以0开头的数）输入样例： 145 输出样例： 541 思路：将一个三位数分为char类型的三个数字，然后输出的时候倒序输出就好了。根本不需要什么逻辑思维。 AC代码： #include using ...

收起

数据结构
生成包括大小写字母数字以及符号的密码且不能有连续或者倒叙以及其校验
2021-03-02 16:21:40

// 判断生成的随机密码中是否包含大小写字母和数字字母 if (exp.test(this.password)) { // 判断有没有倒叙或者正序相连的数字或者字母 let flag = this.adjoinVerfy(this.password); if (flag) { this....

收起
java对于开头字母排列的处理
2020-01-08 14:27:40

先按照销量倒叙，再按照首字母升序 userRank.stream().sorted(Comparator.comparing(ERPUserRankVo::getTotalMoneyTC,Comparator.nullsFirst(BigDecimal::compareTo)).reversed().thenComparing(ERPUserRankVo::...

收起

mysql java
Linux 小技巧:bc输出进制倒叙正序输出查看汇编
2016-08-01 17:20:44

Linux 小技巧: 1. 十进制转换为16进制 echo "obase=16;121" |bc 79 转换十进制为2进制 echo "obase=2;...2.rev temp 倒叙输出temp cat temp 正续输出temp 3. gcc -o ao test.c test.c文件 int main(){

收起
linux查看日志
2021-05-15 06:23:37

若想在linux下查询某个时间段的log，用sed命令示例如下：$　sed -n '/2017-11-11 11:00:00/,/2017-11-11 11:11:11/p' error.loggrep正则表达式元字符集：^ 锚定行的开始如：'^grep'匹配所有以grep开头的行。...

收起
Python 学习-基础编程（1）
2020-12-29 17:17:31

,…, )) 对print()函数的end参数进行赋值 print(, end="") 【实例】计算机程序是机械记忆的高手，下面将编写一段程序，获得用户输入，采用倒叙方式将输入内容输出出来。该程序的输入和输出实例如下：输入...

收起

python
TP5在前端时间戳转换为时间格式
2021-02-01 19:08:22

转载：深入浅出Zookeeper（一） Zookeeper架构及FastLeaderElection机制转载至 http://www.jasongj.com/zookeeper/fastleaderelection/: 原创文章,转载请务必将下面这段话置于文章开头处.本文转发自技术世界,原文...

收起
框架阶段学习
2021-04-29 15:12:40

1600 或 3000 的员工 SELECT * FROM emp WHERE sal IN (800,1600,3000) 查询出所有雇员姓名是以 A 开头的全部雇员信息。 SELECT * FROM emp WHERE ename like "A%" 查询出雇员姓名第二个字母是 M 的全部雇员信息。 ...

收起
念叨了一年的游戏叙事书中文版终于出了
千次阅读 2021-12-21 09:20:37

作为对比，他接着列出了《神秘海域2》开头部分的分类结果：（《神秘海域2》采用了倒叙的设计，一开始就用如此生猛的桥段瞬间把玩家心揪了起来。）当然，为了避免误会，Skolnick也特地强调：《合金装备 2》是一款...

收起
RocketMQ源码(4)—Broker启动加载消息文件以及恢复数据源码【一万字】
2022-06-03 14:02:31

详细介绍了Broker启动加载消息文件以及恢复数据源码。

收起

java 消息队列
史上最全的工作流引擎 Activiti 学习教程（值得收藏）
千次阅读 2022-05-14 01:32:29

点击关注公众号，实用技术文章及时了解一、工作流介绍1.1 概念工作流(Workflow)，就是通过计算机对业务流程自动化执行管理。它主要解决的是“使在多个参与者之间按照某种预定义的规则自动进行传递文档、信息或任务的...

收起

大数据 mysql java python
放大招了，肝了一篇8万字的Java8新特性总结，赶快收藏
千次阅读 多人点赞 2022-02-14 10:07:34

Lambda表达式是一个匿名函数，我们可以这样理解Lambda表达式：Lambda是一段可以传递的代码（能够做到将代码像数据一样进行传递）。使用Lambda表达式能够写出更加简洁、灵活的代码。并且，使用Lambda表达式能够使...

收起

Java8 Java 编程基础程序员编程语言
7.3万字肝爆Java8新特性，我不信你能看完！（建议收藏）
万次阅读 多人点赞 2021-04-09 13:17:35

Lambda表达式是一个匿名函数，我们可以这样理解Lambda表达式：Lambda是一段可以传递的代码（能够做到将代码像数据一样进行传递）。使用Lambda表达式能够写出更加简洁、灵活的代码。并且，使用Lambda表达式能够使...

收起
使用sorted内置函数排序数列来找出最大三个数的乘积
2022-02-10 00:45:00

3] 最后用x=nums[-1]*nums[-2]*nums[-3]来表示乘积并用 Print(‘{}为最大三个数组成的乘积’.format{x}) 3 实验结果与讨论通过实验、实践等证明提出的方法是有效的，是能够解决开头提出的问题。代码清单 1 Courier...

收起

人工智能机器学习排序算法
深入理解PHP之数组(遍历顺序) Laruence原创_PHP教程
2021-04-30 04:33:29

如果Bucket中的数据不是一个指针，pDataPtr为NULL(本段来自Altair的”Zend HashTable详解”) 结合上面的HashTable结构, 我们来说明下HashTable的总结构图: HashTable的pListhHead指向线性列表形式下的第一个元素, 上...

收起
链表实现倒序相加
2020-08-18 15:15:10

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。示例：输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807 # Definition for singly-linked list

收起

指针 python
用指针将英文字符串倒序排列。
2017-07-16 23:06:31

//重置p1到下一个单词的开头 } p2++; } p3 = p2 - 1; while(p1 ) //单p2扫描到最后一个单词时，后面不是空格而是'0'，会跳过循环交换，所以需额外循环最后一个单词。 { tmp = *p1; *(p1++) = *p3; *...

收起
MySql字符研究
2021-01-27 13:34:39

0x01 字符集和字符序http://www.laruence.com/2008/01/05/12.html字符集 character set针对给定的字符赋予一个数值，这个数值就是这个字符的编码，多个字符以及对应的编码，就组成了字符集eg: A->...

收起
indexOf() 如何判断一个元素在指定数组中是否存在？... indexOf()方法是正序查找，lastIndexOf()是倒叙查找
千次阅读 2020-12-20 11:42:36

你可以在编写scripts时，在其开头使用以下代码，它能够允许你在没有本地支持的情况下使用indexOf方法。该算法符合ECMA-262第5版其中一项规定, 即假定 TypeError和 Math.abs 呈现它们原有的价值。 1 //Production ...

收起
删除链表的倒数第N个节点，并返回链表的头节点
2021-07-13 12:06:43

} } 0x01：两次循环求长度实现思路： 1、先循环一遍链表，求出链表的长度L，倒数第N个节点就是从开头数第（L-N+1）个节点,将此节点的next指向下下节点就可以了。在解题的过程中要添加一个亚节点（dummy）进行...

收起

指针 leetcode
Mongodb简单常用的查询语句
2021-10-29 15:07:25

以某个字符开头查询 db.user_document_test.find({address: /^北/}); 以某个字符结尾查询 db.user_document_test.find({address: /区$/}) 5.符号匹配查询，大于($gt)，小于($lt)，大于等于($gte)，小于等于($lte)，...

收起

mongodb
基础回顾：10W+ 字 C 语言入门教程（上）
2021-06-25 10:43:36

手机中的每一个功能就相当于C语言程序中的一个程序段(函数) 众多功能中总有一个会被先执行,不可能多个功能一起执行想使用手机必须先执行手机的开机功能所以C语言程序也一样,由众多功能、众多程序段组成, 众多C语言...

收起

lamp scipy makefile lighttpd
Linux 之 sort 命令
千次阅读 2021-05-12 14:38:22

简介sort 是用来排序的，Unix Shell 的传统是对问本行做处理，...默认排序规则：数字开头的行会排在字母开头行之前字母序排序(不分大小写)小写字母会排在相同的大写字母之前OptionsFlag描述-r, --reverse倒序-o, --...

收起
阅读下面一段文字,完成8一10题当科学家们使用计算机来试图预
2021-06-28 02:42:35

尤其是文章的开头句、结尾句、独立成段的句子、比喻句、连问句、过渡句、抒情议论句，文章的主旨常常隐含其中。 ①不要急着去做题，在进入题目之前，必须读两遍文章。第一遍速读，作快速浏览，摄取各段大概意思，...

收起

倒叙特写式开头公开课教学教案.doc

ORACLE 索引结构--倒叙索引：

python的list中元组倒序排列和列表生成式去掉列表的开头和结尾数据和多可迭代对象根据下标排序

语法

参数

参数

返回值

返回值

vi查找行开头结尾

【顺序结构】：三位数倒叙问题（题解）

生成包括大小写字母数字以及符号的密码且不能有连续或者倒叙以及其校验

java对于开头字母排列的处理

Linux 小技巧:bc输出进制 倒叙正序输出 查看汇编

linux查看日志

Python 学习-基础编程（1）

TP5在前端时间戳转换为时间格式

框架阶段学习

念叨了一年的游戏叙事书中文版终于出了

RocketMQ源码(4)—Broker启动加载消息文件以及恢复数据源码【一万字】

史上最全的工作流引擎 Activiti 学习教程（值得收藏）

放大招了，肝了一篇8万字的Java8新特性总结，赶快收藏

7.3万字肝爆Java8新特性，我不信你能看完！（建议收藏）

使用sorted内置函数排序数列来找出最大三个数的乘积

深入理解PHP之数组(遍历顺序) Laruence原创_PHP教程

链表实现倒序相加

用指针将英文字符串倒序排列。

MySql字符研究

indexOf() 如何判断一个元素在指定数组中是否存在？... indexOf()方法 是正序查找，lastIndexOf()是倒叙查找

删除链表的倒数第N个节点，并返回链表的头节点

Mongodb简单常用的查询语句

基础回顾：10W+ 字 C 语言入门教程（上）

Linux 之 sort 命令

阅读下面一段文字,完成8一10题当科学家们使用计算机来试图预

Linux 小技巧:bc输出进制倒叙正序输出查看汇编

indexOf() 如何判断一个元素在指定数组中是否存在？... indexOf()方法是正序查找，lastIndexOf()是倒叙查找