达梦数据库SQL执行计划常用操作符

已于 2024-04-03 10:03:48 修改
阅读量2.8k 收藏 12
点赞数 3
分类专栏： 达梦数据库 文章标签： 数据库 达梦数据库 DM
于 2021-04-15 10:24:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35273918/article/details/115717673
版权

1. PRJT2
关系的“投影”(project)运算，用于选择表达式项的计算；广泛用于查询，排序，函数索引创建等。
SQL>explain select c1 + c2 from t1;
explain select c1 + c2 from t1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
    #CSCN2: [6, 1, 0]; INDEX33555457(T1)

2. NSET2
结果集(result set)收集，一般是查询计划的顶层节点。
SQL>explain select c1 + c2 from t1;
explain select c1 + c2 from t1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
    #CSCN2: [6, 1, 0]; INDEX33555457(T1)

3. SLCT2
关系的“选择”（select）运算，用于查询条件的过滤。
explain select * from t1 where c1 >1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(3), is_atom(FALSE)
    #SLCT2: [6, 1, 0]; T1.C1 > 1
      #CSCN2: [6, 1, 0]; INDEX33555457(T1)
 

4. NEST LOOP INNER JOIN2

简写为NLI2，嵌套循环内连接；没有索引可用，且无法用HASH,(如不等值比较)，则可能使用NLI2

explain select * from t1, t2 where t1.c1 >t2.c2;
#NSET2: [19, 1, 0]
  #PRJT2: [19, 1, 0]; exp_num(4), is_atom(FALSE)
    #SLCT2: [19, 1, 0]; T1.C1 > T2.C2
      #NEST LOOP INNER JOIN2: [19, 1, 0];
        #CSCN2: [6, 1, 0]; INDEX33555457(T1)
        #CSCN2: [6, 1, 0]; INDEX33555458(T2)

5. MERGE INNER JOIN3
简写为MI3，归并内连接；有索引可用时，有可能使用MI3。
explain select a.c1, b.c1 from tx a, tx b where a.c1 = b.c1;
#NSET2: [29, 100000, 0]
  #PRJT2: [29, 100000, 0]; exp_num(2), is_atom(FALSE)
    #MERGE INNER JOIN3: [29, 100000, 0];
      #CSCN2: [23, 100000, 0]; INDEX33555463(TX)
      #CSCN2: [23, 100000, 0]; INDEX33555463(TX)

6. NEST LOOP FULL JOIN2
简写为NLFO2，嵌套循环全外连接。一般不等值连接时使用。
explain select *from t1 full join t2 on t1.c1 <> t2.c1;
#NSET2: [19, 1, 0]
  #PRJT2: [19, 1, 0]; exp_num(4), is_atom(FALSE)
    #NEST LOOP FULL JOIN2: [19, 1, 0]; join condition(T1.C1 <> T2.C1)
      #CSCN2: [6, 1, 0]; INDEX33555457(T1)
      #CSCN2: [6, 1, 0]; INDEX33555458(T2)

7. NEST LOOP LEFT JOIN2
简写为NLLO2，嵌套循环左外连接。一般不等值连接时使用。
explain select *from t1 left join t2 on t1.c1 <> t2.c1;
#NSET2: [19, 1, 0]
  #PRJT2: [19, 1, 0]; exp_num(4), is_atom(FALSE)
    #NEST LOOP LEFT JOIN2: [19, 1, 0]; join condition(T1.C1 <> T2.C1)
      #CSCN2: [6, 1, 0]; INDEX33555457(T1)
      #CSCN2: [6, 1, 0]; INDEX33555458(T2)

8. HASH LEFT JOIN2
简写为HLO2，HASH左外连接。一般等值连接时使用。
explain select *from t1 left join t2 on t1.c1 = t2.c1;
#NSET2: [13, 1, 0]
  #PRJT2: [13, 1, 0]; exp_num(4), is_atom(FALSE)
    #HASH LEFT JOIN2: [13, 1, 0]; key_num(1),
      #CSCN2: [6, 1, 0]; INDEX33555457(T1)
      #CSCN2: [6, 1, 0]; INDEX33555458(T2)

9. HASH RIGHT JOIN2
简写为HRO2，HASH右外连接。下面的例子，做一个tx与t2的左连接。因为t2的行数很小，tx比较大，所以自动转为右连接，在t2上建hash的代价比较小。
explain select * from tx left join t2 on t2.c1 = tx.c1 + 2;
#NSET2: [39, 100000, 0]
  #PRJT2: [39, 100000, 0]; exp_num(4), is_atom(FALSE)
    #HASH RIGHT JOIN2: [39, 100000, 0]; key_num(1),
      #CSCN2: [6, 1, 0]; INDEX33555458(T2)
      #CSCN2: [23, 100000, 0]; INDEX33555463(TX)

10.  HASH FULL JOIN2
简写为HFO2，HASH全外连接。等值连接时可用； 
explain select *from t1 full join t2 on t1.c1 = t2.c1;
#NSET2: [13, 1, 0]
  #PRJT2: [13, 1, 0]; exp_num(4), is_atom(FALSE)
    #HASH FULL JOIN2: [13, 1, 0]; key_num(1),
      #CSCN2: [6, 1, 0]; INDEX33555457(T1)
      #CSCN2: [6, 1, 0]; INDEX33555458(T2)

11.  TOPN2
取前N个记录； 

explain select top 10 * from t1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(3), is_atom(FALSE)
    #TOPN2: [6, 1, 0]; top_num(10)
      #CSCN2: [6, 1, 0]; INDEX33555457(T1)

12.  UNION ALL
Union all 运算，
explain select *from t1 union all select *from t2;
#NSET2: [13, 2, 0]
  #PRJT2: [13, 2, 0]; exp_num(2), is_atom(FALSE)
    #UNION ALL: [13, 2, 0]
      #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555457(T1)
      #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555458(T2)

13.  UNION
集合的并运算，
explain select *from t1 union select *from t2;
#NSET2: [13, 2, 0]
  #PRJT2: [13, 2, 0]; exp_num(2), is_atom(FALSE)
    #UNION: [13, 2, 0]
      #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555457(T1)
      #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555458(T2)

14.  EXCEPT / EXCEPT ALL
集合的差运算
explain select * from t1 except select * from t2;
#NSET2: [13, 1, 0]
  #PRJT2: [13, 1, 0]; exp_num(2), is_atom(FALSE)
    #EXCEPT: [13, 1, 0]
      #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555476(T2)

15.  INTER SECT/ INTERSECT ALL
集合的交运算
explain select * from t1 intersect select * from t2;
#NSET2: [13, 1, 0]
  #PRJT2: [13, 1, 0]; exp_num(2), is_atom(FALSE)
    #INTERSECT: [13, 1, 0]
      #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555476(T2)

16.  INSERET/VINS2
插入记录,其中VINS2用于列存储表
explain insert into t1 values(1, 1);
#INSERT : [0, 0, 0]; table(T1), type(values) 

17.  HAGR2
Hash aggregate; HASH 分组，并计算聚集函数
explain select count(*) from tx group by c2;
#NSET2: [23, 1000, 0]
  #PRJT2: [23, 1000, 0]; exp_num(1), is_atom(FALSE)
    #HAGR2: [23, 1000, 0]; grp_num(1), sfun_num(1)
      #CSCN2: [23, 100000, 0]; INDEX33555479(TX) 

18.  SAGR2
Stream Aggregate;如果输入流是有序的，则使用流分组，并计算聚集函数
explain select count(*) from tx group by c1;
#NSET2: [23, 1000, 0]
  #PRJT2: [23, 1000, 0]; exp_num(1), is_atom(FALSE)
    #SAGR2: [23, 1000, 0]; grp_num(1), sfun_num(1)
      #CSCN2: [23, 100000, 0]; INDEX33555479(TX)

19.  FAGR2
Fast aggregate;如果没有where条件，且取count(*), 或者基于索引的MAX/MIN值，则可以快速取得集函数的值
explain select count(*) from t1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(1), is_atom(FALSE)
    #FAGR2: [6, 1, 0]; sfun_num(1)

20.  AAGR2
简单聚集；如果没有分组（group by）， 则总的就一个组，直接计算聚集函数 
explain select count(*) from tx where c2 = 10;
#NSET2: [22, 1, 0]
  #PRJT2: [22, 1, 0]; exp_num(1), is_atom(FALSE)
    #AAGR2: [22, 1, 0]; grp_num(0), sfun_num(1)
      #SLCT2: [22, 2500, 0]; exp_cast(TX.C2) = var1
        #CSCN2: [22, 100000, 0]; INDEX33555479(TX)

21.  HASH LEFT SEMI JOIN2
HASH 左半连接； 扫描左表建立hash表，扫描右表探测HASH表，最后输出被探测到的左表的行 
explain select * from t1 where c1 in (select c2 from tx);
#NSET2: [35, 1, 0]
  #PRJT2: [35, 1, 0]; exp_num(3), is_atom(FALSE)
    #HASH LEFT SEMI JOIN2: [35, 1, 0];
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #PRJT2: [22, 100000, 0]; exp_num(1), is_atom(FALSE)
        #CSCN2: [22, 100000, 0]; INDEX33555479(TX)

22.  CSCN2/VSCN2
聚集索引扫描（cluster index scan）; VSCN2用于列存储表
explain select *from t1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(3), is_atom(FALSE)
    #CSCN2: [6, 1, 0]; INDEX33555480(T1)

23.  DSCN
Dynamic table scan; 动态视图扫描
explain select * from v$threads;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(3), is_atom(FALSE)
    #DSCN: [6, 1, 0]; SYSINDEXV$THREADS(V$THREADS)

24.  DELETE/VDEL2
删除数据, 其中VDEL2用于列存储表
explain delete from t1 where c1 = 1;
#DELETE : [0, 0, 0]; table(T1), type(select)
  #TEMP TABLE SPOOL: [6, 1, 0]
    #PRJT2: [6, 1, 0]; exp_num(1), is_atom(FALSE)
      #SLCT2: [6, 1, 0]; T1.C1 = 1
        #CSCN2: [6, 1, 0]; INDEX33555480(T1)

25.  SORT3
排序
explain select * from t1 order by c1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(3), is_atom(FALSE)
    #SORT3: [6, 1, 0]; key_num(1), is_distinct(FALSE)
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)

26.  TEMP TABLE SPOOL
临时表，临时存放数据；如delete/update时，临时存放ROWID, PK等定位信息
explain delete from t1 where c1 = 1;
#DELETE : [0, 0, 0]; table(T1), type(select)
  #TEMP TABLE SPOOL: [6, 1, 0]
    #PRJT2: [6, 1, 0]; exp_num(1), is_atom(FALSE)
      #SLCT2: [6, 1, 0]; T1.C1 = 1
        #CSCN2: [6, 1, 0]; INDEX33555480(T1)

27.  PIPE2
管道；先做一遍右儿子，然后执行左儿子，并把左儿子的数据向上送，直到左儿子不再有数据。
explain select (select 2) from  t1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
    #PIPE2: [6, 1, 0]
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #SPOOL2: [0, 1, 0]; key_num(1), spool_num(0)
        #PRJT2: [0, 1, 0]; exp_num(1), is_atom(TRUE)
          #CSCN2: [0, 1, 0]; SYSINDEXSYSDUAL(SYSDUAL)

28.  SPOOL2
也是临时表；和TEMP TABLE SPOOL(NTTS)不同的是，它的数据集不向父亲节点传送，而是被编号，用编号和KEY来定位访问；而TEMP TABLE SPOOL的数据，主动传递给父亲节点；
explain select (select 2) from  t1;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(2), is_atom(FALSE)
    #PIPE2: [6, 1, 0]
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #SPOOL2: [0, 1, 0]; key_num(1), spool_num(0)
        #PRJT2: [0, 1, 0]; exp_num(1), is_atom(TRUE)
          #CSCN2: [0, 1, 0]; SYSINDEXSYSDUAL(SYSDUAL)

29.  CSEK2
聚集索引数据定位；(cluster index seek) 
explain select *from tx where c1 = 20;
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(3), is_atom(FALSE)
    #CSEK2: [6, 1, 0]; scan_type(UNIQUE),INDEX33555479(TX), scan_range[20,20]

30.  SSEK2
2级索引数据定位；(second index seek) 
create index ind2 on tx(c2);
explain select c2 from tx where c2 = 'aaa';
#NSET2: [6, 2500, 0]
  #PRJT2: [6, 2500, 0]; exp_num(1), is_atom(FALSE)
    #SSEK2: [6, 2500, 0]; scan_type(ASC), IND2(TX), scan_range[aaa,aaa]

31.  BLKUP2
(Batch lookup), 使用2级别索引的定位信息， 在聚集索引中查找数据 
explain select * from tx where c2 = 'aaa';
#NSET2: [20, 2500, 0]
  #PRJT2: [20, 2500, 0]; exp_num(4), is_atom(FALSE)
    #BLKUP2: [20, 2500, 0]; IND2(TX)
      #SSEK2: [20, 2500, 0]; scan_type(ASC), IND2(TX), scan_range[aaa,aaa]

32.  NEST LOOP SEMI JOIN2
嵌套循环半连接。通常用于无法使用HASH, 索引的不等值的In/Exists；效率比较差。
explain select * from t1 where exists (select * from t2 where t1.c1 <> t2.c1);
#NSET2: [19, 1, 0]
  #PRJT2: [19, 1, 0]; exp_num(3), is_atom(FALSE)
    #NEST LOOP SEMI JOIN2: [19, 1, 0];  join condition(T1.C1 <> T2.C1)
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #CSCN2: [6, 1, 0]; INDEX33555476(T2)

33.  NEST LOOP INDEX JOIN2
嵌套循环索引连接(IJI2)。 右表上有索引， 对于左表的每一行，利用索引在右表中定位。这是DM6中最常用的优化方式；DM7由于HASH连接比较成熟，因此其重要性略有下降。
explain select *from t1, tx where t1.c1 = tx.c1;
#NSET2: [26, 1, 0]
  #PRJT2: [26, 1, 0]; exp_num(5), is_atom(FALSE)
    #NEST LOOP INDEX JOIN2: [26, 1, 0]
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #CSEK2: [19, 1, 0]; scan_type(UNIQUE),INDEX33555479(TX), scan_range[T1.C1,T1.C1]

34.  HASH2 INNER JOIN
HASH内连接（HI3）；无法利用索引时，系统一般采用HASH连接。
explain select *from t1, t2 where t1.c1 = t2.c1;
#NSET2: [13, 1, 0]
  #PRJT2: [13, 1, 0]; exp_num(4), is_atom(FALSE)
    #HASH2 INNER JOIN: [13, 1, 0];  KEY_NUM(1);
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #CSCN2: [6, 1, 0]; INDEX33555476(T2)

35.  INDEX JOIN SEMI JOIN2
索引半连接。在半连接的右表中，有索引可利用时使用，如下例tx(c1)上有索引。
explain select *from t1 where exists (select * from tx where t1.c1 = tx.c1);
#NSET2: [8, 1, 0]
  #PRJT2: [8, 1, 0]; exp_num(3), is_atom(FALSE)
    #INDEX JOIN SEMI JOIN2: [8, 1, 0];
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #CSEK2: [19, 1, 0]; scan_type(UNIQUE), INDEX33555479(TX), scan_range[T1.C1,T1.C1]

36.  HASH RIGHT SEMI JOIN2
HASH右半连接(HRS2)。半连接一般情况下，总是在左表建立HASH, 如果右表数据更少，则转化为右半连接。 
explain select * from tx where exists (select *from t1 where tx.c3 = t1.c2);
#NSET2: [40, 1, 0]
  #PRJT2: [40, 1, 0]; exp_num(4), is_atom(FALSE)
    #HASH RIGHT SEMI JOIN2: [40, 1, 0];
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #CSCN2: [23, 100000, 0]; INDEX33555479(TX)

37.  HASH RIGHT SEMI JOIN32
HASH右半连接。这个专门用来处理all/any/some等谓词。但all/any/some不是必须用这个操作符。
explain select *from tx where c3 > all(select c2 from t1);
#NSET2: [30, 100000, 0]
  #PRJT2: [30, 100000, 0]; exp_num(4), is_atom(FALSE)
    #HASH RIGHT SEMI JOIN32: [30, 100000, 0]; op all;, join condition(TX.C3 > DMTEMPVIEW_00001021.col_name)
      #CSCN2: [23, 100000, 0]; INDEX33555479(TX)
      #PRJT2: [6, 1, 0]; exp_num(1), is_atom(FALSE)
        #CSCN2: [6, 1, 0]; INDEX33555480(T1)

38.  MERGE SEMI JOIN3
归并半连接。如果连接的关键字正好是索引列，则可以使用。
explain select * from tx a where exists (select *from tx b where a.c1 = b.c1 and b.c3 = 10);
#NSET2: [27, 2500, 0]
  #PRJT2: [27, 2500, 0]; exp_num(4), is_atom(FALSE)
    #MERGE SEMI JOIN3: [27, 2500, 0];
      #CSCN2: [23, 100000, 0]; INDEX33555479(TX)
      #SLCT2: [23, 2500, 0]; TX.C3 = 10
        #CSCN2: [23, 100000, 0]; INDEX33555479(TX)

39.  CONST VALUE LIST
系统自动创建的一个常量列表，用于与实体表做连接。
explain select *from t1 where c1 in (1, 2, 3);
#NSET2: [6, 1, 0]
  #PRJT2: [6, 1, 0]; exp_num(3), is_atom(FALSE)
    #HASH2 INNER JOIN: [6, 1, 0];  KEY_NUM(1);
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #CONST VALUE LIST: [0, 3, 0]; row_num(3), col_num(1)

40.  HEAP TABLE/HEAP TABLE SCAN
有时，系统会把重复利用的中间保存在一个临时表中，这个表称为HEAP TABLE;与之配套的是，一个专门的扫描操作符号。(HTAB/HSCN)
explain with v1 as
(select count(*) from tx)
select *
from v1 a, v1 b;
#NSET2: [89, 1, 0]
  #PIPE2: [89, 1, 0]
    #PRJT2: [66, 1, 0]; exp_num(2), is_atom(FALSE)
      #NEST LOOP INNER JOIN2: [66, 1, 0];
        #HEAP TABLE SCAN: [22, 1, 0]; table_no(0),
        #HEAP TABLE SCAN: [22, 1, 0]; table_no(0),
    #HEAP TABLE: [22, 1, 0]; table_no(0),
      #PRJT2: [22, 1, 0]; exp_num(1), is_atom(FALSE)
        #FAGR2: [22, 1, 0]; sfun_num(1)

41.  FBTR
Fill Btr, 填充B树。建索引的时候使用。一般不能用explain看，到， 但是建索引的时候，可以在V$SQL_NODE_HISTORY中查到 。

42.  UFLT
(Filter for Update from)，这是个用于实现UPDATE FROM语句(SQL SERVER兼容性)的操作符号。以rowid作为key，建hash表，如果下层数据过来没有hash匹配项则插入到hash表，
explain update t1 set t1.c1 = tx.c2 from tx where t1.c2 = tx.c1;
#UPDATE : [0, 0, 0]; table(T1), type(select)
  #TEMP TABLE SPOOL: [26, 1, 0]
    #UFLT: [0, 0, 0]; IS_TOP_1(TRUE)
      #PRJT2: [26, 1, 0]; exp_num(2), is_atom(FALSE)
        #NEST LOOP INDEX JOIN2: [26, 1, 0]
          #CSCN2: [6, 1, 0]; INDEX33555480(T1)
          #CSEK2: [19, 1, 0]; scan_type(UNIQUE), INDEX33555479(TX), scan_range[T1.C2,T1.C2] 

43.  HIERARCHICAL QUERY (CNNTB)
用于实现层次查询。
explain select * from tx connect by prior c1 = c2  start with c3 = 0;
#NSET2: [118773, 12500000, 0]
  #PRJT2: [118773, 12500000, 0]; exp_num(3), is_atom(FALSE)
    #HIERARCHICAL QUERY: [118773, 12500000, 0];
      #PRJT2: [23, 2500, 0]; exp_num(4), is_atom(FALSE)
        #SLCT2: [23, 2500, 0]; TX.C3 = 0
          #CSCN2: [23, 100000, 0]; INDEX33555479(TX)
      #PRJT2: [23, 2500, 0]; exp_num(4), is_atom(FALSE)
        #SLCT2: [23, 2500, 0]; var1 = exp_cast(TX.C2)
          #CSCN2: [23, 100000, 0]; INDEX33555479(TX) 

44.  INDEX JOIN LEFT JOIN2
索引左外连接，使用右表的索引。
explain select * from t1 left join tx on t1.c1 = tx.c1;
#NSET2: [26, 1, 0]
  #PRJT2: [26, 1, 0]; exp_num(5), is_atom(FALSE)
    #INDEX JOIN LEFT JOIN2: [26, 1, 0]
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)
      #CSEK2: [19, 1, 0]; scan_type(UNIQUE), INDEX33555479(TX), scan_range[T1.C1,T1.C1] 

45.  MPP BROADCAST
Mpp模式下，消息广播到各站点，包含必要的聚集函数合并计算
46.  MPP GATHER
Mpp模式下，消息收集到主站点
47.  MPP DISTRIBUTE
Mpp模式下，消息各站点的相互重分发， 一般在连接前做
48.  MPP SCATTER
Mpp模式下，主站点向各从站点广播消息
49.  PARALLEL
水平分区表的并行查询

50.  RNSK
(Row number stop key),实现ORACLE兼容的rownum;
explain select * from tx where rownum = 10;
#NSET2: [23, 100000, 0]
  #PRJT2: [23, 100000, 0]; exp_num(4), is_atom(FALSE)
    #RNSK: [23, 100000, 0]; rownum = exp_cast(10)
      #CSCN2: [23, 100000, 0]; INDEX33555479(TX)

51.  CNTS
用于实现全文索引的CONTAINS

52.  SSCN
(second index scan), 直接使用2级索引进行扫描;
explain select c2 from tx;
#NSET2: [22, 100000, 0]
  #PRJT2: [22, 100000, 0]; exp_num(1), is_atom(FALSE)
    #SSCN: [22, 100000, 0]; IND2(TX)

53.  AFUN
分析函数计算。
explain
SELECT  c1, SUM(c3) OVER (PARTITION BY c1) FROM tx;
#NSET2: [23, 100000, 0]
  #PRJT2: [23, 100000, 0]; exp_num(2), is_atom(FALSE)
    #AFUN: [23, 100000, 0]; afun_num(1)
      #CSCN2: [23, 100000, 0]; INDEX33555479(TX)

54.  PSCN/ASCN/ESCN
PSCN： 批量参数当作表来扫描
ASCN:  数组当作表来扫描
ESCN:  外部表扫描

55.  DISTINCT
去重。
explain select distinct c1 from tx;
#NSET2: [22, 1000, 0]
  #PRJT2: [22, 1000, 0]; exp_num(1), is_atom(FALSE)
    #DISTINCT: [22, 1000, 0]
      #SSCN: [22, 100000, 0]; IND2(TX) 

56.  HASH LEFT SEMI MUTIPLE JOIN
多列HASH左半连接， 用于实现多列IN。
explain select * from t1 where (c1, c2) not in (select c1, c2 from tx);
#NSET2: [35, 1, 0]
  #PRJT2: [35, 1, 0]; exp_num(3), is_atom(FALSE)
    #HASH LEFT SEMI MULTIPLE JOIN: [35, 1, 0];  (ANTI), join condition((exp11 AND exp11))
      #CSCN2: [6, 1, 0]; INDEX33555480(T1)

57.  REMOTE / LSET
实现外部连接(DBLINK)。
REMOTE: 远程查询；
LSET:   远程的结果集

保定公民
关注
  • 3
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
DM执行计划
a457646454的博客
06-10 451
执行计划查看 执行计划是 SQL 语句的执行方式，由查询优化器为语句设计的执行方式，交给执行器去执行。在 SQL 命令行使用EXPLAIN可以打印出语句的执行计划。 EXPLAIN select * from DMHR.t2 where age > 60; ...
达梦数据库SQL参考资料
12-11
达梦数据库SQL参考资料为我们提供了一本全面的关于达梦数据库SQL语句的使用指南，涵盖了从基本语法到高级功能的多个方面。下面，我们将根据提供的目录和部分内容，详细阐述这些知识点。 首先，DM_SQL语言的特点是本...
达梦数据库执行计划操作符介绍
07-07
国产数据库达梦7的执行计划操作符介绍，理解了这些操作符，能更好的读懂执行计划
达梦SQL优化之-执行计划操作符解读
weixin_42018955的博客
01-17 1696
达梦SQL优化之-执行计划操作符解读
达梦数据库系列—38.全文检索
最新发布
md54333的博客
07-30 1139
中文最多分词：可以将存在二义性的词划分出来，例如：“和服装”会生成“和”、“和服”、“服”、“服装”和“装”。中文最少分词：最少分词，其消除了存在二义性的词，即前面举例的文本分词的结果为“和”、“服装”两个词，这样可以减少大量冗余词的存储，能进行更准确的匹配。对于非结构化数据，即全文数据，要想实现检索，一般都是采用模糊查询的方式实现的。当用户填充全文索引时，系统才将定义了全文索引的文本列的内容进行分词，并根据分词结果填充索引。英文分词：即根据英文分隔符的分词，对超过 32 个字节的英文单词进行了拆分处理。
达梦关于单表查询的执行计划操作符
weixin_44665741的博客
03-13 754
执行计划操作符是SQL执行的基本单元，所有的SQL语句最终都是转换成一连串的操作符最后在数据库中执行，得到需要的结果，操作符也是读懂执行计划的基础。 单表查询相关的操作符含义 CSCN ： 基础全表扫描(a)，从头到尾，全部扫描 SSCN ： 二级索引扫描(b), 从头到尾，全部扫描 SSEK ： 二级索引范围扫描(b) ，通过键值精准定位到范围或者单值 CSEK ： 聚簇索引范围扫描© ， 通过键值精准定位到范围或者单值 BLKUP ： 根据二级索引的ROWID 回原表中取出全部数据(b + a) 1）C
性能调优第三篇-执行计划常见操作符
Owen_Zeng 的博客
09-16 1051
前面的文章知道了如何格式化，和如何查看执行计划。这篇文章主要介绍常见的操作符
常用执行计划操作符
weixin_30236595的博客
08-19 127
一、数据访问操作符 1、SCAN操作符：扫描操作主要分为3种 Table Scan：当针对一个表（没有聚集索引、堆表）执行一个查询语句时， 此时将会做全表扫描操作（如果有where子句，则先执行全表扫描操作，然后在针对结果集做Filter操作） 示例： Cluster Index Scan：聚集索引扫描，表中所有的数据都存在于聚集索引的叶节点中，因此聚集索引扫描相当于将整个表中...
达梦数据库_SQL语言手册
03-19
达梦数据库_SQL语言手册.pdf 数据库快照定义语句 数据库快照删除语句 第章数据查询语句和全文检索语句 单表查询 简单查询 带条件查询 集函数 情况表达式 连接查询 子查询 标量子查询 表子查询 派生表子...
达梦数据库-oci编程例子
02-26
在达梦数据库的例子中，可以使用预编译语句提高效率，特别是当同一SQL语句需要多次执行时。 3. **绑定变量**：oci编程中，可以将变量绑定到SQL语句中的占位符，使得数据的传递更加灵活。在达梦数据库中，这一过程...
达梦 dmrman 备份报错 os_pipe2_conn_server open failed 记录
南猿北辙
10-31 639
做全备测试的时候碰到下面情况，此时数据库服务已经关闭。 [dmdba@localhost ~]$ dmrman dmrman V7.6.0.197-Build(2019.09.12-112648)ENT RMAN> backup database '/dm7/data/DM01/dm.ini'; backup database '/dm7/data/DM01/dm.ini'; file d...
达梦全文索引
qq_36192280的博客
03-03 438
create table context_test(name varchar(10),sys_time timestamp,con_text varchar(5000)) insert into context_test values('艾克','2019-03-19 14:19:35','很多人梦想着穿越时空,但并不是每个人都可以拥有这种体质。生活在祖安的艾克与其他人一样曾经是一个普通的的孩子,直到有一天,一名身披暗色斗篷的怪异科学家找上他。科学家声称他发明了可以时空穿梭的便携式机器,遗憾的是,却没有人
达梦数据库字符串连接用什么符号？
龙山溪笔记
09-05 7123
不同的数据库字符串连接有用不同的符号，比如SQLSERVER用 +，Oracle用 || 早期的达梦版本两种都支持，新版本只支持 || 因为 + 同时作为连接符和运算符会有歧义，例如下面这个sql： select '1' + '1' from dual; 结果应该是 2 还是 11 呢？ 达梦还可以像mysql一样用 concat函数 select concat('1','1') ...
达梦数据库DM7强制索引
wumengjie0418的博客
11-24 1186
达梦数据库DM7强制索引
达梦数据库执行计划查看
weixin_42942173的博客
08-09 3821
本文主要讲述达梦数据库执行计划怎么看，通过什么工具看、总结了执行计划里面操作符含义及对应的执行计划举例。
达梦数据库集合操作符的运用
键盘上的艺术
02-19 2601
前言 如果我们需要将两个不同的select 语句的结果集合并到一起显示，我们就要用到Union关键字。Union或Union all关键字的作用是将多个结果作为一个整体来展示，除此之外，DM7中提供了 intersect和except操作符来进行集合操作。 创建演示环境 录入几条测试数据 Union 和 Union All的运用 Union和Union All操作符都是用来对操作结果取并集...
视图合并、hash join连接列数据分布不均匀引发的惨案
FaN()
08-26 2464
表大小SQL> select count(*) from agent.TB_AGENT_INFO; COUNT(*) ---------- 1751SQL> select count(*) from TB_CHANNEL_INFO ; COUNT(*) ---------- 1807SQL> select count(*) from TB_USER_CHANNEL; C
Nested Loops Join(嵌套连接)
wangyihbu的专栏
02-26 2087
Nested Loops Join(嵌套连接)Sql Server支持三种物理连接：nested loops join,merge join和hash join.这篇文章,我将描述nested loops join(或者简称为NL)。基本算法最简单的情况是,nested loop会以连接谓词为条件取出一张表里的每一行(称为外部表)与另外一张表(称为内部表)的每一行进行比较来寻找符合条件的行。(注意这里的"内部"和"外部"是具有多层含义的,必须从上下文中来理解它们。"内部表"和"外部表"是指连接的输入,"内连
达梦数据库的存储引擎
04-25
达梦数据库是一种关系型数据库管理系统，它支持多种存储引擎。以下是达梦数据库的几种常见存储引擎： 1. DMSE：DMSE（达梦存储引擎）是达梦数据库的默认存储引擎。它采用B+树索引结构，支持事务和并发控制，并提供了高性能的数据访问和查询能力。 2. InnoDB：InnoDB是一种支持事务和行级锁的存储引擎。它具有较好的并发性能和数据完整性，适用于高并发的应用场景。 3. MyISAM：MyISAM是一种不支持事务和行级锁的存储引擎。它具有较高的插入和查询性能，适用于读写比较平衡的应用场景。 4. Memory：Memory存储引擎将数据存储在内存中，提供了非常高的读写性能。但由于数据存储在内存中，断电或重启会导致数据丢失，适用于对数据持久性要求不高的场景。 5. Archive：Archive存储引擎主要用于归档和压缩数据，适用于大量历史数据的存储和查询。 6. NDB Cluster：NDB Cluster是一种分布式存储引擎，支持高可用性和水平扩展。它适用于大规模的分布式数据库集群。 以上是达梦数据库的一些常见存储引擎，不同的存储引擎适用于不同的应用场景和需求。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

保定公民

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值