功能说明：为 SQL 注入 HINT 规则。SF_INJECT_HINT 方法创建的 HINT 规则无生效类别限制，如果需要为该 HINT 规则设置生效类别，可通过 SF_ALTER_HINT 过程修改实现。

参数说明：
sql_text：待注入 HINT 规则的 SQL 语句。SQL 语句必须是语法正确的增删改查语句。
hint_text：待注入的 HINT 规则，必须指定为非 NULL 值。
name：HINT 规则的名称，指定为 NULL 值时系统为其命名。
description：对 HINT 规则的详细描述。
validate：HINT 规则是否生效。TRUE 是；FALSE 否。
fuzzy：指定 SQL 的匹配规则为精准匹配或模糊匹配，该参数值不能为 NULL。
当该参数缺省时，表示使用定义 1 的语法，仅支持精准匹配。
该参数类型为 BOOLEAN 时，使用定义 2 或定义 3 的语法，值为 TRUE 时，为模糊匹配；
值为 FALSE 时，为精准匹配。
精准匹配时，待注入 HINT 规则的 SQL 语句必须为语法正确的 INSERT/DELETE/UPDATE/SELECT/MERGE INTO 语句（语句以 EXPLAIN/EXPLAIN FOR 开头时，去掉 EXPLAIN/EXPLAIN FOR 后的语句必须完全正确），精准匹配要求 SQL 语句完全匹配，不支持 SQL 语句中的子查询匹配；
模糊匹配时，待注入 HINT 规则的 SQL 语句应为非 NULL 值。
该参数类型为 INT 时，使用定义 4 或定义 5 的语法，值为 0 表示精确匹配，值为 1 表示模糊匹配，值为 2 表示通过 sql_text_id精确匹配。
fuzzy 取值为 2 时，参数 sql_text 应该输入长度为 13 的 sql_text_id 字段，如果 fuzzy 取值为 2 但参数 sql_text 依旧输入 SQL 语句，预期会报错。
need_clear：是否同步清空所有缓存的计划，该参数值不能为 NULL。
当该参数缺省时，表示使用定义 1、定义 2 或定义 4 的语法，此时默认不清空缓存计划。
指定该参数时，使用定义 3 和定义 5 的语法，值为 TRUE 时，清空缓存的计划；值为 FALSE 时，模糊匹配和通过 sql_text_id 匹配时，不清空缓存的计划，需要手动清除对应 SQL 的计划后，指定的 HINT 才能生效，精确匹配时，默认会删除受影响 SQL 的计划缓存。

返回值：执行成功返回名称，执行失败报错误信息。

二、使用

--模糊匹配
SF_INJECT_HINT('SQL语句', 'HINT', 'INJECT名称', '注释', TRUE, TRUE);

注入HINT后需要清空对应SQL的计划缓存

BEGIN
    FOR RS IN (SELECT * FROM V$CACHEPLN WHERE SQLSTR LIKE '%SQL语句%') LOOP
        EXECUTE IMMEDIATE 'SP_CLEAR_PLAN_CACHE(' || RS.CACHE_ITEM || ');';
    END LOOP;
END;

查询已经注入的HINT-系统视图

SELECT * FROM SYSINJECTHINT ORDER BY CRTDATE DESC;

删除注入的HINT

SF_DEINJECT_HINT('INJECT名称');

一、赋分制的由来

想象一下：化学考试特别难，全省平均只有45分；而生物考试简单，平均高达75分。此时如果直接用原始分计入高考总分，选化学的同学岂不是太吃亏了？

所以赋分制就是要建立一个公平竞技场，让不同科目的成绩能够公平比较！

二、赋分规则详解

根据福建省教育厅文件，赋分规则分三部分：需赋分科目、等级划分和分数转换。物理、历史直接使用原始分，满分100分；政治、地理、化学、生物则需赋分转换，最终同样满分100分。

为什么物理和历史不用赋分呢？

好问题！因为物理和历史是首选科目，每个学生必须二选一，它们被认为具有较强的区分度，所以直接使用原始分。

接下来是等级划分，赋分制将所有考生按原始分从高到低排列，划分为5个等级，人数比例分别为：A级15%、B级35%、C级35%、D级13%、E级2%。每个等级对应不同的赋分区间：A级对应86-100分，B级71-85分，C级56-70分，D级41-55分，E级30-40分。

三、赋分制的模拟

假设全省仅有20名同学参加高考化学考试，考题特别难，分数从高到低排列如下。

首先是按比例划分等级，全部20名同学按照之前说的比例划分，结果是：

• A级（前15%）：3人（20×15%=3）
• B级（接着35%）：7人（20×35%=7）
• C级（接着35%）：7人（20×35%=7）
• D级（接着13%）：2人（20×13%=2.6）
• E级（最后2%）：1人（20×2%=0.4）

注意，因为人数计算有小数，实际分配会有微调。在此例中，D级和E级的人数就有调整。

于是，20个学生的等级分就出来了。现在，让我们按照赋分制的规则来给这20名同学分配等级和赋分，如图所示。

完整的表格

那这些同学的赋分到底是多少呢？让我们看看几个具体同学的情况。

• 李学神：原始分66，排名第1，属于A级，是全部考生的最高分，直接得100分；郝厉害：原始分是60分，排名第3，也是A级，处于A级的下边界。获得A级最低赋分，即86分。

• 牛二爷：原始分是59分，排名第4，处于B级最高，得88分；甄聪明：原始分是50，排名第10，处于B级最低，得71分。
• 小牛：原始分是49，排名第11，处于C级最高，得70分；小强：原始分是40，排名第17，处于C级最低，得56分。
• 牛漂亮：原始分18，排名第18，处于D级最高，得55分；羊美丽：原始分8，排名第19，处于D级最低，得41分。
• 朱坚强：原始分0分，排名第20，处于E级最低（亦是全部考生最低），得30分。

如此，一些赋分就可填写了，如下图所示。

不过，这些不处在头尾，而是位于中间的同学，如张丫霸，艾学习等，他们的赋分又该如何计算呢？

四、赋分制公式

其实就是把考生在原始分中的排位，平移到赋分的分数段中。用一个公式来表达这个转换过程：
赋分 = 等级下限分 + [(原始分 – 等级原始分下限) ÷ (等级原始分上限 – 等级原始分下限)] × (等级上限分 – 等级下限分)

来，接下来我们应用公式算算张丫霸的赋分。

张丫霸（63）的原始分
= 等级下限分+[(原始分-等级原始分下限)÷(等级原始分上限-等级原始分下限)]×(等级上限分-等级下限分)
= 86 + [(63 - 60) ÷ (66 - 60)] × (100 - 86)
= 86 + [3 ÷ 6] × 14
= 86 + 7
= 93

也就是说，张丫霸化学成绩经过赋分转换后，从原始的63分变成了93分！

这正是赋分制的调节作用。你63分在A级原始分范围内的相对位置，对应到了A级赋分范围内的93分。

其实总分第一即满分的规矩，通过代公式也能计算得到，牛学神66分同时也是最高分，带入公式计算会发现，（66 – 60) ÷ (66 – 60)=1，然后86+1× 14=100分。

五、公式带入

记住这几个要点：政治、地理、化学、生物四科需要赋分转换；按全省排名分为A-E五级；每个等级内，通过等比例转换计算最终赋分。

接下来，我尝试和大家探讨探讨如何写出高效健壮的SQL，来模拟赋分制的系统实现。

六、数据准备

--创建学生成绩表：这就是我们的数字化考场
CREATE TABLE student_scores (
    student_id NUMBER(10),                -- 学生ID，每个学生的唯一标识
    student_name VARCHAR2(50),            -- 学生姓名
    raw_score NUMBER(5,2),                -- 原始分数，支持小数点后两位
    grade CHAR(1),                        -- 等级(A-E)，系统计算后填入
    converted_score NUMBER(5,2)           -- 赋分结果，这就是最终的神奇转换结果
);

-- 重现上次的考试现场：20名同学的化学考试原始成绩
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (1, '牛学神', 66);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (2, '张丫霸', 63);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (3, '郝厉害', 60);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (4, '牛二爷', 59);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (5, '艾学习', 58);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (6, '孙奋斗', 55);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (7, '钱多多', 53);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (8, '陈努力', 52);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (9, '王大锤', 51);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (10, '甄聪明', 50);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (11, '小牛', 49);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (12, '小马', 47);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (13, '小翠', 45);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (14, '小丽', 43);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (15, '小南', 42);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (16, '小北', 41);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (17, '小强', 40);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (18, '牛漂亮', 18);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (19, '羊美丽', 8);
INSERT INTO student_scores(student_id, student_name, raw_score) VALUES (20, '朱坚强', 0);
COMMIT;

七、算法核心

第一步

排名计算 – 给每个学生找到自己的位置

-- 第一步：排名计算 - 这是一切计算的基础
ranked_students AS (
    SELECT 
        student_id,
        student_name,
        raw_score,
        -- 使用RANK()函数处理同分情况，确保同分学生得到相同排名
        RANK() OVER (ORDER BY raw_score DESC) as rank_num,
        -- COUNT() OVER()获取总人数，这个技巧避免了额外的子查询
        COUNT(*) OVER () as total_count
    FROM student_scores
)

说明：
ROW_NUMBER()：1,2,3,4…（强制给同分学生不同排名）
RANK()：1,2,2,2,5,6…（同分学生得到相同排名，后续排名跳跃）

第二步

等级划分 – 按福建省标准分配ABCDE五个等级

接下来是关键的等级分配，这一步必须严格按照福建省教育厅的规定：A级15%，B级35%，C级35%，D级13%，E级2%。

-- 第二步：等级划分 - 严格按照福建省的15%、35%、35%、13%、2%比例
graded_students AS (
    SELECT 
        student_id, student_name, raw_score, rank_num, total_count,
        CASE
            -- A级：前15%（对于20人：CEIL(20 × 0.15) = 3，即前3名）
            WHEN rank_num <= CEIL(total_count * 0.15) THEN 'A'
            -- B级：前15%之后到前50%（第4名到第10名）
            WHEN rank_num <= CEIL(total_count * 0.50) THEN 'B'
            -- C级：前50%之后到前85%（第11名到第17名）
            WHEN rank_num <= CEIL(total_count * 0.85) THEN 'C'
            -- D级：前85%之后到前98%（第18名到第19名）
            WHEN rank_num <= CEIL(total_count * 0.98) THEN 'D'
            -- E级：剩下的就是最后2%（第20名）
            ELSE 'E'
        END as grade
    FROM ranked_students
)

说明：
这里使用累积比例的简洁写法。由于CASE语句按顺序执行，前15%先被分配A级，剩下的15%-50%自动成为B级，以此类推。这比写区间判断更简洁且不易出错。

第三步

计算等级边界 – 找出每个等级的分数范围

现在我们要找出每个等级内的最高分和最低分，这些边界值是等比例转换公式的关键参数。

-- 第三步：计算每个等级内的原始分数范围，这些数据是公式计算的基础
grade_ranges AS (
    SELECT 
        grade,
        -- 找出等级内的最高和最低原始分数
        MAX(raw_score) as max_raw_score,      -- 等级内最高原始分
        MIN(raw_score) as min_raw_score,      -- 等级内最低原始分
        -- 对应的赋分区间上限（福建省标准）
        CASE grade 
            WHEN 'A' THEN 100 WHEN 'B' THEN 85 WHEN 'C' THEN 70 
            WHEN 'D' THEN 55 ELSE 40 
        END as max_converted_score,
        -- 对应的赋分区间下限（福建省标准）
        CASE grade 
            WHEN 'A' THEN 86 WHEN 'B' THEN 71 WHEN 'C' THEN 56 
            WHEN 'D' THEN 41 ELSE 30 
        END as min_converted_score
    FROM graded_students 
    GROUP BY grade
)

这一步很巧妙！通过GROUP BY grade，我们能分别统计出每个等级的分数范围。比如A级的原始分范围是60-66分（郝厉害到牛学神），对应的赋分范围是86-100分。

这样A级原始分的60-66这6分的跨度，要映射到赋分的86-100这14分的跨度上。这就是等比例转换的数学基础。

第四步

特殊情况处理 – 让系统更加智能和健壮

现在到了算法的核心部分，我们必须处理所有可能的边界情况，确保系统的数学稳定性和业务合理性。

-- 第四步：特殊情况处理与等比例转换公式应用
final_calculation AS (
    SELECT 
        gs.student_id, gs.student_name, gs.raw_score, gs.rank_num, gs.grade,
        CASE
            -- 特殊处理1：全省第1名必须获得满分100分
            WHEN gs.rank_num = 1 THEN 100
            -- 特殊处理2：全省最低分必须获得保底30分
            WHEN gs.raw_score = (SELECT MIN(raw_score) FROM student_scores) THEN 30
            -- 特殊处理3：单人等级的健壮性处理
            -- 当等级内只有1人时，max_raw_score = min_raw_score，公式分母为0
            -- 这种情况在20万考生中几乎不可能出现，但为了代码健壮性必须处理
            WHEN gr.max_raw_score = gr.min_raw_score THEN 
                CASE gs.grade
                    WHEN 'A' THEN 100  -- A级唯一学生给满分
                    WHEN 'B' THEN 85   -- B级唯一学生给该级最高分
                    WHEN 'C' THEN 70   -- C级唯一学生给该级最高分
                    WHEN 'D' THEN 55   -- D级唯一学生给该级最高分
                    WHEN 'E' THEN 30   -- E级唯一学生给保底分
                END
            -- 一般情况：应用等比例转换公式
            -- 公式：赋分 = 等级下限 + (个人原始分 - 等级原始分下限) × 
            --              (等级赋分跨度) ÷ (等级原始分跨度)
            ELSE ROUND(
                gr.min_converted_score + 
                (gs.raw_score - gr.min_raw_score) * 
                (gr.max_converted_score - gr.min_converted_score) / 
                (gr.max_raw_score - gr.min_raw_score), 0
            )
        END as converted_score
    FROM graded_students gs, grade_ranges gr
    WHERE gs.grade = gr.grade
)

为什么等级内只有一个人就要特殊处理呢？

如果等级内仅一人，max_raw_score等于min_raw_score，等比例公式的分母就是零，会导致数学错误。虽然这种情况在实际考试中极其罕见，但程序必须处理所有边界条件。我们的处理策略是：ABCD级唯一学生给该级最高分，E级唯一学生给30分，这样确保整个赋分体系始终有最高分100和最低分30。当然，这只是我们的一种设计方案，实际的官方系统可能会有不同的处理逻辑。

八、完整实现

四步合并一气呵成

形成一个完整、优雅、高效的SQL查询。

-- 福建省高考赋分制完整实现算法
WITH 
-- 第一步：排名计算，确定每个学生的相对位置
ranked_students AS (
    SELECT 
        student_id, student_name, raw_score,
        RANK() OVER (ORDER BY raw_score DESC) as rank_num,
        COUNT(*) OVER () as total_count
    FROM student_scores
),
-- 第二步：等级划分，按福建省15%、35%、35%、13%、2%标准分配
graded_students AS (
    SELECT 
        student_id, student_name, raw_score, rank_num, total_count,
        CASE
            WHEN rank_num <= CEIL(total_count * 0.15) THEN 'A'
            WHEN rank_num <= CEIL(total_count * 0.50) THEN 'B'
            WHEN rank_num <= CEIL(total_count * 0.85) THEN 'C'
            WHEN rank_num <= CEIL(total_count * 0.98) THEN 'D'
            ELSE 'E'
        END as grade
    FROM ranked_students
),
-- 第三步：计算各等级的原始分数范围和对应的赋分区间
grade_ranges AS (
    SELECT 
        grade,
        MAX(raw_score) as max_raw_score,
        MIN(raw_score) as min_raw_score,
        CASE grade 
            WHEN 'A' THEN 100 WHEN 'B' THEN 85 WHEN 'C' THEN 70 
            WHEN 'D' THEN 55 ELSE 40 
        END as max_converted_score,
        CASE grade 
            WHEN 'A' THEN 86 WHEN 'B' THEN 71 WHEN 'C' THEN 56 
            WHEN 'D' THEN 41 ELSE 30 
        END as min_converted_score
    FROM graded_students 
    GROUP BY grade
),
-- 第四步：特殊情况处理与等比例转换公式应用
final_calculation AS (
    SELECT 
        gs.student_id, gs.student_name, gs.raw_score, gs.rank_num, gs.grade,
        CASE
            -- 特殊情况1：全省第1名固定100分
            WHEN gs.rank_num = 1 THEN 100
            -- 特殊情况2：全省最低分固定30分
            WHEN gs.raw_score = (SELECT MIN(raw_score) FROM student_scores) THEN 30
            -- 特殊情况3：单人等级处理（健壮性考虑）
            WHEN gr.max_raw_score = gr.min_raw_score THEN 
                CASE gs.grade
                    WHEN 'A' THEN 100 WHEN 'B' THEN 85 WHEN 'C' THEN 70 
                    WHEN 'D' THEN 55 WHEN 'E' THEN 30
                END
            -- 一般情况：应用等比例转换公式
            ELSE ROUND(
                gr.min_converted_score + 
                (gs.raw_score - gr.min_raw_score) * 
                (gr.max_converted_score - gr.min_converted_score) / 
                (gr.max_raw_score - gr.min_raw_score), 0
            )
        END as converted_score
    FROM graded_students gs, grade_ranges gr
    WHERE gs.grade = gr.grade
)
-- 显示最终的赋分结果，按排名顺序展示
SELECT 
    rank_num as "排名", 
    student_name as "姓名", 
    raw_score as "原始分", 
    grade as "等级", 
    converted_score as "赋分"
FROM final_calculation 
ORDER BY rank_num;

九、见证奇迹

完美复现手工计算结果

十、完美收官

从手工到智能实现

第一步

批量更新：将计算结果写回数据库

光有查询结果还不够，我们需要把这些宝贵的计算结果保存到数据库中，供后续的高考录取系统使用，代码思路如下。

UPDATE student_scores 
SET (grade, converted_score) = (
    SELECT grade, converted_score 
    FROM (
        -- 这里是完整的赋分计算逻辑
        WITH 
        ranked_students AS (
            SELECT 
                student_id, student_name, raw_score,
                RANK() OVER (ORDER BY raw_score DESC) as rank_num,
                COUNT(*) OVER () as total_count
            FROM student_scores
        ),
        graded_students AS (
            SELECT 
                student_id, student_name, raw_score, rank_num, total_count,
                CASE
                    WHEN rank_num <= CEIL(total_count * 0.15) THEN 'A'
                    WHEN rank_num <= CEIL(total_count * 0.50) THEN 'B'
                    WHEN rank_num <= CEIL(total_count * 0.85) THEN 'C'
                    WHEN rank_num <= CEIL(total_count * 0.98) THEN 'D'
                    ELSE 'E'
                END as grade
            FROM ranked_students
        ),
        grade_ranges AS (
            SELECT 
                grade,
                MAX(raw_score) as max_raw_score,
                MIN(raw_score) as min_raw_score,
                CASE grade 
                    WHEN 'A' THEN 100 WHEN 'B' THEN 85 WHEN 'C' THEN 70 
                    WHEN 'D' THEN 55 ELSE 40 
                END as max_converted_score,
                CASE grade 
                    WHEN 'A' THEN 86 WHEN 'B' THEN 71 WHEN 'C' THEN 56 
                    WHEN 'D' THEN 41 ELSE 30 
                END as min_converted_score
            FROM graded_students 
            GROUP BY grade
        ),
        final_calculation AS (
            SELECT 
                gs.student_id, gs.grade,
                CASE
                    WHEN gs.rank_num = 1 THEN 100
                    WHEN gs.raw_score = (SELECT MIN(raw_score) FROM student_scores) THEN 30
                    WHEN gr.max_raw_score = gr.min_raw_score THEN 
                        CASE gs.grade
                            WHEN 'A' THEN 100 WHEN 'B' THEN 85 WHEN 'C' THEN 70 
                            WHEN 'D' THEN 55 WHEN 'E' THEN 30
                        END
                    ELSE ROUND(
                        gr.min_converted_score + 
                        (gs.raw_score - gr.min_raw_score) * 
                        (gr.max_converted_score - gr.min_converted_score) / 
                        (gr.max_raw_score - gr.min_raw_score), 0
                    )
                END as converted_score
            FROM graded_students gs, grade_ranges gr
            WHERE gs.grade = gr.grade
        )
        SELECT grade, converted_score FROM final_calculation 
        WHERE student_id = student_scores.student_id
    )
);
commit;

第二步

数据质量检查：确保系统的可靠性

任何一个生产系统都必须有完善的质量检查机制，特别是像高考赋分这样关系到学生前途的重要计算。

-- 全面的数据质量检查
SELECT '数据完整性检查' as 检查类型, '总人数' as 检查项目, COUNT(*) as 检查结果 
FROM student_scores
UNION ALL
SELECT '数据完整性检查', '已赋分人数', COUNT(*) 
FROM student_scores WHERE converted_score IS NOT NULL
UNION ALL
SELECT '等级分布检查', grade || '级人数', COUNT(*) 
FROM student_scores WHERE grade IS NOT NULL GROUP BY grade
UNION ALL
SELECT '分数范围检查', '赋分最高分', MAX(converted_score) 
FROM student_scores WHERE converted_score IS NOT NULL
UNION ALL
SELECT '分数范围检查', '赋分最低分', MIN(converted_score) 
FROM student_scores WHERE converted_score IS NOT NULL
UNION ALL
SELECT '逻辑性检查', '原始分与赋分差异数', COUNT(*)
FROM student_scores 
WHERE converted_score IS NOT NULL AND converted_score < raw_score
ORDER BY 检查类型, 检查项目;

这个检查查询能帮我们发现各种潜在问题，比如是否所有学生都完成了赋分，等级分布是否合理，赋分是否在30-100的正常范围内，以及赋分后是否真的比原始分更高等等。

第三步

性能优化考虑：面向大规模数据

如果考生数据量达数百万甚至更多，这套算法性能如何？

优化手段：

1. 为raw_score字段建立索引，加速排序；
2. 使用并行查询提高大数据量的处理速度；
3. 分批处理，比如按学校或地区分批计算等等。

总结

原来复杂的赋分制可以用一条这么优雅简洁的SQL实现了，代码改变世界。

这个案例展示了如何将教育政策精确转化为数据库算法。从排名到赋分，每一步都体现了技术服务教育公平的理念。技术让复杂的教育评价变得高效精准，更重要的是，它让公平变得可验证、可重现、易维护。每一行代码背后，都承载着对教育公平的坚持。

需要特别说明的是，本文展示的仅仅是一个极简示例。真实的高考赋分系统要复杂得多！是绝不可能仅用一条SQL就能搞定的，需要考虑太多场景细节了。比如当大量学生出现同分时，可能会打破等级比例：按15%划分A级理论上应该有3000人，但如果第2999名到第3500名都是同分，系统需要决定是严格按比例切分还是保持同分同级。不同省份对此可能有不同的处理策略。

此外还有数据校验、异常处理、并发控制、审计日志等工程问题，以及如何处理缺考、作弊、成绩复议等特殊情况。

但无论系统多复杂，核心思想不变：通过等级划分和等比例转换，将原始分数映射到标准分数区间，实现不同科目分数的可比性。这正是新高考制度的精髓所在。

祝莘莘高考学子们：

      心想事成，金榜题名！！！

对象统计信息描述数据是如何在数据库中存储的。统计信息是优化器的代价计算的依据，可以帮助优化器较精确地估算成本，对执行计划的选择起着至关重要的作用。

达梦数据库的统计信息分三种类型：表统计信息、列统计信息、索引统计信息。通过直方图来表示。统计信息生成过程分以下三个步骤：

• 确定采样的数据：根据数据对象，确定需要分析哪些数据。
  • 表：计算表的行数、所占的页数目、平均记录长度
  • 列：统计列数据的分布情况
  • 索引：统计索引列的数据分布情况
• 确定采样率
  • 根据数据对象的大小，通过内部算法，确定数据的采样率。采样率与数据量成反比。
• 生成直方图
  • 有两种类型的直方图：频率直方图和等高直方图。根据算法分析表的数据分布特征，确定直方图的类型。频率直方图的每个桶(保存统计信息的对象)的高度不同，等高直方图每个桶的高度相同。例如，对列生成统计信息，当列值分布比较均匀时，会采用等高直方图，否则，采用频率直方图。

在执行查询时，如果数据对象存在统计信息，代价算法可以根据统计信息中的数据，比较精确地计算出操作所需花费的成本，以此来确定连接方式、对象访问路径、连接顺序，选择最优的执行计划。

用户也可以通过修改 OPTIMIZER_DYNAMIC_SAMPLING 参数值在缺乏统计信息时进行动态统计信息收集。

二、收集统计信息

--收集全库统计信息
CALL SP_DB_STAT_INIT ();

--收集指定用户下所有表所有列的统计信息：
DBMS_STATS.GATHER_SCHEMA_STATS('OWNNAME',100,TRUE,'FOR ALL COLUMNS SIZE AUTO');

--收集指定用户下所有索引的统计信息：
DBMS_STATS.GATHER_SCHEMA_STATS('OWNNAME', 1.0, TRUE, 'FOR ALL INDEXED SIZE AUTO');
--或 收集单个索引统计信息：
DBMS_STATS.GATHER_INDEX_STATS('OWNNAME','INDNAME');

--收集指定用户下某表统计信息：
DBMS_STATS.GATHER_TABLE_STATS('OWNNAME','TABNAME',NULL,100,TRUE,'FOR ALL COLUMNS SIZE AUTO');

--收集某表某列的统计信息：
STAT 100 ON TABNAME(COLNAME);

注意：
以上DBMS_STATS包收集方式均可在最后添加参数DEGREE：收集的并行度，默认为 1。以提高收集效率。DBMS_STATS包方法的具体使用手册可从数据库安装路径doc目录下《DM8系统包使用手册.pdf》查看。

另外

--收集表统计信息
call SP_TAB_STAT_INIT('OWNNAME','TABNAME');
--收集索引统计信息
call SP_INDEX_STAT_INIT('OWNNAME','INDNAME');
--生成表上所有索引的统计信息
call SP_TAB_INDEX_STAT_INIT ('OWNNAME', 'TABNAME');

注意
GATHER_TABLE_STATS 是用于收集和更新统计信息的操作，帮助查询优化器更好地优化查询执行计划。它支持并行度、采样、索引统计信息等选项，适用于数据量大的表和定期更新统计信息的场景。
SP_TAB_STAT_INIT、SP_INDEX_STAT_INIT 是用于初始化或重置表的统计信息的存储过程，通常在表结构变化或数据量较少时使用。它会将统计信息重置为默认值，适用于需要重新收集统计信息的特殊场景。

生产环境收集统计信息

有时我们需要在生产环境收集统计信息，即便在业务低谷时报错：-7120达梦数据库报错回滚记录版本太旧，无法获取用户记录。可以在执行前修改如下参数：

ALTER SESSION SET 'ENABLE_IGNORE_PURGE_REC' = 1;

然后再执行收集统计信息的语句。

备注
ENABLE_IGNORE_PURGE_REC，动态会话级参数，当返回 EC_RN_NREC_PURGED（-7120）错误（回滚记录版本太旧，无法获取用户记录）时的处理策略；
0：报错；1：忽略这一条记录，继续执行；2：报错并生成日志；3：忽略这一条记录，继续执行，并生成日志

三、查看统计信息

（1）查看单个表统计信息

DBMS_STATS.TABLE_STATS_SHOW('OWNNAME','TABNAME');

（2）批量查看某用户下表的统计信息

SELECT 'DBMS_STATS.TABLE_STATS_SHOW('''||OWNER||''','''||TABLE_NAME||''');' FROM DBA_TABLES WHERE OWNER = 'OWNNAME';

使用上述SQL执行后的结果集的SQL进行批量查询。

四、其他SQL

（1）查询表的最近一次收集统计信息的时间

SELECT
    *
FROM
    (SELECT
         O.OBJECT_TYPE AS "对象类型",
         O.OWNER AS "用户",
         O.OBJECT_NAME AS "对象名称",
         C.COLUMN_NAME AS "列名称",
         C.COLUMN_ID AS "列ID",
         C.DATA_TYPE AS "数据类型",
         S.T_TOTAL AS "总行数",
         S.N_SMAPLE AS "采样个数",
         S.N_DISTINCT AS "不同值的个数",
         S.N_NULL AS "空值个数",
         S.V_MIN AS "列的最小值",
         S.V_MAX AS "列的最大值",
         S.N_BUCKETS AS "直方图桶数目",
         S.LAST_GATHERED AS "最后收集时间"
     FROM
         SYSSTATS S
         INNER JOIN DBA_OBJECTS O ON S.ID = O.OBJECT_ID
         INNER JOIN DBA_TAB_COLUMNS C ON O.OWNER = C.OWNER AND O.OBJECT_NAME = C.TABLE_NAME AND S.COLID + 1 = C.COLUMN_ID
     WHERE
         O.OWNER = 'OWNNAME'
         AND O.OBJECT_NAME = 'TABNAME'
         AND O.OBJECT_TYPE = 'TABLE')
ORDER BY
    C.COLUMN_ID;

备注：收集全库统计信息时不会更新这个时间，除全库收集外其余收集方式均可更新这个时间。SYSSTATS的COLID字段为-1时包含全库收集统计信息时间。

本文可能不局限于DM数据库，用法是否可用需自行验证。

二、汇总

2.1 字段中是否包含中文

--查询NAME字段包含中文的
SELECT NAME FROM CS_ZW WHERE ASCIISTR(NAME) LIKE '%\%';
--查询NAME字段不包含中文的
SELECT NAME FROM CS_ZW WHERE ASCIISTR(NAME) NOT LIKE '%\%';

2.2 TIMESTAMP类型取小时部分

SELECT DATE_FORMAT(SYSDATE(),'%H') AS HOUR FROM DUAL;

2.3 查询表的创建时间

SELECT NAME,CRTDATE AS "创建时间" FROM SYSOBJECTS WHERE "TYPE$" = 'SCHOBJ' AND "SUBTYPE$" = 'UTAB' AND NAME = '表名';

2.4 大字段类型查询时直接显示内容

创建测试表及数据

CREATE TABLE DZD (ID INT,B1 BLOB,C1 CLOB);

INSERT INTO TEST.DZD VALUES (1,'ABCDEF','MAKDJIDIJFIJDIJIENG');
INSERT INTO TEST.DZD VALUES (2,'BCDEF','NGJDJIEJIJFIJEWNAAS');
INSERT INTO TEST.DZD VALUES (3,'CDEF','JMEIGNABEIJGIIANAI');

方法一：【BLOB类型不适用】

SELECT ID,C1::VARCHAR FROM TEST.DZD;

方法二：

--DBMS_LOB.SUBSTR(BLOB/CLOB/TEXT)
SELECT ID,DBMS_LOB.SUBSTR(B1),DBMS_LOB.SUBSTR(C1) FROM TEST.DZD;

方法三：

DM管理工具配置连接属性，高级中添加参数clobAsString=true

方法四：

使用新工具SQLark（百灵连接）

2.5 时间戳与日期类型的相互转化

日期类型转时间戳

SELECT UNIX_TIMESTAMP(SYSDATE);

时间戳转日期类型

SELECT FROM_UNIXTIME(1591644470);
SELECT FROM_UNIXTIME(1591644470,'YYYY-MM-DD');
SELECT FROM_UNIXTIME(1591644470,'YYYY-MM-DD HH24:MI:SS');

另-13位时间戳转化方法

--截取后直接转化
SELECT FROM_UNIXTIME(SUBSTR(1709187648234,0,10)) FROM DUAL;
--TO_CHAR方式
SELECT TO_CHAR(1709187648234*1.0 / (1000*60*60*24) + TO_DATE('1970-01-01 08:00:00','YYYY-MM-DD HH24:MI:SS'),'YYYY-MM-DD HH24:MI:SS');
SELECT TO_CHAR(1709187648234*1.0 / (1000*60*60*24) + TO_DATE('1970-01-01 08:00:00.000','YYYY-MM-DD HH24:MI:SS.MS'),'YYYY-MM-DD HH24:MI:SS.MS');

2.6 求一个或多个数中的最大值

创建测试表及数据

CREATE TABLE SCORE(ID INT PRIMARY KEY,NAME VARCHAR(30),YW INT,SX INT,YY INT);

使用SQLark的数据生成功能，生成成绩单数据。

--查询每名学生自己最好的一科成绩
SELECT GREATEST(YW,SX,YY),* FROM SCORE;

如图

2.7 计算一个字符串中某个字符的个数

示例：计算该字符串中“F”的个数。

SELECT LENGTH('ADSLFKJAKSJFDLJADSASF')-LENGTH(REPLACE('ADSLFKJAKSJFDLJADSASF', 'F' ,''));

思路：

思路：

1. 将字符串中所找字符替换成”【就是将所找字符替换成空】
2. 利用数学：字符串长度-字符串去掉所找字符后的长度=字符的个数

总结：

SELECT LENGTH('字符串')-LENGTH(REPLACE('字符串', '所找字符' ,''));

2.8 列转置（列转行）

创建测试表及数据

--创建表
CREATE TABLE LZH (ID INT, DT DATETIME (6), TEXT VARCHAR(8188));
--插入测试数据
INSERT INTO LZH (ID, DT, TEXT) VALUES (1, '2024-01-24 14:26:26.000000', 'a,B,c,d');
INSERT INTO LZH (ID, DT, TEXT) VALUES (5, '2024-01-24 14:26:26.000000', 'e,f,G');
INSERT INTO LZH (ID, DT, TEXT) VALUES (7, '2024-01-24 14:26:26.000000', 'h,i,J');

将TEXT字段以逗号分隔，拆分成新的一行数据

SELECT
	A.*,
	REGEXP_SUBSTR(A.TEXT, '[^,]{1,}', 1, B.L) AS SPLIT_FIELD
FROM
	LZH A
	JOIN (
		SELECT
			LEVEL AS L
		FROM
			DUAL
		CONNECT BY LEVEL <= 100
	) B ON REGEXP_COUNT (A.TEXT, ',') + 1 >= B.L
ORDER BY
	3;

效果：

2.9 虚拟列

表中某字段由其他字段计算所得-计算列

CREATE TABLE SCORE_TEST (
	YW CHAR(10),
	SX CHAR(10),
	YY CHAR(10),
	ZF CHAR(10) AS (YW + SX + YY)
);

INSERT INTO SCORE_TEST(YW,SX,YY) VALUES ('92','73','84');

SELECT * FROM SCORE_TEST;

如图：

2.10 二进制转化为相应的ASCII码文本

SELECT UTL_RAW.CAST_TO_VARCHAR2(DBMS_LOB.SUBSTR(BLOB字段)) FROM TABLENAME;

2.11 分区表将手机号以最后一位数字分十个子表

思路：使用虚拟列进行范围分区

CREATE TABLE PHONEINFO (NAME VARCHAR(20),PHONE VARCHAR(20),PHONE_TAIL_NUMBER CHAR(1) AS (SUBSTR(PHONE,-1)))
PARTITION BY LIST(PHONE_TAIL_NUMBER) (
	PARTITION P0 VALUES ('0'),
	PARTITION P1 VALUES ('1'),
	PARTITION P2 VALUES ('2'),
	PARTITION P3 VALUES ('3'),
	PARTITION P4 VALUES ('4'),
	PARTITION P5 VALUES ('5'),
	PARTITION P6 VALUES ('6'),
	PARTITION P7 VALUES ('7'),
	PARTITION P8 VALUES ('8'),
	PARTITION P9 VALUES ('9')
);

2.12 CONCAT函数拼接时间字段

CONCAT函数拼接传参的字段时，时间字段不会带上单引号，可以在拼接字段时带上引号来解决

SELECT CONCAT('BETWEEN ',SYSDATE)--无单引号
UNION ALL
SELECT CONCAT('BETWEEN ',''''||SYSDATE||'''');--加单引号

2.13 自定义函数实现字段拼接【CURSOR】

创建测试数据

CREATE TABLE ZIDUANPINJIE (ID INT NOT NULL PRIMARY KEY, NAME VARCHAR(30));

INSERT INTO ZIDUANPINJIE VALUES (1,'武汉');
INSERT INTO ZIDUANPINJIE VALUES (2,'达梦');
INSERT INTO ZIDUANPINJIE VALUES (3,'数据库');
INSERT INTO ZIDUANPINJIE VALUES (4,'股份');
INSERT INTO ZIDUANPINJIE VALUES (5,'有限');
INSERT INTO ZIDUANPINJIE VALUES (6,'公司');
INSERT INTO ZIDUANPINJIE VALUES (7,'成功');
INSERT INTO ZIDUANPINJIE VALUES (8,'上市');
INSERT INTO ZIDUANPINJIE VALUES (9,'科创板');

COMMIT;

函数定义

CREATE OR REPLACE FUNCTION PINJIE_ALL_DATA_FROM_TABLE
RETURN VARCHAR IS
	V_RESULT VARCHAR(100);
	CURSOR TABLE_CURSOR IS
		SELECT * FROM ZIDUANPINJIE;
BEGIN
	FOR REC IN TABLE_CURSOR LOOP
		V_RESULT := V_RESULT || REC.NAME;
		--V_RESULT := V_RESULT ||'||' || REC.NAME; -- 添加分隔符
	END LOOP;
	
	RETURN V_RESULT;
END;
/

验证效果

SELECT "TEST"."PINJIE_ALL_DATA_FROM_TABLE"();

效果如图

2.14 IMAGA字段转换为VARCHAR字段

创建测试表

CREATE TABLE IMG2VAR (ID INT PRIMARY KEY, PICTURE IMAGE);

使用SQLark的数据生成功能生成测试数据

转换

SELECT UTL_I18N.RAW_TO_CHAR(SUBSTRBLB(PICTURE,1,3000),'UTF8') FROM TEST.IMG2VAR;

效果图

2.15 LIKE转义ESCAPE

创建测试数据

CREATE TABLE TEST_LIKE (ID INT, NAME VARCHAR(200));

INSERT INTO TEST_LIKE VALUES(1,'FFFF');
INSERT INTO TEST_LIKE VALUES(2,'FF_FF');
INSERT INTO TEST_LIKE VALUES(3,'FF\FF');
INSERT INTO TEST_LIKE VALUES(4,'FF_A\A');
INSERT INTO TEST_LIKE VALUES(5,'FF_\FF');
INSERT INTO TEST_LIKE VALUES(6,'FF\_FF');
INSERT INTO TEST_LIKE VALUES(7,'FF%_%FF');

COMMIT;

一些查询示例：

（1）查询包含“_”的数据

SELECT * FROM TEST_LIKE WHERE NAME LIKE '%\_%' ESCAPE '\';
--或者
SELECT * FROM TEST_LIKE WHERE NAME LIKE '%A_%' ESCAPE 'A';

效果图：

（2）查询包含“\_”的数据

SELECT * FROM TEST_LIKE WHERE NAME LIKE '%\\\_%' ESCAPE '\';

效果图：

（3）查询包含“%”的数据

SELECT * FROM TEST_LIKE WHERE REGEXP_LIKE (NAME,'%');
--或者
SELECT * FROM TEST_LIKE WHERE NAME LIKE '%\%%' ESCAPE '\';

效果图：

2.16 字符串按分割符拆分成一列的多行

示例：将字符串 “AAA|BBB|CCC|DDD|EEE”，按 “|” 截取

方法一：SUBSTRING_INDEX嵌套

SELECT SUBSTRING_INDEX('AAA|BBB|CCC|DDD|EEE','|',1) UNION ALL							--AAA
SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('AAA|BBB|CCC|DDD|EEE','|', 2),'|',-1) UNION ALL	--BBB
SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('AAA|BBB|CCC|DDD|EEE','|', 3),'|',-1) UNION ALL	--CCC
SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('AAA|BBB|CCC|DDD|EEE','|', 4),'|',-1) UNION ALL	--DDD
SELECT SUBSTRING_INDEX(SUBSTRING_INDEX('AAA|BBB|CCC|DDD|EEE','|', 5),'|',-1);			--EEE

方法二：REGEXP_SUBSTR结合LEVEL

SELECT
    REGEXP_SUBSTR('AAA|BBB|CCC|DDD|EEE', '[^|]+', 1, LEVEL) AS SPLIT_VALUE
FROM
    DUAL CONNECT BY
    REGEXP_SUBSTR('AAA|BBB|CCC|DDD|EEE', '[^|]+', 1, LEVEL) IS NOT NULL;

方法三：

DECLARE
    V_COUNT INT;
    V_DATA VARCHAR(50);
    V_SQL VARCHAR(5000);
BEGIN
    SELECT LENGTH('AAA|BBB|CCC|DDD|EEE') - LENGTH(REPLACE('AAA|BBB|CCC|DDD|EEE', '|', '')) + 1 INTO V_COUNT FROM DUAL;
    EXECUTE IMMEDIATE 'DROP TABLE IF EXISTS RESULT_TABLE;';
    EXECUTE IMMEDIATE 'CREATE TABLE RESULT_TABLE (RES VARCHAR2(50));';
    FOR I IN 1 .. V_COUNT LOOP
        SET V_DATA = SUBSTRING_INDEX(SUBSTRING_INDEX('AAA|BBB|CCC|DDD|EEE', '|', I), '|', -1);
        V_SQL = 'INSERT INTO RESULT_TABLE VALUES (:1);';
        EXECUTE IMMEDIATE V_SQL USING V_DATA;
    END LOOP;
END;

查询验证

SELECT * FROM RESULT_TABLE;

总结模板：

DECLARE 
    V_COUNT INT;
    V_DATA VARCHAR(50);
    V_SQL VARCHAR(5000);
    
BEGIN
	SELECT LENGTH('字符串')-LENGTH(REPLACE('字符串', '分割符' ,''))+1 INTO V_COUNT FROM DUAL;
    EXECUTE IMMEDIATE 'DROP TABLE IF EXISTS RESULT_TABLE;';
    EXECUTE IMMEDIATE 'CREATE TABLE RESULT_TABLE (RES VARCHAR2(50));';
	FOR I IN 1..V_COUNT LOOP
    	SET V_DATA = SUBSTRING_INDEX(SUBSTRING_INDEX('字符串','分割符', I),'分割符',-1);
    	V_SQL = 'INSERT INTO RESULT_TABLE VALUES (:1);';
		EXECUTE IMMEDIATE V_SQL USING V_DATA;
    END LOOP;
END;
--查询结果
SELECT * FROM RESULT_TABLE;

2.17 时间转化成秒数

SELECT TIME_TO_SEC('03:00:00') from dual;

效果：

2.18 TRIM不掉的空格

有时“空格”不一定是“空格”，而是“制表符”，而TRIM函数默认修剪字符是空格，所以需要简单补充下SQL

--去掉前后的制表符
SELECT TRIM(BOTH '	' FROM 字段名);
--去掉首端的制表符
SELECT TRIM(LEADING '	' FROM 字段名);
--去掉末端的制表符
SELECT TRIM(TRAILING '	' FROM 字段名);

三、后续

该文档不定时更新，如有发现新的SQL，随时同步到该文章。

通俗来讲，会话(Session) 是通信双方从开始通信到通信结束期间的一个上下文（Context）。这个上下文是一段位于服务器端的内存：记录了本次连接的客户端机器、通过哪个应用程序、哪个用户登录等信息。

连接（Connection）：连接是从客户端到ORACLE实例的一条物理路径。连接可以在网络上建立，或者在本机通过IPC机制建立。通常会在客户端进程与一个专用服务器或一个调度器之间建立连接。

会话(Session) 是和连接(Connection)是同时建立的，两者是对同一件事情不同层次的描述。简单讲，连接(Connection)是物理上的客户端同服务器的通信链路，会话(Session)是逻辑上的用户同服务器的通信交互。

二、常用SQL

2.1 操作系统命令查询会话数

lsof -i:5236|grep dmserver|wc -l
或者
netstat -nat|awk '{print $4}'|grep 5236|wc -l

2.2 SQL查询会话数

--当前数据库连接的会话总数
SELECT COUNT(*) FROM V$SESSIONS;
--当前数据库活动的会话总数
SELECT COUNT(*) FROM V$SESSIONS WHERE STATE='ACTIVE';
--详细查询
SELECT SQL_TEXT,CLNT_IP,STATE,COUNT(*) FROM V$SESSIONS GROUP BY SQL_TEXT,CLNT_IP,STATE ORDER BY STATE,COUNT(*) DESC;

2.3 查看数据库设置的最大会话数

SELECT PARA_NAME, PARA_VALUE FROM V$DM_INI WHERE PARA_NAME = 'MAX_SESSIONS';
--或者
SELECT NAME, VALUE FROM V$PARAMETER WHERE NAME = 'MAX_SESSIONS';

2.4 总览活动会话数、会话总数、最大会话数

SELECT 'ACTIVE_SESSION:' AS SESS,COUNT(1) AS COUNT FROM V$SESSIONS WHERE STATE='ACTIVE' UNION ALL
SELECT 'CURRENT_SESSION:',COUNT(1) FROM V$SESSIONS UNION ALL
SELECT 'MAX_SESSION:',PARA_VALUE FROM V$DM_INI WHERE PARA_NAME='MAX_SESSIONS';

2.5 查看会话主要信息

SELECT SQL_TEXT, 
       STATE, 
       USER_NAME, 
       CURR_SCH, 
       CLNT_TYPE, 
       CLNT_HOST, 
       APPNAME, 
       CLNT_IP, 
       CLNT_VER 
FROM V$SESSIONS;

2.6 查看SQL的来源

SELECT
    REGEXP_SUBSTR(CLNT_IP, '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+'),
    COUNT(*),
    STATE,
    CLNT_VER
FROM
    V$SESSIONS
GROUP BY
    REGEXP_SUBSTR(CLNT_IP, '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+'),
    STATE,
    CLNT_VER
ORDER BY
    2 DESC;

2.7 调整MAX_SESSIONS，可使用该SQL评估

SELECT
    *,
    ROUND(总的 / (SELECT
                    TRUNC(SUM(TOTAL_SIZE * 1.0) / 1024 / 1024)
                FROM
                    V$MEM_POOL), 2) * 100 || '%' 占总的百分比,
    ROUND(总的 / DECODE(水位, 0, 1, 水位), 2) * 100 || '%' 与水位百分比
FROM
    (SELECT
         REGEXP_REPLACE(NAME, '[0-9]') 类别,
         COUNT(*) 池数,
         TRUNC(SUM((ORG_SIZE / 1024.0 / 1024))) 初始,
         TRUNC(SUM((DATA_SIZE / 1024.0 / 1024))) 在用,
         TRUNC(SUM((TOTAL_SIZE / 1024.0 / 1024))) 总的,
         TRUNC(SUM((TARGET_SIZE / 1024.0 / 1024))) 水位
     FROM
         V$MEM_POOL
     GROUP BY
         REGEXP_REPLACE(NAME, '[0-9]')
     UNION ALL
     SELECT
         'MEM_TOTAL',
         1,
         TRUNC(SUM((ORG_SIZE / 1024.0 / 1024))) 初始,
         TRUNC(SUM((DATA_SIZE / 1024.0 / 1024))) 在用,
         TRUNC(SUM(TOTAL_SIZE * 1.0) / 1024 / 1024) 总的,
         TRUNC(SUM((TARGET_SIZE / 1024.0 / 1024))) 水位
     FROM
         V$MEM_POOL) ALL_MEM
WHERE
    总的 > 0
ORDER BY
    总的 DESC;

查看SESSION占总的百分比，评估可以调整的幅度。

实际配置不建议超过推荐值的150%，配置过大的话，业务高峰期间会话数太高，有发生OOM的可能。
【推荐值：参数优化脚本根据服务器配置执行后所得的值】

2.8 查看阻塞会话

SELECT TW.*,SS.CLNT_IP,SESS_ID,SS.SQL_TEXT FROM V$TRXWAIT TW JOIN V$SESSIONS SS ON SS.THRD_ID=TW.THRD_ID ORDER BY WAIT_TIME DESC;
--或者
SELECT * FROM V$SESSIONS WHERE TRX_ID IN (SELECT WAIT_FOR_ID FROM V$TRXWAIT);

2.9 清除阻塞会话的源头

--使用结果集的SQL清除
SELECT 'SP_CLOSE_SESSION('||SESS_ID||');' FROM V$SESSIONS WHERE TRX_ID IN (SELECT WAIT_FOR_ID FROM V$TRXWAIT);
SELECT 'SP_CLOSE_SESSION('||SESS_ID||');' FROM V$SESSIONS S, V$LOCK L WHERE S.TRX_ID = L.TRX_ID AND L.BLOCKED = 1;
--或者根据SESS_ID清除
SP_CLOSE_SESSION(SESS_ID);
--如果清除不掉，先取消，再清除
SP_CANCEL_SESSION_OPERATION(SESS_ID);
SP_CLOSE_SESSION(SESS_ID);

2.10 清除所有会话

BEGIN
    FOR REC IN (SELECT * FROM V$SESSIONS WHERE SESS_ID <> SESSID()) LOOP
        SP_CLOSE_SESSION(REC.SESS_ID);
    END LOOP;
END;

2.11 清除某张表的缓存计划

SELECT 'SP_CLEAR_PLAN_CACHE('||CACHE_ITEM||');' FROM V$CACHEPLN WHERE SQLSTR LIKE '%TABLENAME%';
--或者
SELECT * FROM V$CACHEPLN WHERE SQLSTR LIKE '%TABLENAME%';
SP_CLEAR_PLAN_CACHE(CACHE_ITEM);

2.12 批量清除缓存

BEGIN
    FOR RS IN (SELECT * FROM V$CACHEPLN WHERE SQLSTR LIKE '%SQL语句%') LOOP
        EXECUTE IMMEDIATE 'SP_CLEAR_PLAN_CACHE(' || RS.CACHE_ITEM || ');';
    END LOOP;
END;

2.13 查询当前锁的状态

SELECT * FROM V$LOCK;
--或者
SELECT
    LC.LMODE,
    LC.TABLE_ID,
    LC.BLOCKED,
    VTW.ID AS TRX_ID,
    VS.SESS_ID,
    VS.SQL_TEXT,
    VS.APPNAME,
    VS.CLNT_IP
FROM
    V$LOCK LC
    LEFT JOIN V$TRXWAIT VTW ON (LC.TRX_ID = VTW.ID)
    LEFT JOIN V$TRX VT ON (VTW.ID = VT.ID)
    LEFT JOIN V$SESSIONS VS ON (VT.SESS_ID = VS.SESS_ID)
WHERE
    VS.SQL_TEXT IS NOT NULL;

2.14 查询历史执行语句记录-有SQL耗时字段

SELECT
    SQL_HIS.SEQ_NO,
    SQL_HIS.SESS_ID,
    SQL_HIS.TRX_ID,
    SQL_HIS.TOP_SQL_TEXT,
    SQL_HIS.TIME_USED / 1000 TIMEUSED_MS,
    SQL_HIS.START_TIME,
    UNIX_TIMESTAMP(SQL_HIS.START_TIME), --SQL_HIS.COMMAND_TYPE,
    SESS_HIS.USER_NAME,
    SESS_HIS.CLNT_IP,
    SESS_HIS.APPNAME
FROM
    V$SQL_HISTORY SQL_HIS
    LEFT JOIN V$SESSION_HISTORY SESS_HIS ON SQL_HIS.SESS_ID = SESS_HIS.SESS_ID AND SQL_HIS.SESS_SEQ = SESS_HIS.SESS_SEQ
WHERE
    SF_GET_EP_SEQNO(SQL_HIS.ROWID) = SF_GET_SELF_EP_SEQNO()
    AND SQL_ID > 0
    AND IS_OVER = 'Y'
    AND CAST((TO_DATE(START_TIME, 'YYYY-MM-DD HH24:MI:SS') + CAST(TIME_USED / 1000000 AS INTERVAL SECOND)) AS DATETIME(0)) < SYSDATE 
    --AND TOP_SQL_TEXT NOT LIKE ?     --排除某些SQL
    --AND TIME_USED/1000/1000 >= 1         --执行耗时 1S 以上的SQL
    --AND START_TIME BETWEEN '2025-07-18 00:00:00' AND '2025-07-18 23:59:59.999'		--某一天
ORDER BY
    SQL_HIS.TIME_USED DESC;

2.15 历史最大连接数

SELECT
    TO_CHAR(CREATE_TIME, 'YYYY-MM-DD HH24') HH,
    COUNT(1) CNT
FROM
    SYS.V$SESSION_HISTORY
GROUP BY
    TO_CHAR(CREATE_TIME, 'YYYY-MM-DD HH24')
ORDER BY
    1 DESC;

2.16 当前慢SQL

--1--
SELECT
    'SP_CANCEL_SESSION_OPERATION (''' || SESS_ID || ''');' AS                 "取消会话",
    'SP_CLOSE_SESSION(''' || SESS_ID || ''');' AS                             "清除会话",
    DATEDIFF(SS, LAST_RECV_TIME, SYSDATE) AS                                  SQL_USED_TIME,
    DBMS_LOB.SUBSTR(SF_GET_SESSION_SQL(SESS_ID)) AS                           SQL_TXT,
    CURR_SCH,
    USER_NAME,
    SESS_ID,
    REPLACE(SUBSTR(CLNT_IP, 1, INSTR(CLNT_IP, ':', -1) -1), '::FFFF:', '') AS CLNT_IP,
    (SELECT
         INS_CNT || ' ' || DEL_CNT || ' ' || UPD_CNT IDU
     FROM
         V$TRX
     WHERE
         ID = A.TRX_ID
         AND TRX_ID > 0) AS                                                   "INS | DEL | UPD - COUNT",
    PARSE_TIME,
    HARD_PARSE_TIME,
    LOGIC_READ_CNT,
    PHY_READ_CNT,
    IO_WAIT_TIME,
    MAX_MEM_USED
FROM
    V$SESSIONS A
    LEFT JOIN V$SQL_STAT B ON A.SESS_ID = B.SESSID
WHERE
    1 = 1
    AND A.STATE = 'ACTIVE'
ORDER BY
    3 DESC;
--2--
SELECT
    'SP_CANCEL_SESSION_OPERATION (''' || SESS_ID || ''');' AS                                      "取消会话",
    'SP_CLOSE_SESSION(''' || SESS_ID || ''');' AS                                                  "清除会话",
    SQL_USED_TIME,
    SQL_TXT,
    CURR_SCH,
    USER_NAME,
    SESS_ID,
    CLNT_IP,
    "INS | DEL | UPD - COUNT",
    PARSE_TIME,
    HARD_PARSE_TIME,
    LOGIC_READ_CNT,
    PHY_READ_CNT,
    ROUND(PHY_READ_CNT * 1.0 * PAGE / 1024 / 1024 / DECODE(SQL_USED_TIME, 0, 1, SQL_USED_TIME)) AS PHY_READ_MB,
    IO_WAIT_TIME,
    MAX_MEM_USED
FROM
    (SELECT
         DATEDIFF(SS, LAST_RECV_TIME, SYSDATE) AS                                  SQL_USED_TIME,
         DBMS_LOB.SUBSTR(SF_GET_SESSION_SQL(SESS_ID)) AS                           SQL_TXT,
         CURR_SCH,
         USER_NAME,
         SESS_ID,
         REPLACE(SUBSTR(CLNT_IP, 1, INSTR(CLNT_IP, ':', -1) -1), '::FFFF:', '') AS CLNT_IP,
         (SELECT
              INS_CNT || ' ' || DEL_CNT || ' ' || UPD_CNT IDU
          FROM
              V$TRX
          WHERE
              ID = A.TRX_ID
              AND TRX_ID > 0) AS                                                   "INS | DEL | UPD - COUNT",
         PARSE_TIME,
         HARD_PARSE_TIME,
         LOGIC_READ_CNT,
         PHY_READ_CNT,
         IO_WAIT_TIME,
         MAX_MEM_USED
     FROM
         V$SESSIONS A
         LEFT JOIN V$SQL_STAT B ON A.SESS_ID = B.SESSID
     WHERE
         1 = 1
         AND A.STATE = 'ACTIVE')
ORDER BY
    3 DESC;

2.17 IO等待、逻辑读、物理读

SELECT
	ST.IO_WAIT_TIME,
	ST.LOGIC_READ_CNT,
	ST.PHY_READ_CNT,
	DATEDIFF (MS, S.LAST_RECV_TIME, CURRENT_TIMESTAMP) AS TIME_USED,
	DBMS_LOB.SUBSTR (SF_GET_SESSION_SQL (S.SESS_ID)) AS FULLSQL,
	S.STATE,
	ST.*
FROM
	V$SQL_STAT ST
	INNER JOIN V$SESSIONS S ON ST.SESSID = S.SESS_ID
WHERE
	S.STATE = 'ACTIVE'
ORDER BY
	LOGIC_READ_CNT DESC,
	IO_WAIT_TIME DESC;

2.18 清除运行过久的SQL

BEGIN
    FOR REC IN (SELECT
                    SESS_ID
                FROM
                    (SELECT DATEDIFF(SS, LAST_RECV_TIME, SYSDATE) SS, SF_GET_SESSION_SQL(SESS_ID), * FROM V$SESSIONS WHERE STATE = 'ACTIVE')
                WHERE
                    SS > 30) LOOP
        SP_CLOSE_SESSION(REC.SESS_ID);
    END LOOP;
END;

2.19 空闲会话清理

SELECT 
    SESS_ID,
    USER_NAME,
    CLNT_IP,
    STATE,
    TRX_ID,
    DATEDIFF(SS, LAST_RECV_TIME, SYSDATE) AS IDLE_SECONDS,
    DATEDIFF(SS, LAST_RECV_TIME, SYSDATE) / 86400 AS IDLE_DAYS,
    CREATE_TIME,
    LAST_RECV_TIME,
    SQL_TEXT,
    CASE 
        WHEN TRX_ID = 0 THEN '低风险'
        ELSE '中风险（有事务但无DML）'
    END AS RISK_LEVEL,
    'SP_CLOSE_SESSION(' || SESS_ID || ');' AS KILL_SESS_SQL
FROM 
    V$SESSIONS S
WHERE 
    S.STATE = 'IDLE'
    AND NOT EXISTS (
        SELECT 1 
        FROM V$TRX T
        WHERE T.ID = S.TRX_ID
          AND T.STATUS = 'ACTIVE'
          AND (T.INS_CNT > 0 OR T.UPD_CNT > 0 OR T.DEL_CNT > 0 OR T.UPD_INS_CNT > 0)
    )
ORDER BY 
    IDLE_SECONDS DESC;

2.20 自定义查询会话的存储过程

--分别通过SESS_ID、THRD_ID、TRX_ID定位会话
CREATE OR REPLACE PROCEDURE SYSDBA.GSBD(
    P_TYPE IN VARCHAR2, -- 查询类型：'SESS', 'THRD', 'TRX'
    P_ID   IN BIGINT    -- 对应的 ID 值
)
AS
BEGIN
    -- 根据类型选择不同的查询
    IF P_TYPE = 'SESS' THEN
        -- 按 SESS_ID 查询
        SELECT 'SP_CANCEL_SESSION_OPERATION (' || SESS_ID || ')' AS CANCEL_CMD,
               'SP_CLOSE_SESSION(' || SESS_ID || ')'            AS CLOSE_CMD,
               THRD_ID,
               SESS_ID,
               TRX_ID,
               DATEDIFF(SS, LAST_RECV_TIME, SYSDATE)           AS "EXECTIME(S)",
               STATE,
               TO_CHAR(SF_GET_SESSION_SQL(SESS_ID))            AS "SQL",
               (SELECT INS_CNT || ' ' || DEL_CNT || ' ' || UPD_CNT
                FROM V$TRX
                WHERE ID = TRX_ID
                  AND TRX_ID > 0)                              AS "更新的数据IDU",
               CURR_SCH,
               USER_NAME,
               CLNT_HOST,
               CLNT_IP,
               CLNT_TYPE,
               OSNAME,
               LEFT(LAST_SEND_TIME, 19)
        FROM V$SESSIONS
        WHERE SESS_ID = P_ID
          AND SESS_ID <> SESSID;   -- 排除当前会话

    ELSIF P_TYPE = 'THRD' THEN
        -- 按 THRD_ID 查询
        SELECT 'SP_CANCEL_SESSION_OPERATION (' || SESS_ID || ')' AS CANCEL_CMD,
               'SP_CLOSE_SESSION(' || SESS_ID || ')'            AS CLOSE_CMD,
               THRD_ID,
               SESS_ID,
               TRX_ID,
               DATEDIFF(SS, LAST_RECV_TIME, SYSDATE)           AS "EXECTIME(S)",
               STATE,
               TO_CHAR(SF_GET_SESSION_SQL(SESS_ID))            AS "SQL",
               (SELECT INS_CNT || ' ' || DEL_CNT || ' ' || UPD_CNT
                FROM V$TRX
                WHERE ID = TRX_ID
                  AND TRX_ID > 0)                              AS "更新的数据IDU",
               CURR_SCH,
               USER_NAME,
               CLNT_HOST,
               CLNT_IP,
               CLNT_TYPE,
               OSNAME,
               LEFT(LAST_SEND_TIME, 19)
        FROM V$SESSIONS
        WHERE THRD_ID = P_ID
          AND SESS_ID <> SESSID;

    ELSIF P_TYPE = 'TRX' THEN
        -- 按 TRX_ID 查询
        SELECT 'SP_CANCEL_SESSION_OPERATION (' || SESS_ID || ')' AS CANCEL_CMD,
               'SP_CLOSE_SESSION(' || SESS_ID || ')'            AS CLOSE_CMD,
               THRD_ID,
               SESS_ID,
               TRX_ID,
               DATEDIFF(SS, LAST_RECV_TIME, SYSDATE)           AS "EXECTIME(S)",
               STATE,
               TO_CHAR(SF_GET_SESSION_SQL(SESS_ID))            AS "SQL",
               (SELECT INS_CNT || ' ' || DEL_CNT || ' ' || UPD_CNT
                FROM V$TRX
                WHERE ID = TRX_ID
                  AND TRX_ID > 0)                              AS "更新的数据IDU",
               CURR_SCH,
               USER_NAME,
               CLNT_HOST,
               CLNT_IP,
               CLNT_TYPE,
               OSNAME,
               LEFT(LAST_SEND_TIME, 19)
        FROM V$SESSIONS
        WHERE TRX_ID = P_ID
          AND SESS_ID <> SESSID;

    ELSE
        -- 非法类型提示
        RAISE_APPLICATION_ERROR(-20001, '参数 P_TYPE 必须是 SESS, THRD 或 TRX');
    END IF;
END;

--调用方法
CALL SYSDBA.GSBD('SESS', 12345);
CALL SYSDBA.GSBD('THRD', 67890);
CALL SYSDBA.GSBD('TRX', 987654321);

2.21 查找全表扫描的高频SQL

WITH EXEC_STATS AS (
    SELECT SQL_ID, MAX(N_EXEC) AS N_EXEC
    FROM V$SQLTEXT
    GROUP BY SQL_ID
)
SELECT 
    H.SQL_ID,
    H.TOP_SQL_TEXT,                  -- 历史记录中的 SQL 文本（可直接用于查看）
    H.SQL_PLAN,                      -- 执行计划文本（包含操作符和代价）
    E.N_EXEC AS 执行次数
FROM 
    V$PLN_HISTORY H
    JOIN EXEC_STATS E ON H.SQL_ID = E.SQL_ID
WHERE 
    REGEXP_LIKE(H.SQL_PLAN, '#CSCN2: *\[ *([1-9][0-9]{2,}),')   -- 代价 ≥ 100 的全表扫描
    AND E.N_EXEC > 0                 -- 只统计有执行记录的 SQL
    AND H.TOP_SQL_TEXT NOT LIKE '%/*+%'
ORDER BY 
    E.N_EXEC DESC;                   -- 执行次数高的排在前面

三、补充-阻塞会话相关

3.1 阻塞源-SQL有问题用第三个

SELECT
    BLOCKER.SESS_ID AS BLOCKER_SESSID,
    BLOCKER.STATE AS BLOCKER_SESS_STATE,
    BLOCKER.TRX_ID AS BLOCKER_TRXID,
    SQLTEXT.SQL_ID AS BLOCKER_SQLID,
    BLOCKED.SESS_ID AS BLOCKED_SESSID,
    BLOCKED.TRX_ID AS BLOCKED_TRXID,
    SUBSTR(SF_GET_SESSION_SQL(BLOCKER.SESS_ID), 0, 130) AS BLOCKER_FULLSQL,
    REPLACE(BLOCKER.CLNT_IP, '::FFFF:') || '-' || BLOCKER.CLNT_HOST AS BLOCKER_CLNT_IP,
    DATEDIFF(SS, BLOCKED.LAST_RECV_TIME, SYSDATE) AS "BLOCKED_TIME(S)",
    TRXWAIT.WAIT_TIME / 1000 AS "WAIT_TIME(S)"
FROM
    V$TRXWAIT TRXWAIT,
    V$SESSIONS BLOCKED,
    V$SESSIONS BLOCKER,
    V$SQLTEXT SQLTEXT
WHERE
    TRXWAIT.ID = BLOCKED.TRX_ID
    AND TRXWAIT.WAIT_FOR_ID = BLOCKER.TRX_ID
    AND TRXWAIT.WAIT_FOR_ID NOT IN (SELECT ID FROM V$TRXWAIT)
    AND BLOCKER.SQL_TEXT = SQLTEXT.SQL_TEXT
ORDER BY
    BLOCKER_SESSID DESC,
    "BLOCKED_TIME(S)" DESC;

3.2 被阻塞-SQL有问题用第三个

SELECT
    BLOCKED.SESS_ID AS BLOCKED_SESSID,
    BLOCKED.STATE AS BLOCKED_SESS_STATE,
    BLOCKED.TRX_ID AS BLOCKED_TRXID,
    BLOCKED.SQL_ID AS BLOCKED_SQLID,
    BLOCKER.SESS_ID AS BLOCKER_SESSID,
    BLOCKER.TRX_ID AS BLOCKER_TRXID,
    SUBSTR(SF_GET_SESSION_SQL(BLOCKED.SESS_ID), 0, 130) AS BLOCKED_FULLSQL,
    REPLACE(BLOCKED.CLNT_IP, '::FFFF:') || '-' || BLOCKER.CLNT_HOST AS BLOCKED_CLNT_IP,
    DATEDIFF(SS, BLOCKED.LAST_RECV_TIME, SYSDATE) AS "BLOCKED_TIME(S)"
FROM
    V$TRXWAIT TRXWAIT,
    V$SESSIONS BLOCKED,
    V$SESSIONS BLOCKER
WHERE
    TRXWAIT.WAIT_FOR_ID = BLOCKED.TRX_ID
    AND TRXWAIT.WAIT_FOR_ID = BLOCKER.TRX_ID
ORDER BY
    BLOCKER_SESSID DESC,
    "BLOCKED_TIME(S)" DESC;

3.3 一条SQL查阻塞

因为结果集按WAIT_TIME降序排序，所以最上面的事务大概率就是阻塞源

WITH A AS
     (SELECT SESS_ID  AS WAITOR_SESSID,
             SQL_TEXT AS WAITOR_SQL,
             ID       AS WAITOR,
             WAIT_FOR_ID, -- 所等待的事物ID
             WAIT_TIME
        FROM SYS."V$SESSIONS" V,
             V$TRXWAIT        T
       WHERE TRX_ID = ID
     )
     ,
     B AS
     (SELECT SESS_ID          AS WAIT_FOR_SESSID,
             SQL_TEXT         AS WAIT_FOR_SQL,
             ID               AS WAITOR
        FROM SYS."V$SESSIONS"    V,
             V$TRXWAIT           T
       WHERE TRX_ID = WAIT_FOR_ID
     )
  SELECT A.*,
         B.WAIT_FOR_SESSID,
         B.WAIT_FOR_SQL,
         'SP_CANCEL_SESSION_OPERATION(' || WAIT_FOR_SESSID || ');' AS CANCEL_SESS_SQL,
         'SP_CLOSE_SESSION(' || WAIT_FOR_SESSID || ');'            AS KILL_SESS_SQL
    FROM A, B
   WHERE A.WAITOR = B.WAITOR
ORDER BY WAIT_TIME DESC;

完善-带被阻塞事务的数量

WITH A AS
     (SELECT SESS_ID  AS WAITOR_SESSID,
             SQL_TEXT AS WAITOR_SQL,
             ID       AS WAITOR,
             WAIT_FOR_ID, -- 所等待的事物ID
             WAIT_TIME
        FROM SYS."V$SESSIONS" V,
             V$TRXWAIT        T
       WHERE TRX_ID = ID
     )
     ,
     B AS
     (SELECT SESS_ID          AS WAIT_FOR_SESSID,
             SQL_TEXT         AS WAIT_FOR_SQL,
             ID               AS WAITOR
        FROM SYS."V$SESSIONS"    V,
             V$TRXWAIT           T
       WHERE TRX_ID = WAIT_FOR_ID
     )
SELECT WAITOR_SESSID,
       WAITOR,
       WAITOR_SQL,
       WAIT_TIME,
       WAIT_FOR_SESSID,
       WAIT_FOR_ID,
       WAIT_FOR_SQL,
       BLOCKED_COUNT,
       'SP_CANCEL_SESSION_OPERATION(' || WAIT_FOR_SESSID || ');' AS CANCEL_SESS_SQL,
       'SP_CLOSE_SESSION(' || WAIT_FOR_SESSID || ');'            AS KILL_SESS_SQL
FROM (
    SELECT A.*,
           B.WAIT_FOR_SESSID,
           B.WAIT_FOR_SQL,
           COUNT(*) OVER (PARTITION BY B.WAIT_FOR_SESSID) AS BLOCKED_COUNT,
           ROW_NUMBER() OVER (PARTITION BY B.WAIT_FOR_SESSID ORDER BY A.WAIT_TIME DESC) AS RN
    FROM A, B
    WHERE A.WAITOR = B.WAITOR
) t
WHERE RN = 1
ORDER BY WAIT_TIME DESC;

3.4 阻塞源头

SELECT
    'SP_CANCEL_SESSION_OPERATION(' || S.SESS_ID || ');' AS 取消会话,
    'SP_CLOSE_SESSION(' || S.SESS_ID || ');' AS            清除会话,
    S.SESS_ID AS                                           会话ID,
    S.TRX_ID AS                                            事务ID,
    S.USER_NAME AS                                         用户名,
    S.SQL_TEXT AS                                          当前SQL,
    S.STATE AS                                             会话状态,
    S.CLNT_IP AS                                           客户端IP,
    S.APPNAME AS                                           应用名,
    S.CREATE_TIME AS                                       会话创建时间
FROM
    V$SESSIONS S
WHERE
    S.TRX_ID IN (SELECT DISTINCT T.WAIT_FOR_ID
                 FROM V$TRXWAIT T
                 WHERE T.WAIT_FOR_ID NOT IN (SELECT ID FROM V$TRXWAIT));

另附

相关的系统动态视图

• 显示会话的具体信息：V$SESSIONS
• 显示所有活动事务的信息：V$TRX
• 显示事务等待信息：V$TRXWAIT
• 显示活动事务视图信息：V$TRX_VIEW
• 显示当前系统中锁的状态：V$LOCK
• 显示死锁的历史信息：V$DEADLOCK_HISTORY
• 当前正在执行的SQL语句的资源开销：V$SQL_STAT
  • 需要ENABLE_MONITOR=1
• 历史SQL语句执行的资源开销：V$SQL_STAT_HISTORY
  • 需要ENABLE_MONITOR=1
• 显示系统最近1000条执行时间超过预定值的SQL语句：V$LONG_EXEC_SQLS
  • 需要ENABLE_MONITOR=1、MONITOR_TIME=1
  • 预定值可通过SP_SET_LONG_TIME(5000);–修改为5S以上的SQL
  • SELECT SF_GET_LONG_TIME();–可查看当前值
• 显示系统自启动以来执行时间最长的20条SQL语句：V$SYSTEM_LONG_EXEC_SQLS
  • 需要ENABLE_MONITOR=1、MONITOR_TIME=1

当发现达梦数据库所在服务器CPU爆满需要排查时，可通过如下方法排查。

二、问题排查

（1）查询已执行超过2秒的活动SQL

SELECT * FROM
	(
		SELECT
			SESS_ID,
			SQL_TEXT,
			DATEDIFF (SS, LAST_RECV_TIME, SYSDATE) Y_EXETIME,
			SF_GET_SESSION_SQL (SESS_ID) FULLSQL,
			CLNT_IP
		FROM
			V$SESSIONS
		WHERE
			STATE = 'ACTIVE'
	)
WHERE
	Y_EXETIME >= 2;

（2）查询是否有阻塞

SELECT * FROM V$TRXWAIT;

（3）查询被阻塞的会话和引起阻塞的会话

SELECT
	SYSDATE STATTIME,
	DATEDIFF (SS, S1."LAST_SEND_TIME", SYSDATE) SS,
	'被阻塞的会话' WT,
	S1."SESS_ID" WT_SESS_ID,
	S1."SQL_TEXT" WT_SQL_TEXT,
	S1."STATE" WT_STATE,
	S1."TRX_ID" WT_TRX_ID,
	S1."USER_NAME" WT_USER_NAME,
	S1."CLNT_IP" WT_CLNT_IP,
	S1."APPNAME" WT_APPNAME,
	S1."LAST_SEND_TIME" WT_LAST_SEND_TIME,
	'引起阻塞的会话' FM,
	S2."SESS_ID" FM_SESS_ID,
	S2."SQL_TEXT" FM_SQL_TEXT,
	S2."STATE" FM_STATE,
	S2."TRX_ID" FM_TRX_ID,
	S2."USER_NAME" FM_USER_NAME,
	S2."CLNT_IP" FM_CLNT_IP,
	S2."APPNAME" FM_APPNAME,
	S2."LAST_SEND_TIME" FM_LAST_SEND_TIME
FROM
	V$SESSIONS S1,
	V$SESSIONS S2,
	V$TRXWAIT W
WHERE
	S1.TRX_ID = W.ID
	AND S2.TRX_ID = W.WAIT_FOR_ID;

根据查到的引起阻塞的信息，确认是否可以杀掉阻塞源头的会话，可以杀掉源头尝试消除阻塞。

杀掉后如未完全消除阻塞，需要再次确认是否可以进行进一步的清除会话，以完全解除阻塞。

可能用到的SQL-查杀所有引起阻塞的会话

DECLARE
V_CNT INT;
BEGIN
	SELECT COUNT(SESS_ID) INTO V_CNT FROM "SYS"."V$SESSIONS" WHERE STATE = 'ACTIVE';
    IF V_CNT>=50 THEN
		FOR REC IN (SELECT SESS_ID FROM V$SESSIONS WHERE STATE = 'ACTIVE' AND SQL_TEXT LIKE 'UPDATE %' AND CLNT_IP<>'::1' ORDER BY 1)
	    LOOP
			EXECUTE IMMEDIATE 'CALL SP_CLOSE_SESSION('||REC.SESS_ID||');';
	    END LOOP;
    END IF;
END;
/

注意
由于一般阻塞都是由更新数据引起，所以SQL中以清除UPDATE语句为例。

上述是比较常见的情况，一些特别情况下（系统刚刚迁移过来）可能是由于SQL语句的执行计划不太好，就需要排查慢SQL或者并发比较高的SQL。排查方法如下：

--查看活动会话中执行时间早的SQL
SQL> select sql_text,user_name,create_time from v$sessions where state='ACTIVE' order by create_time desc;

--查看实时SQL并发
SQL> select sql_text,user_name,count(1) from v$sessions where state='ACTIVE' group by sql_text,user_name order by 3;

重点查看上述结果集中最靠后边的（靠后边都是执行慢或并发高的）一些SQL的执行计划，并优化，便能将CPU的利用率降下来。

（4）

top命令查看占用高的线程PID

top -b -H -n 1 > top_threads.txt

再根据文件中的PID，查询V$SESSIONS视图

SELECT * FROM V$SESSIONS WHERE THRD_ID = '1162792';

另附

清除所有会话的方法

BEGIN
        FOR REC IN
        (
                SELECT * FROM V$SESSIONS WHERE SESS_ID <> SESSID()
        )
        LOOP
                SP_CLOSE_SESSION(REC.SESS_ID);
        END LOOP;
END;
/

达梦数据库在初始化实例时会有一个参数PAGE_SIZE即页大小，默认是8K。

配置不同的页大小，字段所支持的存储长度会有所不同，会有如下限制

当表中一行记录所以字段长度之和占用页大小的一半时就会出现记录超长的报错，如图

二、问题解决

考虑到实际场景，解决方法有如下几种：

1. 找到表中VARCHAR类型比较长的字段（如 VARCHAR(8000) 这种），修改成 TEXT 类型。
2. 重新初始化数据库，把页大小配置成32KB。这是一个底层参数，在数据库生命周期内都不能更改，所以必须重新初始化。（对于表中 varchar2 类型较长，并且字段较多的情况不太适合，这种情况采用方法1解决）
3. 尝试给表启用超长记录：ALTER TABLE 模式名.表名 ENABLE USING LONG ROW;

注意
方法1中TEXT大字段是不参与问题描述中的长度计算的，大字段长度能够达到 2 GB。但是要注意，大字段的使用和普通字段是有区别的。

在达梦数据库中报错字符串截断存在多种情况，报错原因不一。

二、问题解决

2.1 大字段模糊查询

当查询条件中字段为TEXT，并进行LIKE模糊查询时报错。

报错原因是因为存在隐式转换，转换时截断而导致报错。

解决方法一

首先，查看一下该大字段长度

SELECT DBMSLOB.GETLENGTH(字段);

再根据长度尝试修改参数CLOB_LIKE_MAX_LEN【静态参数】的值，并重启数据库。

CLOB_LIKE_MAX_LEN：LIKE 语句中 CLOB 类型的最大长度，单位 KB，取值范围 8~102400。

修改SQL

SP_SET_PARA_VALUE(2, 'CLOB_LIKE_MAX_LEN', 20480);
--或者
ALTER SYSTEM SET 'CLOB_LIKE_MAX_LEN' = 20480 SPFILE;

解决方法二

通过包的方法DBMS_LOB.SUBSTR可以避免报错

SELECT 1 WHERE DBMS_LOB.SUBSTR(TEXT_COLUMN) LIKE '%XXX%';

2.2 WM_CONCAT/LISTAGG 拼接

当使用WM_CONCAT/LISTAGG进行字符串拼接，拼接太多时报错。

报错原因是因为WM_CONCAT/LISTAGG函数返回类型为VARCHAR类型，所以有截断的可能。

解决方法一

使用LISTAGG2集函数替换WM_CONCAT/LISTAGG函数

SELECT LISTAGG2(NAME, ', ') WITHIN GROUP (ORDER BY NAME) AS "拼接结果" FROM PRODUCTION.PRODUCT;

注意
1.WM_CONCAT 也可以写成 WMSYS.WM_CONCAT
2.WM_CONCAT 和 LISTAGG 返回类型为 VARCHAR
3.LISTAGG2 返回类型为 CLOB

解决方法二

后续版本可以通过修改参数WM_CONCAT_LOB【静态参数】指定WM_CONCAT函数的返回值类型。0：VARCHAR 类型；1：CLOB 类型

修改SQL

SP_SET_PARA_VALUE(2, 'WM_CONCAT_LOB', 1);
--或者
ALTER SYSTEM SET 'WM_CONCAT_LOB' = 1 SPFILE;

静态参数，修改后需重启数据库生效。

三、补充

如再有其他情况报错：字符串截断。发现后即同步到该文章。

MVCC 多版本并发控制是指维持一个数据的多个版本，在保证事务隔离级的情况下，使得读写操作没有冲突，提高了数据库并发读写的性能。
因此可以解决在并发读写数据库时，做到在读操作时不用阻塞写操作，写操作也不用阻塞读操作。
当对一张表批量修改且并发量较大时，可能会报 MVCC 多版本操作冲突过多的错误。多会话同时修改表数据时报错：Too many mvcc conflict。

二、问题解决

修改数据库dm.ini文件中静态参数MVCC_RETRY_TIMES和BDTA_SIZE，重启数据库。

修改MVCC_RETRY_TIMES参数值为 100，重启数据库。

修改SQL

SP_SET_PARA_VALUE(2, 'MVCC_RETRY_TIMES', 100);
--或者
ALTER SYSTEM SET 'MVCC_RETRY_TIMES' = 100 SPFILE;

参数分析

MVCC_RETRY_TIMES 参数越大，发生 MVCC 冲突时的最大重试次数越多，报错可能性越低。
BDTA_SIZE 参数越大，批量数据处理大小（BDTA 的大小）越大，报错可能性越大。

注意
在实际业务场景中，同一时刻并发执行修改同一条数据会导致此报错，建议分析确认应用中同一时刻不同事务修改同一条数的业务合理性。达梦中控制并发冲突次数的参数为 MVCC_RETRY_TIMES，默认为 5，该参数可从一定程度上缓解冲突的概率。但该错误信息不是并发操作触发锁机制控制锁等待，而是同一时刻不同的事务修改同一条数据导致，故要综合评估业务逻辑的合理性来进行解决。

在达梦数据库中对大字段类型的列进行排序或比较时会报错[-2685]：试图在blob或者clob列上排序或比较

测试数据演示示例：

建表

CREATE TABLE T_BCLOB (ID INT PRIMARY KEY, BL BLOB, CL CLOB);

使用SQLark的数据生成功能，生成测试数据。

使用ORDER BY在大字段列进行排序

SELECT * FROM T_BCLOB ORDER BY BL,CL;

报错[-2685]：试图在blob或者clob列上排序或比较

二、问题解决

首先，对大字段进行排序本身是一个高资源消耗工作，且实际意义不大，不推荐这样编写SQL。不过，如果大字段长度不是很长，且实有这种需求，可以考虑开启功能性参数ENABLE_BLOB_CMP_FLAG【动态，会话级参数】来解决。

开启方法

SP_SET_PARA_VALUE(1, 'ENABLE_BLOB_CMP_FLAG', 1);
--或者
ALTER SYSTEM SET 'ENABLE_BLOB_CMP_FLAG' = 1 BOTH;

查询验证

--查询参数是否修改成功
SELECT PARA_NAME, PARA_VALUE, FILE_VALUE FROM V$DM_INI WHERE PARA_NAME = 'ENABLE_BLOB_CMP_FLAG';
--测试ORDER BY排序功能
SELECT * FROM T_BCLOB ORDER BY BL,CL;

执行成功

排序成功，问题解决。