达梦数据库SQL调优之优化器提示

NICOIOOI

已于 2022-09-04 13:52:07 修改

阅读量1k

点赞数 1

分类专栏：达梦数据库文章标签：数据库 sql

于 2022-09-04 12:31:26 首次发布

本文链接：https://blog.csdn.net/lxm13613538669/article/details/126687947

版权

达梦数据库专栏收录该内容

9 篇文章 0 订阅

订阅专栏

DM查询优化器采用基于代价的估算方法。大多数情况下，估算的代价都是准确的，在一些比较特殊的场合，由于统计信息陈旧，或者抽样数据不能很好地反映数据分布时，优化器选择的执行计划不是”最优“的，甚至可能是很差的执行计划。

这时，DBA就可以通过HINT进行人工干预，指示优化器按照指定的方法去选择SQL的执行计划。如果优化器无法生产相应的执行计划，该HINT将会被忽略。

HINT常见格式：

SELECT /*+ HINT1 [HINT2]*/ 列名 FROM 表名 WHERE_CLAUSE ;
UPDATE 表名 /*+ HINT1 [HINT2]*/ SET 列名 =变量 WHERE_CLAUSE ;
DELETE FROM 表名 /*+ HINT1 [HINT2]*/ WHERE_CLAUSE ;

INI参数提示

支持使用HINT的INI参数可通过 V$HINT_INI_INFO 动态视图查询。

支持HINT的INI参数分为两类：一是HINT_TYPE 为 OPT，表示分析阶段使用的参数；二是HINT_TYPE为EXEC，表示运行阶段使用的参数，运行阶段使用的参数对于视图无效。

示例：

explain select * from sysobjects a, sysobjects b where a.id=b.pid ;
1   #NSET2: [1, 973, 792] 
2     #PRJT2: [1, 973, 792]; exp_num(34), is_atom(FALSE) 
3       #HASH2 INNER JOIN: [1, 973, 792]; LKEY_UNIQUE KEY_NUM(1); KEY(A.ID=B.PID) KEY_NULL_EQU(0)
4         #CSCN2: [1, 973, 396]; SYSINDEXSYSOBJECTS(SYSOBJECTS as A)
5         #CSCN2: [1, 973, 396]; SYSINDEXSYSOBJECTS(SYSOBJECTS as B)

explain select  /*+ENABLE_HASH_JOIN(0)*/ * from sysobjects a, sysobjects b where a.id=b.pid 
1   #NSET2: [6, 973, 792] 
2     #PRJT2: [6, 973, 792]; exp_num(34), is_atom(FALSE) 
3       #NEST LOOP INDEX JOIN2: [6, 973, 792] 
4         #CSCN2: [1, 973, 396]; SYSINDEXSYSOBJECTS(SYSOBJECTS as B)
5         #BLKUP2: [6, 1, 0]; SYSINDEXIDSYSOBJECTS(A)
6           #SSEK2: [6, 1, 0]; scan_type(ASC), SYSINDEXIDSYSOBJECTS(SYSOBJECTS as A), scan_range[B.PID,B.PID]

索引提示

使用索引

DM 提供的 HINT 为表索引的选择 HINT，它指示使用指定索引进行数据检索。

语法：

表名 + INDEX + 索引名
或
/*+ INDEX (表名[,] 索引名) {INDEX (表名[,] 索引名)} */

一个语句中最多指定 8 个索引。在后一种语法格式中，如果查询中给出了表的别名那么必须使用别名。

示例：

DROP TABLE T1 CASCADE;
CREATE TABLE T1 (ID INTEGER,NAME VARCHAR(128));
CREATE INDEX IDX_T1_ID ON T1(ID);
CREATE INDEX IDX_T1_NAME ON T1(NAME);

explain SELECT * FROM T1 WHERE ID > 2011 AND NAME < 'XXX';
1   #NSET2: [1, 1, 60] 
2     #PRJT2: [1, 1, 60]; exp_num(3), is_atom(FALSE) 
3       #SLCT2: [1, 1, 60]; (T1.ID > 2011 AND T1.NAME < 'XXX')
4         #CSCN2: [1, 1, 60]; INDEX33555526(T1)

explain SELECT * FROM T1 INDEX IDX_T1_ID WHERE ID > 2011 AND NAME < 'XXX';
1   #NSET2: [1, 1, 60] 
2     #PRJT2: [1, 1, 60]; exp_num(3), is_atom(FALSE) 
3       #SLCT2: [1, 1, 60]; T1.NAME < 'XXX'
4         #BLKUP2: [1, 1, 60]; IDX_T1_ID(T1)
5           #SSEK2: [1, 1, 60]; scan_type(ASC), IDX_T1_ID(T1), scan_range(2011,max]

explain SELECT /*+INDEX(T1, IDX_T1_ID) */ * FROM T1 WHERE ID > 2011 AND NAME < 'XXX';
1   #NSET2: [1, 1, 60] 
2     #PRJT2: [1, 1, 60]; exp_num(3), is_atom(FALSE) 
3       #SLCT2: [1, 1, 60]; T1.NAME < 'XXX'
4         #BLKUP2: [1, 1, 60]; IDX_T1_ID(T1)
5           #SSEK2: [1, 1, 60]; scan_type(ASC), IDX_T1_ID(T1), scan_range(2011,max]

不使用索引

类似地，也有不使用索引的HINT. 语法如下：

/*+ NO_INDEX (表名[,] 索引名) { NO_INDEX (表名[,] 索引名)} */

可以指定多个索引，则这些索引都不能被使用。一个语句中最多指定 8 个索引。

连接方法提示

DBA 可以通过指定两个表间的连接方法来检测不同连接方式的查询效率，指定的连接可能由于无法实现或代价过高而被忽略。如果连接方法提示中的表名(别名)或索引名无效也会被自动忽略。

DROP TABLE T1 CASCADE;
DROP TABLE T2 CASCADE;
CREATE TABLE T1 (ID INTEGER,NAME VARCHAR(128));
CREATE TABLE T2 (ID INTEGER,NAME VARCHAR(128));
begin
for i in 1..1000 loop
insert into T1 values(i,'dameng'||i);
insert into T2 values(i+500,'damengsh'||i);
end loop;
end;

哈希连接

使用指定顺序的哈希连接

EXPLAIN SELECT /*+ USE_HASH(T1, T2) */ * FROM T1, T2 WHERE T1.id = T2.id;
1   #NSET2: [1, 9800, 104] 
2     #PRJT2: [1, 9800, 104]; exp_num(4), is_atom(FALSE) 
3       #HASH2 INNER JOIN: [1, 9800, 104];  KEY_NUM(1); KEY(T1.ID=T2.ID) KEY_NULL_EQU(0)
4         #CSCN2: [1, 1000, 52]; INDEX33555529(T1)
5         #CSCN2: [1, 1000, 52]; INDEX33555530(T2)

不使用指定顺序的哈希连接

EXPLAIN SELECT /*+ NO_USE_HASH(T1, T2) */ * FROM T1, T2 WHERE T1.id = T2.id;
1   #NSET2: [1, 9800, 104] 
2     #PRJT2: [1, 9800, 104]; exp_num(4), is_atom(FALSE) 
3       #HASH2 INNER JOIN: [1, 9800, 104];  KEY_NUM(1); KEY(T2.ID=T1.ID) KEY_NULL_EQU(0)
4         #CSCN2: [1, 1000, 52]; INDEX33555530(T2)
5         #CSCN2: [1, 1000, 52]; INDEX33555529(T1)

NO_USE_HASH(T1, T2)表示不允许 T1 作为左表，T2 作为右表的哈希连接，但 T1 作为右表的哈希连接还是允许的。

嵌套循环连接

使用嵌套循环连接

EXPLAIN SELECT /*+ USE_NL(a, b) */ * FROM T1 a, T2 b WHERE a.ID = b.ID;
1   #NSET2: [24685, 9800, 104] 
2     #PRJT2: [24685, 9800, 104]; exp_num(4), is_atom(FALSE) 
3       #SLCT2: [24685, 9800, 104]; A.ID = B.ID
4         #NEST LOOP INNER JOIN2: [24685, 9800, 104]; 
5           #CSCN2: [1, 1000, 52]; INDEX33555529(T1 as A)
6           #CSCN2: [1, 1000, 52]; INDEX33555530(T2 as B)

不使用嵌套循环连接

EXPLAIN SELECT /*+ NO_USE_NL(a, b) */ * FROM T1 a, T2 b WHERE a.ID = b.ID;
1   #NSET2: [1, 9800, 104] 
2     #PRJT2: [1, 9800, 104]; exp_num(4), is_atom(FALSE) 
3       #HASH2 INNER JOIN: [1, 9800, 104];  KEY_NUM(1); KEY(A.ID=B.ID) KEY_NULL_EQU(0)
4         #CSCN2: [1, 1000, 52]; INDEX33555529(T1 as A)
5         #CSCN2: [1, 1000, 52]; INDEX33555530(T2 as B)

索引连接

CREATE INDEX IDX_T2_ID ON T2(ID);

使用索引连接

当连接情况为左表+右表索引时，强制两个表间使用索引连接.

示例：

EXPLAIN SELECT /*+ USE_NL_WITH_INDEX(T1, IDX_T2_ID) */ * FROM T1, T2 WHERE T1.ID = T2.ID;
1   #NSET2: [6, 3000, 104] 
2     #PRJT2: [6, 3000, 104]; exp_num(4), is_atom(FALSE) 
3       #NEST LOOP INDEX JOIN2: [6, 3000, 104] 
4         #CSCN2: [1, 1000, 52]; INDEX33555529(T1)
5         #BLKUP2: [6, 3, 0]; IDX_T2_ID(T2)
6           #SSEK2: [6, 3, 0]; scan_type(ASC), IDX_T2_ID(T2), scan_range[T1.ID,T1.ID]

不使用索引连接

当连接情况为左表+右表索引时，强制两个表间不能使用索引连接。

示例：

EXPLAIN SELECT /*+ NO_USE_NL_WITH_INDEX(T1, IDX_T2_ID) */ * FROM T1, T2 WHERE T1.ID = T2.ID;
1   #NSET2: [1, 9800, 104] 
2     #PRJT2: [1, 9800, 104]; exp_num(4), is_atom(FALSE) 
3       #HASH2 INNER JOIN: [1, 9800, 104];  KEY_NUM(1); KEY(T1.ID=T2.ID) KEY_NULL_EQU(0)
4         #CSCN2: [1, 1000, 52]; INDEX33555529(T1)
5         #CSCN2: [1, 1000, 52]; INDEX33555530(T2)

DROP INDEX IDX_T2_ID;

归并连接

CREATE INDEX IDX_T1_ID ON T1(ID);
CREATE INDEX IDX_T2_ID ON T2(ID);
STAT 100 ON T1(ID);
STAT 100 ON T2(ID);

使用归并连接

EXPLAIN SELECT /*+ USE_MERGE(T1,T2) */ * FROM T1, T2 WHERE T1.ID = T2.ID AND T1.ID < 1 AND T2.ID < 1;
1   #NSET2: [1, 1, 104] 
2     #PRJT2: [1, 1, 104]; exp_num(4), is_atom(FALSE) 
3       #MERGE INNER JOIN3: [1, 1, 104]; KEY_NUM(1); KEY(COL_0 = COL_0) KEY_NULL_EQU(0)
4         #BLKUP2: [1, 1, 52]; IDX_T1_ID(T1)
5           #SSEK2: [1, 1, 52]; scan_type(ASC), IDX_T1_ID(T1), scan_range(null2,1)
6         #BLKUP2: [1, 1, 52]; IDX_T2_ID(T2)
7           #SSEK2: [1, 1, 52]; scan_type(ASC), IDX_T2_ID(T2), scan_range(null2,1)

不使用归并连接

EXPLAIN SELECT /*+ NO_USE_MERGE(T1,T2) */ * FROM T1, T2 WHERE T1.ID = T2.ID AND T1.ID < 1 AND T2.ID < 1;
1   #NSET2: [1, 1, 104] 
2     #PRJT2: [1, 1, 104]; exp_num(4), is_atom(FALSE) 
3       #SLCT2: [1, 1, 104]; T2.ID < 1
4         #HASH2 INNER JOIN: [1, 1, 104];  KEY_NUM(1); KEY(T1.ID=T2.ID) KEY_NULL_EQU(0)
5           #SLCT2: [1, 1, 104]; T2.ID < 1
6             #NEST LOOP INDEX JOIN2: [1, 1, 104] 
7               #ACTRL: [1, 1, 104];
8                 #BLKUP2: [1, 1, 52]; IDX_T1_ID(T1)
9                   #SSEK2: [1, 1, 52]; scan_type(ASC), IDX_T1_ID(T1), scan_range(null2,1)
10              #BLKUP2: [1, 1, 0]; IDX_T2_ID(T2)
11                #SSEK2: [1, 1, 0]; scan_type(ASC), IDX_T2_ID(T2), scan_range[T1.ID,T1.ID]
12          #CSCN2: [1, 1000, 52]; INDEX33555530(T2)

DROP INDEX IDX_T1_ID;
DROP INDEX IDX_T2_ID;

半连接

仅OPTIMIZER_MODE=1 有效。

半连接转换为等价内连接

示例：

EXPLAIN SELECT /*+ SEMI_GEN_CROSS OPTIMIZER_MODE(1) */ COUNT(*) FROM T1 A WHERE A.ID IN (SELECT B.ID FROM T1 B);
1   #NSET2: [2, 1, 8] 
2     #PRJT2: [2, 1, 8]; exp_num(1), is_atom(FALSE) 
3       #AAGR2: [2, 1, 8]; grp_num(0), sfun_num(1), distinct_flag[0]; slave_empty(0)
4         #HASH2 INNER JOIN: [2, 1000, 8]; LKEY_UNIQUE KEY_NUM(1); KEY(DMTEMPVIEW_16779696.colname=A.ID) KEY_NULL_EQU(0)
5           #DISTINCT: [1, 1000, 4]
6             #PRJT2: [1, 1000, 4]; exp_num(1), is_atom(FALSE) 
7               #SSCN: [1, 1000, 4]; IDX_T1_ID(T1 as B)
8           #SSCN: [1, 1000, 4]; IDX_T1_ID(T1 as A)

半连接不转换为等价的内连接

示例：

EXPLAIN SELECT /*+ NO_SEMI_GEN_CROSS OPTIMIZER_MODE(1) */ COUNT(*) FROM T1 A WHERE A.ID IN (SELECT B.ID FROM T1 B);
1   #NSET2: [1, 1, 4] 
2     #PRJT2: [1, 1, 4]; exp_num(1), is_atom(FALSE) 
3       #AAGR2: [1, 1, 4]; grp_num(0), sfun_num(1), distinct_flag[0]; slave_empty(0)
4         #MERGE SEMI JOIN3: [1, 1000, 4];   KEY(COL_0 = COL_0) KEY_NULL_EQU(0)
5           #SSCN: [1, 1000, 4]; IDX_T1_ID(T1 as A)
6           #SSCN: [1, 1000, 4]; IDX_T1_ID(T1 as B)

变量改写

仅OPTIMIZER_MODE=1 有效。

使用变量改写连接

适合驱动表数据量少而另一侧计划较复杂的场景。

EXPLAIN SELECT /*+ USE_CVT_VAR OPTIMIZER_MODE(1) */ COUNT(*) FROM T1 A WHERE A.id = 1001 AND EXISTS (SELECT 1 FROM T1 B, T1 C WHERE B.id = C.id AND A.name= B.name);
1   #NSET2: [1, 1, 52] 
2     #PRJT2: [1, 1, 52]; exp_num(1), is_atom(FALSE) 
3       #AAGR2: [1, 1, 52]; grp_num(0), sfun_num(1), distinct_flag[0]; slave_empty(0)
4         #NEST LOOP SEMI JOIN2: [1, 1, 52];  join condition(A.NAME = DMTEMPVIEW_16779711.colname)[with var]
5           #BLKUP2: [1, 1, 52]; IDX_T1_ID(A)
6             #SSEK2: [1, 1, 52]; scan_type(ASC), IDX_T1_ID(T1 as A), scan_range[1001,1001]
7           #PRJT2: [1, 25, 56]; exp_num(1), is_atom(FALSE) 
8             #HASH2 INNER JOIN: [1, 25, 56];  KEY_NUM(1); KEY(B.ID=C.ID) KEY_NULL_EQU(0)
9               #SLCT2: [1, 25, 52]; B.NAME = var1
10                #CSCN2: [1, 1000, 52]; INDEX33555529(T1 as B)
11              #SSCN: [1, 1000, 4]; IDX_T1_ID(T1 as C)

不使用变量改写连接

EXPLAIN SELECT /*+ NO_USE_CVT_VAR OPTIMIZER_MODE(1) */ COUNT(*) FROM T1 A WHERE A.id = 1001 AND EXISTS (SELECT 1 FROM T1 B, T1 C WHERE B.id = C.id AND A.name= B.name);
1   #NSET2: [2, 1, 52] 
2     #PRJT2: [2, 1, 52]; exp_num(1), is_atom(FALSE) 
3       #AAGR2: [2, 1, 52]; grp_num(0), sfun_num(1), distinct_flag[0]; slave_empty(0)
4         #HASH LEFT SEMI JOIN2: [2, 1, 52]; KEY_NUM(1);  KEY(A.NAME=DMTEMPVIEW_16779723.colname) KEY_NULL_EQU(0)
5           #BLKUP2: [1, 1, 52]; IDX_T1_ID(A)
6             #SSEK2: [1, 1, 52]; scan_type(ASC), IDX_T1_ID(T1 as A), scan_range[1001,1001]
7           #PRJT2: [1, 1000, 56]; exp_num(1), is_atom(FALSE) 
8             #HASH2 INNER JOIN: [1, 1000, 56];  KEY_NUM(1); KEY(C.ID=B.ID) KEY_NULL_EQU(0)
9               #SSCN: [1, 1000, 4]; IDX_T1_ID(T1 as C)
10              #CSCN2: [1, 1000, 52]; INDEX33555529(T1 as B)

归并连接

一般情况下，归并连接需要左右孩子的数据按照连接列有序，使用此优化器提示时，优化器将考虑通过插入排序操作符的方式实现归并连接，仅 OPTIMIZER_MODE=1 有效。

--不加HINT
EXPLAIN SELECT /*+ stat(T1 1M) stat(T2 1M) */COUNT(*) FROM T1, T2 WHERE T1.NAME=T2.NAME AND T1.ID=T2.ID;
1   #NSET2: [442, 1, 104] 
2     #PRJT2: [442, 1, 104]; exp_num(1), is_atom(FALSE) 
3       #AAGR2: [442, 1, 104]; grp_num(0), sfun_num(1), distinct_flag[0]; slave_empty(0)
4         #HASH2 INNER JOIN: [442, 2, 104];  KEY_NUM(2); KEY(T1.NAME=T2.NAME AND T1.ID=T2.ID) KEY_NULL_EQU(0, 0)
5           #CSCN2: [115, 1000000, 52]; INDEX33555529(T1)
6           #CSCN2: [115, 1000000, 52]; INDEX33555530(T2)

--加HINT
EXPLAIN SELECT /*+ stat(T1 1M) stat(T2 1M) */ /*+ENHANCED_MERGE_JOIN*/COUNT(*) FROM T1, T2 WHERE T1.NAME=T2.NAME AND T1.ID=T2.ID;
1   #NSET2: [436, 1, 104] 
2     #PRJT2: [436, 1, 104]; exp_num(1), is_atom(FALSE) 
3       #AAGR2: [436, 1, 104]; grp_num(0), sfun_num(1), distinct_flag[0]; slave_empty(0)
4         #MERGE INNER JOIN3: [436, 2, 104]; KEY_NUM(2); KEY(COL_0 = COL_0 AND COL_1 = COL_1) KEY_NULL_EQU(0, 0)
5           #SORT3: [122, 1000000, 52]; key_num(2), is_distinct(FALSE), top_flag(0), is_adaptive(0)
6             #CSCN2: [115, 1000000, 52]; INDEX33555529(T1)
7           #SORT3: [122, 1000000, 52]; key_num(2), is_distinct(FALSE), top_flag(0), is_adaptive(0)
8             #CSCN2: [115, 1000000, 52]; INDEX33555530(T2)

连接顺序提示

多表连接时优化器会考虑各种可能的排列组合顺序。使用 ORDER HINT 指定连接顺序提示可以缩小优化器试探的排列空间，进而得到接近 DBA 所期望的查询计划。如果连接顺序和连接方法提示同时指定且二者间存在自相矛盾，优化器会以连接顺序提示为准。

语法：

/*+ ORDER (T1, T2 , T3, … tn ) */

示例：

CREATE TABLE T1(C1 INT,C2 VARCHAR);
CREATE TABLE T2(D1 INT,D2 VARCHAR);
CREATE TABLE T3(E1 INT,E2 VARCHAR);
CREATE TABLE T4(F1 INT,F2 VARCHAR);

EXPLAIN SELECT /*+ OPTIMIZER_MODE(1), ORDER(T1,T2,T3,T4) ,USE_HASH(T1,T2), USE_HASH(T2,T3), USE_HASH(T3,T4)*/* FROM T1,T2,T3,T4 WHERE T1.c1=T2.d1 AND T2.d2 = T3.e2 AND T3.e1 = T4.f1;
1   #NSET2: [2, 1, 208] 
2     #PRJT2: [2, 1, 208]; exp_num(8), is_atom(FALSE) 
3       #HASH2 INNER JOIN: [2, 1, 208];  KEY_NUM(1); KEY(T3.E1=T4.F1) KEY_NULL_EQU(0)
4         #HASH2 INNER JOIN: [1, 1, 156];  KEY_NUM(1); KEY(T2.D2=T3.E2) KEY_NULL_EQU(0)
5           #HASH2 INNER JOIN: [1, 1, 104];  KEY_NUM(1); KEY(T1.C1=T2.D1) KEY_NULL_EQU(0)
6             #CSCN2: [1, 1, 52]; INDEX33555533(T1)
7             #CSCN2: [1, 1, 52]; INDEX33555534(T2)
8           #CSCN2: [1, 1, 52]; INDEX33555535(T3)
9         #CSCN2: [1, 1, 52]; INDEX33555536(T4)

统计信息提示

优化器在计划优化阶段会自动获取基表的行数。但是一些特殊类型的表行数估算并不准确，或者 DBA 希望了解表大小对计划影响的时候，需要手动设置表的行数。

语法：

/*+ STAT (表名, 行数) */

统计信息提示只能针对基表设置，视图和派生表等对象设置无效。如果表对象存在别名则必须使用别名。行数只能使用整数，或者整数+K（千），整数+M（百万），整数+G（十亿）。行数提示设置后，统计信息的其它内容也会做相应的调整。

示例：

CREATE TABLE T_S(C1 INT);
INSERT INTO T_S SELECT LEVEL FROM DUAL CONNECT BY LEVEL<= 100;
COMMIT;
STAT 100 ON T_S(C1);
EXPLAIN SELECT /*+ STAT(T_S,1M) */ * FROM T_S WHERE C1 <= 10;

--加HINT
EXPLAIN SELECT /*+ STAT(T_S,1M) */ * FROM T_S WHERE C1 <= 10;
1   #NSET2: [116, 100000, 12] 
2     #PRJT2: [116, 100000, 12]; exp_num(2), is_atom(FALSE) 
3       #SLCT2: [116, 100000, 12]; T_S.C1 <= 10
4         #CSCN2: [116, 1000000, 12]; INDEX33555537(T_S)

--不加HINT
EXPLAIN SELECT  * FROM T_S WHERE C1 <= 10;
1   #NSET2: [1, 10, 12] 
2     #PRJT2: [1, 10, 12]; exp_num(2), is_atom(FALSE) 
3       #SLCT2: [1, 10, 12]; T_S.C1 <= 10
4         #CSCN2: [1, 100, 12]; INDEX33555537(T_S)

忽略重复键值提示

当执行 INSERT 操作时，如果存在 UNIQUE 索引，那么发生了重复键值冲突。使用 HINT IGNORE_ROW_ON_DUPKEY_INDEX 则可以忽略该冲突，冲突数据既不进行插入也不会报错，其他非冲突插入正常进行。每一个该 HINT 仅对应一个索引，如需忽略多个索引上的重复键值冲突，请指定多个 HINT。

语法：

/*+IGNORE_ROW_ON_DUPKEY_INDEX(<表名>(<列名>{,<列名>}))*/

若 INSERT 的目标表具有别名，则只有<表名>与别名一致时 HINT 才生效。该 HINT 指定的<列名>必须是某个 UNIQUE 索引的前导列或者全部列，否则报错；当作为前导列时，不能出现其它也将这些列作为前导列的 UNIQUE 索引，否则报错。指定该 HINT 时，不支持insert 操作的批量优化处理。

示例：

drop table t1;
create table t1(c1 int, c2 int, c3 int, c4 int);
create unique index t1i1 on t1(c1,c2,c3);
insert into t1 values (1,2,1,1);
insert into t1 values (1,2,1,1); --报错
insert /*+IGNORE_ROW_ON_DUPKEY_INDEX(t1(c1,c2,c3))*/ into t1 values (1,2,1,1); --不报错

禁用计划缓存提示

使用 HINT PLAN_NO_CACHE 禁用计划缓存，当前语句的执行计划将不会被缓存。

语法:

/*+PLAN_NO_CACHE*/

示例：

drop table t1;
create table t1(c1 int);
--执行计划生成后不缓存
select /*+PLAN_NO_CACHE*/ * from t1; 
--执行计划生成后缓存
select * from t1; 
--重用上一条select生成的执行计划
select * from t1;

更多文章见达梦社区：http://eco.dameng.com

NICOIOOI

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
达梦数据库SQL调优之优化器提示

DM查询优化器采用基于代价的估算方法。大多数情况下，估算的代价都是准确的，在一些比较特殊的场合，由于统计信息陈旧，或者抽样数据不能很好地反映数据分布时，优化器选择的执行计划不是”最优“的，甚至可能是很差的执行计划。这时，DBA就可以通过HINT进行人工干预，指示优化器按照指定的方法去选择SQL的执行计划。如果优化器无法生产相应的执行计划，该HINT将会被忽略。
复制链接

扫一扫