<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>良的世界</title>
	<atom:link href="https://www.lemonary.cn/feed/" rel="self" type="application/rss+xml" />
	<link>https://www.lemonary.cn</link>
	<description></description>
	<lastBuildDate>Tue, 14 Apr 2026 08:42:34 +0000</lastBuildDate>
	<language>zh-Hans</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	

<image>
	<url>https://www.lemonary.cn/wp-content/uploads/2024/12/logo-150x150.jpg</url>
	<title>良的世界</title>
	<link>https://www.lemonary.cn</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>达梦数据库中常用的系统视图</title>
		<link>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e4%b8%ad%e5%b8%b8%e7%94%a8%e7%9a%84%e7%b3%bb%e7%bb%9f%e8%a7%86%e5%9b%be/</link>
					<comments>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e4%b8%ad%e5%b8%b8%e7%94%a8%e7%9a%84%e7%b3%bb%e7%bb%9f%e8%a7%86%e5%9b%be/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Tue, 14 Apr 2026 07:11:36 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2848</guid>

					<description><![CDATA[提示：可根据名称在《DM8系统管理员手册》中查看视图的详细字段信息，或直接在官网查看：DM8系统管理员手册-附 [&#8230;]]]></description>
										<content:encoded><![CDATA[
<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>提示：可根据名称在《DM8系统管理员手册》中查看视图的详细字段信息，或直接在官网查看：<a href="https://eco.dameng.com/document/dm/zh-cn/pm/dm8-admin-manual-appendix1.html">DM8系统管理员手册-附录</a></p>
</blockquote>



<h2 class="wp-block-heading">一、核心数据字典表</h2>



<p>SYSOBJECTS：记录系统中所有对象的信息。</p>



<p>SYSTEXTS：存放字典对象的文本信息。使用时，系统内部临时解析的字典对象才会放入此处。</p>



<p>SYSCOLUMNS：记录系统中所有列定义的信息。</p>



<p>SYSCONS：记录系统中所有约束的信息。</p>



<p>SYSINDEXES：记录系统中所有索引定义信息。</p>



<p>SYSOBJINFOS：记录对象的依赖信息。</p>



<p>SYSUSERS：记录系统中用户信息。</p>



<h2 class="wp-block-heading">二、Oracle兼容视图 (DBA_/ALL_/USER_)</h2>



<p>DBA_SOURCE：查看所有存储对象（函数、存储过程、包等）的源代码。</p>



<p>DBA_OBJECTS：查看数据库中所有对象的详细信息。</p>



<p>DBA_TABLES：查看数据库中所有表（包括系统表）的详细信息。</p>



<p>DBA_TAB_COLUMNS：查看数据库中所有表的列信息。</p>



<p>DBA_CONSTRAINTS：查看数据库中所有表的约束信息。</p>



<p>DBA_INDEXES：查看数据库中所有索引的信息。</p>



<p>DBA_USERS：查看数据库中所有用户的信息。</p>



<p>DBA_TAB_PRIVS：查看授予用户的所有对象权限。</p>



<h2 class="wp-block-heading">三、动态性能视图 (V$)</h2>



<p>V$SESSIONS：查看当前数据库会话信息。</p>



<p>V$LOCK：查看当前锁信息，用于死锁分析与诊断。</p>



<p>V$DATABASE：查看数据库的基本信息和状态。</p>



<p>V$TABLESPACE：查看所有表空间的基本信息。</p>



<p>V$DATAFILE：查看数据文件信息。</p>



<p>V$DM_INI：查看数据库的系统配置参数。</p>



<p>V$RLOGFILE：查看联机重做日志文件信息。</p>



<h2 class="wp-block-heading">四、用户/模式视图</h2>



<p>ALL_USERS：查看所有用户（基本信息）。</p>



<h2 class="wp-block-heading">五、鲜少使用</h2>



<h3 class="wp-block-heading">5.1 查询依赖关系</h3>



<pre class="wp-block-code"><code>SELECT * FROM DBA_DEPENDENCIES WHERE REFERENCED_NAME = 'TABNAME';</code></pre>



<h3 class="wp-block-heading">5.2 查询库中的确定性函数</h3>



<pre class="wp-block-code"><code>SELECT * FROM DBA_SOURCE 
WHERE TYPE = 'PROC' 
AND REGEXP_LIKE(TEXT, 'DETERMINISTIC', 'i') 
ORDER BY OWNER;</code></pre>



<h3 class="wp-block-heading">5.3 查询库中的HUGE表</h3>



<p>（1）查询HUGE表空间</p>



<pre class="wp-block-code"><code>SELECT * FROM SYS."V$HUGE_TABLESPACE";</code></pre>



<p>（2）达梦在创建每一个 HUGE 表时，都会自动创建一个同名的辅助表来管理它的数据。辅助表的命名规则是 原表名$AUX，查询辅助表</p>



<pre class="wp-block-code"><code>SELECT * FROM SYSOBJECTS WHERE NAME LIKE '%$AUX';</code></pre>



<p>（3）通过查找$AUX辅助表来定位所有HUGE主表</p>



<pre class="wp-block-code"><code>SELECT
    US.NAME AS 模式名,
    -- 核心逻辑：去掉末尾的$AUX，得到原始HUGE主表名
    SUBSTR(S.NAME, 1, LENGTH(S.NAME) - 4) AS HUGE主表名,
    S.NAME AS 辅助表名
FROM
    SYSOBJECTS S
JOIN
    SYSOBJECTS US ON S.SCHID = US.ID
WHERE
    S.SUBTYPE$ = 'UTAB'        -- 普通用户表
    AND S.NAME LIKE '%$AUX'    -- 过滤出AUX辅助表
    AND US.TYPE$ = 'SCH'       -- 关联模式信息
ORDER BY
    模式名, HUGE主表名;</code></pre>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>如果一个 HUGE 表是分区表，其辅助表的名称会是“子表名$AUX”。对于这种情况，上述 SQL 可能无法直接还原出原始的主表名。</p>
</blockquote>



<p>（4）查询分区HUGE表</p>



<pre class="wp-block-code"><code>SELECT DISTINCT
    PT.TABLE_OWNER,
    PT.TABLE_NAME,
    T.TABLESPACE_NAME
FROM DBA_TAB_PARTITIONS PT
LEFT JOIN DBA_TABLES T 
    ON PT.TABLE_OWNER = T.OWNER 
    AND PT.TABLE_NAME = T.TABLE_NAME
WHERE T.TABLESPACE_NAME IN (SELECT NAME FROM V$HUGE_TABLESPACE)
ORDER BY PT.TABLE_OWNER, PT.TABLE_NAME;</code></pre>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e4%b8%ad%e5%b8%b8%e7%94%a8%e7%9a%84%e7%b3%bb%e7%bb%9f%e8%a7%86%e5%9b%be/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>达梦数据库服务器的磁盘I/O监控指南</title>
		<link>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e6%9c%8d%e5%8a%a1%e5%99%a8%e7%9a%84%e7%a3%81%e7%9b%98i-o%e7%9b%91%e6%8e%a7%e6%8c%87%e5%8d%97/</link>
					<comments>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e6%9c%8d%e5%8a%a1%e5%99%a8%e7%9a%84%e7%a3%81%e7%9b%98i-o%e7%9b%91%e6%8e%a7%e6%8c%87%e5%8d%97/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Thu, 09 Apr 2026 07:34:44 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<category><![CDATA[I/O]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2828</guid>

					<description><![CDATA[一、为什么要监控磁盘 I/O 磁盘 I/O 性能直接影响到达梦数据库的事务响应速度、日志写入效率以及整体吞吐量 [&#8230;]]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">一、为什么要监控磁盘 I/O</h2>



<p>磁盘 I/O 性能直接影响到达梦数据库的事务响应速度、日志写入效率以及整体吞吐量。监控磁盘 I/O 的目的包括：</p>



<ul class="wp-block-list">
<li><strong>保障数据库响应时间</strong>：达梦数据库在大量并发写入（如 redo log、数据页刷盘）时，I/O 延迟过大会导致事务等待，降低 TPS。</li>



<li><strong>提前发现瓶颈</strong>：通过观察磁盘繁忙度（%util）和平均等待时间（await），可在性能问题影响用户之前进行干预。</li>



<li><strong>容量规划</strong>：了解 I/O 增长趋势，决定何时升级存储（如从 HDD 换为 SSD）或拆分数据文件。</li>



<li><strong>验证优化效果</strong>：修改达梦参数（如 <code>BUFFER</code>、<code>CKPT_INTERVAL</code>）或更换磁盘调度器后，通过 I/O 指标量化改进。</li>
</ul>



<h2 class="wp-block-heading">二、达梦数据库的 I/O 特征</h2>



<p>在监控之前，需要了解达梦数据库产生磁盘 I/O 的主要场景：</p>



<div class="wpdt-c row wpDataTableContainerSimpleTable wpDataTables wpDataTablesWrapper
"
    >
        <table id="wpdtSimpleTable-45"
           style="border-collapse:collapse;
                   border-spacing:0px;"
           class="wpdtSimpleTable wpDataTable"
           data-column="3"
           data-rows="6"
           data-wpID="45"
           data-responsive="0"
           data-has-header="0">

                    <tbody>        <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A1"
                    data-col-index="0"
                    data-row-index="0"
                    style=" width:19.459459459459%;                    padding:10px;
                    "
                    >
                                        I/O 类型                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="B1"
                    data-col-index="1"
                    data-row-index="0"
                    style=" width:52.216216216216%;                    padding:10px;
                    "
                    >
                                        说明                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="C1"
                    data-col-index="2"
                    data-row-index="0"
                    style=" width:28.324324324324%;                    padding:10px;
                    "
                    >
                                        典型特征                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A2"
                    data-col-index="0"
                    data-row-index="1"
                    style="                    padding:10px;
                    "
                    >
                                        数据文件读写                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B2"
                    data-col-index="1"
                    data-row-index="1"
                    style="                    padding:10px;
                    "
                    >
                                        查询时读取数据页，DML/DDL 时修改数据页并最终由检查点写回                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C2"
                    data-col-index="2"
                    data-row-index="1"
                    style="                    padding:10px;
                    "
                    >
                                        随机读 + 随机写，读写比例不定                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A3"
                    data-col-index="0"
                    data-row-index="2"
                    style="                    padding:10px;
                    "
                    >
                                        重做日志（redo log）                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B3"
                    data-col-index="1"
                    data-row-index="2"
                    style="                    padding:10px;
                    "
                    >
                                        事务提交时顺序写入 redo 日志，保证持久性                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C3"
                    data-col-index="2"
                    data-row-index="2"
                    style="                    padding:10px;
                    "
                    >
                                        顺序写，延迟敏感，写吞吐量较高                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A4"
                    data-col-index="0"
                    data-row-index="3"
                    style="                    padding:10px;
                    "
                    >
                                        归档日志                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B4"
                    data-col-index="1"
                    data-row-index="3"
                    style="                    padding:10px;
                    "
                    >
                                        日志切换后归档，通常为顺序写                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C4"
                    data-col-index="2"
                    data-row-index="3"
                    style="                    padding:10px;
                    "
                    >
                                        顺序写，可能占用大量带宽                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A5"
                    data-col-index="0"
                    data-row-index="4"
                    style="                    padding:10px;
                    "
                    >
                                        临时表空间                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B5"
                    data-col-index="1"
                    data-row-index="4"
                    style="                    padding:10px;
                    "
                    >
                                        排序、哈希连接等操作使用临时表空间                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C5"
                    data-col-index="2"
                    data-row-index="4"
                    style="                    padding:10px;
                    "
                    >
                                        多为读写混合，可能产生大量 I/O                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A6"
                    data-col-index="0"
                    data-row-index="5"
                    style="                    padding:10px;
                    "
                    >
                                        备份与恢复                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B6"
                    data-col-index="1"
                    data-row-index="5"
                    style="                    padding:10px;
                    "
                    >
                                        使用 dmrman 或 dexp 进行备份/导出                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C6"
                    data-col-index="2"
                    data-row-index="5"
                    style="                    padding:10px;
                    "
                    >
                                        顺序读或写，占用高带宽                    </td>
                                        </tr>
                    </table>
</div><style id='wpdt-custom-style-45'>
.wpdt-fs-000016 { font-size: 16px !important;}
</style>




<h2 class="wp-block-heading">三、核心 I/O 指标解读</h2>



<p>使用 <code>iostat -x -d -m 1</code> 可以获得以下关键指标。掌握这些指标是分析 I/O 性能的基础。</p>



<div class="wpdt-c row wpDataTableContainerSimpleTable wpDataTables wpDataTablesWrapper
"
    >
        <table id="wpdtSimpleTable-46"
           style="border-collapse:collapse;
                   border-spacing:0px;"
           class="wpdtSimpleTable wpDataTable"
           data-column="3"
           data-rows="7"
           data-wpID="46"
           data-responsive="0"
           data-has-header="0">

                    <tbody>        <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A1"
                    data-col-index="0"
                    data-row-index="0"
                    style=" width:10.352941176471%;                    padding:10px;
                    "
                    >
                                        指标                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="B1"
                    data-col-index="1"
                    data-row-index="0"
                    style=" width:59.921568627451%;                    padding:10px;
                    "
                    >
                                        含义                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="C1"
                    data-col-index="2"
                    data-row-index="0"
                    style=" width:29.725490196078%;                    padding:10px;
                    "
                    >
                                        健康范围参考（针对达梦数据库）                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A2"
                    data-col-index="0"
                    data-row-index="1"
                    style="                    padding:10px;
                    "
                    >
                                        r/s, w/s                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B2"
                    data-col-index="1"
                    data-row-index="1"
                    style="                    padding:10px;
                    "
                    >
                                        每秒读/写请求次数（IOPS）                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C2"
                    data-col-index="2"
                    data-row-index="1"
                    style="                    padding:10px;
                    "
                    >
                                        普通 SAS HDD 约 200~300，SSD 可达 5000+                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A3"
                    data-col-index="0"
                    data-row-index="2"
                    style="                    padding:10px;
                    "
                    >
                                        rMB/s, wMB/s                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B3"
                    data-col-index="1"
                    data-row-index="2"
                    style="                    padding:10px;
                    "
                    >
                                        每秒读/写数据量（吞吐量）                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C3"
                    data-col-index="2"
                    data-row-index="2"
                    style="                    padding:10px;
                    "
                    >
                                        HDD 约 100~200 MB/s，SATA SSD ~500 MB/s                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A4"
                    data-col-index="0"
                    data-row-index="3"
                    style="                    padding:10px;
                    "
                    >
                                        %util                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B4"
                    data-col-index="1"
                    data-row-index="3"
                    style="                    padding:10px;
                    "
                    >
                                        磁盘繁忙度，表示 I/O 请求在时间上的占比。若持续 > 80%，说明磁盘可能成为瓶颈                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C4"
                    data-col-index="2"
                    data-row-index="3"
                    style="                    padding:10px;
                    "
                    >
                                        达梦 OLTP 建议 < 70%；OLAP 可允许短期 100%                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A5"
                    data-col-index="0"
                    data-row-index="4"
                    style="                    padding:10px;
                    "
                    >
                                        await                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B5"
                    data-col-index="1"
                    data-row-index="4"
                    style="                    padding:10px;
                    "
                    >
                                        平均每次 I/O 请求的响应时间（毫秒）。对 redo log 写入尤其重要                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C5"
                    data-col-index="2"
                    data-row-index="4"
                    style="                    padding:10px;
                    "
                    >
                                        SSD < 2ms，HDD < 10ms；> 20ms 需告警                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A6"
                    data-col-index="0"
                    data-row-index="5"
                    style="                    padding:10px;
                    "
                    >
                                        avgrq-sz                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B6"
                    data-col-index="1"
                    data-row-index="5"
                    style="                    padding:10px;
                    "
                    >
                                        平均请求大小（扇区数，512 字节/扇区）。达梦默认数据页大小通常为 8KB 或 16KB（对应 16~32 扇区）                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C6"
                    data-col-index="2"
                    data-row-index="5"
                    style="                    padding:10px;
                    "
                    >
                                        数据库场景常见 16~64 扇区（8~32 KB）                    </td>
                                        </tr>
                            <tr class="wpdt-cell-row " >
                                <td class="wpdt-cell wpdt-fs-000016 wpdt-bold"
                                            data-cell-id="A7"
                    data-col-index="0"
                    data-row-index="6"
                    style="                    padding:10px;
                    "
                    >
                                        aq-sz                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="B7"
                    data-col-index="1"
                    data-row-index="6"
                    style="                    padding:10px;
                    "
                    >
                                        平均队列深度。若持续 > 2 且 await 升高，说明 I/O 压力较大                    </td>
                                                <td class="wpdt-cell wpdt-fs-000016"
                                            data-cell-id="C7"
                    data-col-index="2"
                    data-row-index="6"
                    style="                    padding:10px;
                    "
                    >
                                        一般 < 2，高并发时可接受 4~5                    </td>
                                        </tr>
                    </table>
</div><style id='wpdt-custom-style-46'>
.wpdt-fs-000016 { font-size: 16px !important;}
</style>




<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p><strong>注意</strong>：<code>%util</code> 高不一定表示磁盘坏，也可能是高性能设备（如 NVMe SSD）在多队列下利用率高但延迟仍很低。需结合 <code>await</code> 判断。</p>
</blockquote>



<h2 class="wp-block-heading">四、识别设备映射</h2>



<p>在使用 LVM（逻辑卷管理）时，<code>iostat</code> 会显示 <code>dm-0</code>、<code>dm-1</code> 等设备名。你需要知道这些设备对应哪些达梦相关的文件系统。</p>



<p><strong>使用 <code>lsblk</code> 查看树形关系</strong></p>



<pre class="wp-block-code"><code>--输出示例：
sda
└─sda3
   ├─klas-root (dm-0)  /
   ├─klas-swap  (dm-1) &#091;SWAP]
   └─klas-backup(dm-2)</code></pre>



<p>说明：</p>



<p><code>dm-0</code> → 根文件系统 <code>/</code>，若达梦软件安装在此，数据文件、redo log 也在此。<br><code>dm-1</code> → swap，监控其 I/O 可判断内存是否不足。<br><code>dm-2</code> → 备份卷，未挂载则无 I/O。</p>



<h2 class="wp-block-heading">五、常用监控命令与工具</h2>



<h3 class="wp-block-heading">5.1 实时监控（推荐组合）</h3>



<pre class="wp-block-code"><code># 每 2 秒显示所有磁盘的扩展统计，以 MB 为单位
iostat -x -d -m 2

# 只关注达梦数据目录所在的磁盘（如 dm-0）
iostat -x -d -m dm-0 2</code></pre>



<h3 class="wp-block-heading">5.2 定位 I/O 来源进程</h3>



<p>当发现磁盘繁忙时，使用以下工具找出是哪些进程产生了 I/O：</p>



<pre class="wp-block-code"><code># 类似 top，按 I/O 排序
iotop -o

# 使用 pidstat 查看每个进程的 I/O 统计
pidstat -d 2</code></pre>



<h3 class="wp-block-heading">5.3 长期记录与告警</h3>



<pre class="wp-block-code"><code>#!/bin/bash
# ============================================================
# 脚本名称: io_monitor.sh
# 脚本作者: shine
# 功能描述: 监控 Linux 主机 IO 情况并记录到日志（dmdba 用户版）
# 依赖工具: iostat (sysstat)
# 部署路径: /home/dmdba/io_monitor.sh
# 日志路径: /home/dmdba/io_logs/io_YYYYMMDD.log
# ============================================================

# ---------------------- 配置区域 ----------------------
LOG_DIR="/home/dmdba/io_logs"               # 日志存放目录（dmdba 可写）
LOG_FILE="${LOG_DIR}/io_$(date +%Y%m%d).log" # 按天分割日志
SAMPLE_COUNT=3                              # 采样次数
SAMPLE_INTERVAL=2                           # 采样间隔（秒）
# -----------------------------------------------------

# 检查 iostat 是否存在
if ! command -v iostat &amp;>/dev/null; then
    echo "错误：iostat 命令未找到，请确保已安装 sysstat。" >&amp;2
    exit 1
fi

# 创建日志目录（如果不存在）
mkdir -p "$LOG_DIR" || {
    echo "错误：无法创建日志目录 $LOG_DIR" >&amp;2
    exit 1
}

# 记录开始标记及采样数据
{
    echo "==================== $(date '+%Y-%m-%d %H:%M:%S') ===================="
    echo "采样参数: 间隔=${SAMPLE_INTERVAL}秒, 次数=${SAMPLE_COUNT}"
    echo ""

    # 执行 iostat 采集
    # -x : 显示扩展统计信息（含 await、%util 等关键指标）
    # -d : 仅显示设备利用率报告
    # -t : 打印时间戳
    # -m : 吞吐量以 MB/s 为单位（便于阅读高速存储）
    iostat -x -d -t -m "$SAMPLE_INTERVAL" "$SAMPLE_COUNT"

    echo ""
} >> "$LOG_FILE" 2>&amp;1

# 自动压缩 7 天前的原始日志（避免占用过多空间）
find "$LOG_DIR" -type f -name "io_*.log" -mtime +7 -exec gzip -f {} \;

# 自动删除 30 天前的压缩日志（彻底释放空间）
find "$LOG_DIR" -type f -name "io_*.log.gz" -mtime +30 -delete</code></pre>



<p>将以上脚本加入 crontab，每5分钟记录一次，配合监控系统（如 Zabbix、Prometheus）设置告警：</p>



<ul class="wp-block-list">
<li><code>await > 20</code>（SSD 场景）</li>



<li><code>%util > 80</code> 持续 5 分钟</li>
</ul>



<h2 class="wp-block-heading">六、总结</h2>



<p>磁盘 I/O 是达梦数据库性能的关键因素之一。通过定期使用 <code>iostat</code> 等工具监控核心指标，结合 <code>lsblk</code> 明确设备映射，并掌握针对达梦特征的分析方法，可以快速定位 I/O 瓶颈，做出合理的优化决策。建议将 I/O 监控纳入日常运维巡检体系，并与达梦自身的动态性能视图（如 <code>V$SQL_STAT</code>、<code>V$SESSION_STAT</code>、<code>V$LATCHES</code>）配合使用，形成完整的性能分析闭环。</p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e6%9c%8d%e5%8a%a1%e5%99%a8%e7%9a%84%e7%a3%81%e7%9b%98i-o%e7%9b%91%e6%8e%a7%e6%8c%87%e5%8d%97/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>SQL优化之注入HINT</title>
		<link>https://www.lemonary.cn/sql%e4%bc%98%e5%8c%96%e4%b9%8b%e6%b3%a8%e5%85%a5hint/</link>
					<comments>https://www.lemonary.cn/sql%e4%bc%98%e5%8c%96%e4%b9%8b%e6%b3%a8%e5%85%a5hint/#comments</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Thu, 19 Mar 2026 09:25:54 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<category><![CDATA[HINT]]></category>
		<category><![CDATA[SQL]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2600</guid>

					<description><![CDATA[一、说明 功能说明：为 SQL 注入 HINT 规则。SF_INJECT_HINT 方法创建的 HINT 规则 [&#8230;]]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">一、说明</h2>



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



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



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



<h2 class="wp-block-heading">二、使用</h2>



<pre class="wp-block-code"><code>--模糊匹配
SF_INJECT_HINT('SQL语句', 'HINT', 'INJECT名称', '注释', TRUE, TRUE);</code></pre>



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



<pre class="wp-block-code"><code>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;</code></pre>



<p>查询已经注入的HINT-系统视图</p>



<pre class="wp-block-code"><code>SELECT * FROM SYSINJECTHINT ORDER BY CRTDATE DESC;</code></pre>



<p>删除注入的HINT</p>



<pre class="wp-block-code"><code>SF_DEINJECT_HINT('INJECT名称');</code></pre>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/sql%e4%bc%98%e5%8c%96%e4%b9%8b%e6%b3%a8%e5%85%a5hint/feed/</wfw:commentRss>
			<slash:comments>1</slash:comments>
		
		
			</item>
		<item>
		<title>达梦数据库的重做日志</title>
		<link>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e9%87%8d%e5%81%9a%e6%97%a5%e5%bf%97/</link>
					<comments>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e9%87%8d%e5%81%9a%e6%97%a5%e5%bf%97/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Thu, 19 Mar 2026 09:24:27 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<category><![CDATA[REDO]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2486</guid>

					<description><![CDATA[一、概述 重做日志（即 REDO 日志）指在 DM 数据库中添加、删除、修改对象，或者改变数据，DM 都会按照 [&#8230;]]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">一、概述</h2>



<p>重做日志（即 REDO 日志）指在 DM 数据库中添加、删除、修改对象，或者改变数据，DM 都会按照特定的格式，将这些操作执行的结果写入到当前的重做日志文件中。重做日志文件默认以 log 为扩展名，可在初始化数据库时使用建库参数 RLOG_POSTFIX_NAME 指定重做日志文件的扩展名。每个 DM 数据库实例必须至少有 2 个重做日志文件，默认两个日志文件为 DAMENG01.log、DAMENG02.log，这两个文件循环使用。</p>



<p>重做日志文件因为是数据库正在使用的日志文件，因此被称为联机日志文件。</p>



<p>重做日志文件主要用于数据库的备份与恢复。理想情况下，数据库系统不会用到重做日志文件中的信息。然而现实世界总是充满了各种意外，比如电源故障、系统故障、介质故障，或者数据库实例进程被强制终止等，数据库缓冲区中的数据页会来不及写入数据文件。这样，在重启 DM 实例时，通过重做日志文件中的信息，就可以将数据库的状态恢复到发生意外时的状态。</p>



<p>重做日志文件对于数据库是至关重要的。它们用于存储数据库的事务日志，以便系统在出现系统故障和介质故障时能够进行故障恢复。在 DM 数据库运行过程中，任何修改数据库的操作都会产生重做日志，例如，当一条元组插入到一个表中的时候，插入的结果写入了重做日志，当删除一条元组时，删除该元组的事实也被写了进去，这样，当系统出现故障时，通过分析日志可以知道在故障发生前系统做了哪些动作，并可以重做这些动作使系统恢复到故障之前的状态。</p>



<h2 class="wp-block-heading">二、管理重做日志文件</h2>



<p>添加重做日志文件</p>



<p>在服务器打开状态下，可以添加新的重做日志文件。添加的数据文件大小最小为 4096*页大小，如页大小为 8K，则可添加的文件最小值为 4096*8k=32M。如添加重做大小为 128M 的重做日志文件DAMENG03.log。</p>



<pre class="wp-block-code"><code>ALTER DATABASE ADD LOGFILE '/data/dmdata/DAMENG/DAMENG03.log' size 128;</code></pre>



<p>扩展重做日志文件</p>



<p>在服务器打开状态下，可以扩展已有的重做日志文件的大小。如扩展重做日志文件DAMENG03.log 到 256M。</p>



<pre class="wp-block-code"><code>ALTER DATABASE RESIZE LOGFILE '/data/dmdata/DAMENG/DAMENG03.log' to 256;</code></pre>



<h2 class="wp-block-heading">三、其他</h2>



<p>在<code>V$RLOG</code>视图中监控FREE_SPACE/TOTAL_SPACE，如果空闲率低于20%就需要考虑扩容，低于1G可用一般是出现影响了。存储IO性能可以监控上看看应该有瓶颈了，还有业务层面也看看拆分大事务，间隔调度批量作业等，避免集中资源压力。扩REDO要选择在业务空闲时间进行。</p>



<pre class="wp-block-code"><code>SELECT FREE_SPACE/TOTAL_SPACE FROM V$RLOG;</code></pre>



<p>V$LOG_HISTORY：服务器启动后，记录当前节点联机日志切换的历史信息。只记录最近 128 次切换记录。</p>



<figure class="wp-block-image size-full"><img fetchpriority="high" decoding="async" width="648" height="414" src="https://www.lemonary.cn/wp-content/uploads/2026/01/image-4.png" alt="" class="wp-image-2594" srcset="https://www.lemonary.cn/wp-content/uploads/2026/01/image-4.png 648w, https://www.lemonary.cn/wp-content/uploads/2026/01/image-4-300x192.png 300w" sizes="(max-width: 648px) 100vw, 648px" /></figure>



<p><a href="https://eco.dameng.com/vip/details/203632ca14ff5be38458f06e894c3d79" target="_blank" rel="noreferrer noopener">该视图新增于2023年第二季度</a></p>



<p>以前的版本可以通过过滤日志得知重做日志的切换时间，如下：</p>



<pre class="wp-block-code"><code>cat 日志.log | grep 'rfil file switch'</code></pre>



<figure class="wp-block-image size-large"><img decoding="async" width="1024" height="221" src="https://www.lemonary.cn/wp-content/uploads/2026/02/image-1024x221.png" alt="" class="wp-image-2605" srcset="https://www.lemonary.cn/wp-content/uploads/2026/02/image-1024x221.png 1024w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-300x65.png 300w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-768x166.png 768w, https://www.lemonary.cn/wp-content/uploads/2026/02/image.png 1386w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e9%87%8d%e5%81%9a%e6%97%a5%e5%bf%97/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>达梦数据库授予其他用户下创建表的权限</title>
		<link>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e6%8e%88%e4%ba%88%e5%85%b6%e4%bb%96%e7%94%a8%e6%88%b7%e4%b8%8b%e5%88%9b%e5%bb%ba%e8%a1%a8%e7%9a%84%e6%9d%83%e9%99%90/</link>
					<comments>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e6%8e%88%e4%ba%88%e5%85%b6%e4%bb%96%e7%94%a8%e6%88%b7%e4%b8%8b%e5%88%9b%e5%bb%ba%e8%a1%a8%e7%9a%84%e6%9d%83%e9%99%90/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Thu, 19 Mar 2026 09:23:17 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2540</guid>

					<description><![CDATA[1、给用户授予在其他用户创建表或视图的权限。 2、如何授予A用户对B用户下所有表的查询权限]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">1、给用户授予在其他用户创建表或视图的权限。</h2>



<pre class="wp-block-code"><code>1.修改参数
sp_set_para_value(1,'ENABLE_DDL_ANY_PRIV',1);
2.执行授权语句
例如：grant create ANY table to "用户名"
3.修改参数为原值
sp_set_para_value(1,'ENABLE_DDL_ANY_PRIV',0);</code></pre>



<h2 class="wp-block-heading">2、如何授予A用户对B用户下所有表的查询权限</h2>



<pre class="wp-block-code"><code>1.设置 INI 参数 GRANT_SCHEMA=1，重启数据库生效。
sp_set_para_value(2,'GRANT_SCHEMA',1);
2.将模式 B 下所有对象的查询权限授予用户 A
GRANT SELECT ON SCHEMA B TO A;</code></pre>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e6%8e%88%e4%ba%88%e5%85%b6%e4%bb%96%e7%94%a8%e6%88%b7%e4%b8%8b%e5%88%9b%e5%bb%ba%e8%a1%a8%e7%9a%84%e6%9d%83%e9%99%90/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>达梦的回滚表空间ROLL</title>
		<link>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e7%9a%84%e5%9b%9e%e6%bb%9a%e8%a1%a8%e7%a9%ba%e9%97%b4roll/</link>
					<comments>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e7%9a%84%e5%9b%9e%e6%bb%9a%e8%a1%a8%e7%a9%ba%e9%97%b4roll/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Wed, 18 Mar 2026 03:05:20 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<category><![CDATA[ROLL]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2754</guid>

					<description><![CDATA[一、简单概述 ROLL 表空间完全由 DM 数据库自动维护，用户无需干预。该表空间用来存放事务运行过程中执行  [&#8230;]]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">一、简单概述</h2>



<p>ROLL 表空间完全由 DM 数据库自动维护，用户无需干预。该表空间用来存放事务运行过程中执行 DML(数据操作语言)操作之前的值，从而为访问该表的其他用户提供表数据的读一致性视图。</p>



<p>ROLL 表空间的 DBF 文件，称为 ROLL 文件。ROLL 文件用于保存系统的回滚记录，提供事务回滚时的信息。回滚文件可被分为若干回滚段，每个事务的回滚页在回滚段中各自挂链，页内则顺序存放回滚记录。</p>



<p>回滚表空间的管理和用户表空间的管理基本是一样的，区别是回滚空间的空间名固定为ROLL，不可修改。可增加和扩展回滚空间中的回滚文件，设置回滚空间的扩展属性。</p>



<h2 class="wp-block-heading">二、缩小表空间</h2>



<p>调小UNDO_RETENTION参数，减少保留时间。</p>



<p>尝试逐渐缩小表空间大小</p>



<pre class="wp-block-code"><code>--一点点降
ALTER TABLESPACE ROLL RESIZE DATAFILE '/data/dmdata/DAMENG/ROLL.DBF' TO 50G;</code></pre>



<p>增删改表数据，没有提交的话，就会先放到ROLL表空间中，提交后会清空，他的大小和总数据量没有关系，和一次修改数据的量有关系，并且如果不够用的话是会自动扩展的。</p>



<p>查询未提交的事务</p>



<pre class="wp-block-code"><code>SELECT
    T1.SQL_TEXT,
    T1.STATE,
    T1.TRX_ID,
    T2.INS_CNT,
    T2.UPD_CNT,
    T2.DEL_CNT,
    T2.UPD_INS_CNT
FROM
    V$SESSIONS T1,
    V$TRX T2
WHERE
    T1.TRX_ID = T2.ID
    AND T1.STATE = 'IDLE'
    AND T2.STATUS = 'ACTIVE'
    AND (INS_CNT &gt; 0
             OR UPD_CNT &gt; 0
             OR DEL_CNT &gt; 0
             OR UPD_INS_CNT &gt; 0);</code></pre>



<h2 class="wp-block-heading">三、关联参数</h2>



<p><code>PSEG_RECV</code>：动态系统级参数，默认值3。</p>



<p>系统故障重启时，对活动事务和已提交事务的处理方式。</p>



<ul class="wp-block-list">
<li>0：跳过回滚活动事务和 PURGE 已经提交事务的步骤。在回滚表空间出现异常、损坏、系统无法正常启动时，可将 PSEG_RECV 设置为 0，让系统启动；但存在一定风险，未提交事务的修改将无法回滚，破坏事务的原子性；另外，已提交未 PURGE 的事务，将导致部分存储空间无法回收；</li>



<li>1：回滚活动事务并 PURGE 已经提交事务；</li>



<li>2：延迟 PURGE 已提交事务，延迟回滚活动事务；</li>



<li>3：回滚活动事务，延迟 PURGE 已提交事务</li>
</ul>



<p><code>UNDO_RETENTION</code>：动态系统级参数，默认值90。</p>



<p>事务提交后回滚页保持时间，单位秒。取值范围 0~86400<br>注：类型为 DOUBLE，可支持毫秒</p>



<p><code>ENABLE_IGNORE_PURGE_REC</code>：动态会话级，默认值2。</p>



<p>当返回 EC_RN_NREC_PURGED（-7120）错误（回滚记录版本太旧，无法获取用户记录）时的处理策略；</p>



<ul class="wp-block-list">
<li>0：报错；</li>



<li>1：忽略这一条记录，继续执行；</li>



<li>2：报错并生成日志；</li>



<li>3：忽略这一条记录，继续执行，并生成日志</li>
</ul>



<h2 class="wp-block-heading">四、常用SQL</h2>



<h3 class="wp-block-heading">4.1 查询ROLL表空间数据文件使用情况</h3>



<pre class="wp-block-code"><code>SELECT
    TS.NAME AS                                                                                       TABLESPACE_NAME,
    DF.PATH AS                                                                                       DATAFILE_PATH,
    ROUND(DF.TOTAL_SIZE * PAGE / 1024.0 / 1024.0, 2) AS                                              DATAFILE_TOTAL_MB,
    ROUND((DF.TOTAL_SIZE -DF.FREE_SIZE) * PAGE / 1024.0 / 1024.0, 2) AS                              DATAFILE_USED_MB,
    ROUND(DF.FREE_SIZE * PAGE / 1024.0 / 1024.0, 2) AS                                               DATAFILE_FREE_MB,
    ROUND(LEAST(DF.TOTAL_SIZE, GREATEST((DF.FREE_PAGE_NO -1), 4096)) * PAGE / 1024.0 / 1024.0, 2) AS DATAFILE_MINSIZE
FROM
    V$TABLESPACE TS,
    V$DATAFILE DF
WHERE
    DF.GROUP_ID = TS.ID
    AND TS.NAME = 'ROLL'
ORDER BY
    TS.ID,
    DF.ID;</code></pre>



<p>查询结果的最后一列 DATAFILE_MINSIZE 是根据 FREE_PAGE_NO 这个数据估算出的可能数据文件最小尺寸，只作为参考值，如果收缩表空间文件的话，可能收缩到更小的尺寸。</p>



<p>ROLL表空间最后数据页的位置</p>



<pre class="wp-block-code"><code>SELECT EXT.TS_ID AS TABLESPACE_ID,
      MAX(TS.NAME) AS TABLESPACE_NAME,
      EXT.FILE_ID,
      MAX(CAST(EXTENT_ID AS NUMBER) * SF_GET_EXTENT_SIZE + USED)* PAGE / 1024 / 1024 AS LAST_PAGE_POS_MB
  FROM V$EXTENTS EXT,
      V$TABLESPACE TS
 WHERE EXT.STATE &lt;> 'FREE'
   AND EXT.TS_ID = TS.ID
   AND TS.NAME = 'ROLL'
 GROUP BY EXT.TS_ID,EXT.FILE_ID;</code></pre>



<h3 class="wp-block-heading">4.2 当前回滚段正在使用的大小</h3>



<pre class="wp-block-code"><code>SELECT ROUND(SUM(N_USED_PAGES) * PAGE / 1024.0 / 1024.0, 2) AS ROLL_USED_MB FROM V$PSEG_ITEMS;</code></pre>



<h3 class="wp-block-heading">4.3 定位占用ROLL的事务</h3>



<p>有时候在一些实际项目中会遇到回滚文件异常增大的情况，一般来说都是由于大事务造成的，而如何找出这个大事务对应的操作则是比较关键的问题。达梦其实提供了关于回滚段相关的动态性能视图，<code>V$PSEG_COMMIT_TRX</code>会记录已经提交但还没有purge的事务信息，而<code>V$PSEG_ITEMS</code>则会记录回滚系统中相应回滚项的信息，也就是正在执行的事务对应的回滚信息。</p>



<p>以下SQL帮助我们在大事务提交后分析确定出对应的SQL操作，仅限从事务提交后，回滚purge之前，因为一旦超过<code>UNDO_RETENTION</code>后<code>V$PSEG_COMMIT_TRX</code>中对应登记的事务信息就被清除了：</p>



<pre class="wp-block-code"><code>SELECT
    I.N_USED_PAGES * PAGE / 1024 / 1024 USED_ROLL_SPACE_MB,
    H.TOP_SQL_TEXT,
    P.ITEM_NTH,
    P.TRX_ID,
    P.CMT_TIME,
    H.AFFECTED_ROWS
FROM
    V$PSEG_COMMIT_TRX P,
    V$SQL_HISTORY H,
    (SELECT TOP 1 * FROM V$PSEG_ITEMS ORDER BY N_USED_PAGES DESC) I
WHERE
    P.TRX_ID = H.TRX_ID
    AND I.NTH = P.ITEM_NTH
    AND I.N_USED_PAGES &gt; 0
    AND AFFECTED_ROWS &gt; 0
ORDER BY
    USED_ROLL_SPACE_MB DESC;</code></pre>



<p>在做增删改查操作过程中，<code>V$PSEG_ITEMS</code>使用到的页数是动态在增加的，但是对应的<code>NTH_ITEM</code>必须在此事务提交后才能在<code>V$PSEG_COMMIT_TRX</code>中捕获到，而需要找到对应这个耗费回滚段空间的SQL必须先获取到对应的<code>TRX_ID</code>，才能在<code>V$SQL_HISTORY</code>或LOG_COMMIT日志中找到对应SQL，故在大事务执行过程中无法抓到对应SQL操作，只要当大事务提交后才能抓到对应SQL以及它使用过的ROLL空间大小；<br>需要注意的是，<code>V$PSEG_ITEMS</code>记录的是回滚项对应正在使用的PAGES，而繁忙的生产系统其中一个回滚项（默认一个实例有17个回滚项）可能会有多个I/D/U操作都已提交但还没有被purge（例如还没有到<code>UNDO_RETENTION</code>时间），所以这个联合查询查出来对应是一个回滚项中多个还没有来得及被purge的事务所占用的回滚空间总大小，具体是哪个SQL还需具体分析，但这时已经把范围缩到很小了比较容易确定是哪个SQL操作引发的。值得注意的是，我们不能完全按照影响行数来判断，因为CALL的影响行数记录值永远是1，无法得知真实影响行数。</p>



<p>下面举个栗子说明一下：</p>



<p>（1）首先查看17个回滚项对应的信息，主要关注u_used_pages字段</p>



<pre class="wp-block-code"><code>select * from v$pseg_items;</code></pre>



<figure class="wp-block-image size-large"><img decoding="async" width="1024" height="331" src="https://www.lemonary.cn/wp-content/uploads/2026/03/image-4-1024x331.png" alt="" class="wp-image-2758" srcset="https://www.lemonary.cn/wp-content/uploads/2026/03/image-4-1024x331.png 1024w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-4-300x97.png 300w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-4-768x248.png 768w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-4.png 1514w" sizes="(max-width: 1024px) 100vw, 1024px" /></figure>



<p>（2）然后查看以下测试表T3占用空间情况：</p>



<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" width="549" height="212" src="https://www.lemonary.cn/wp-content/uploads/2026/03/image-5.png" alt="" class="wp-image-2759" srcset="https://www.lemonary.cn/wp-content/uploads/2026/03/image-5.png 549w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-5-300x116.png 300w" sizes="auto, (max-width: 549px) 100vw, 549px" /></figure>



<p>（3）执行delete操作，删除10,230,000条记录</p>



<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" width="405" height="313" src="https://www.lemonary.cn/wp-content/uploads/2026/03/image-6.png" alt="" class="wp-image-2760" srcset="https://www.lemonary.cn/wp-content/uploads/2026/03/image-6.png 405w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-6-300x232.png 300w" sizes="auto, (max-width: 405px) 100vw, 405px" /></figure>



<p>（4）再查看<code>V$PSEG_ITEMS</code>发现NTH_ITEM=10对应使用了12522个page</p>



<p>我们可以换算一下,12522*32k/1024/1024=391MB，比T3表实际占用空间要稍微小一些，考虑到其他的一些空间消耗，作为查找占用回滚段空间的操作是没有问题的。</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1024" height="326" src="https://www.lemonary.cn/wp-content/uploads/2026/03/image-7-1024x326.png" alt="" class="wp-image-2761" srcset="https://www.lemonary.cn/wp-content/uploads/2026/03/image-7-1024x326.png 1024w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-7-300x96.png 300w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-7-768x245.png 768w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-7.png 1504w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></figure>



<p>（5）commit提交后，使用上述sql进行查询对应的事务操作：</p>



<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" width="853" height="132" src="https://www.lemonary.cn/wp-content/uploads/2026/03/image-8.png" alt="" class="wp-image-2762" srcset="https://www.lemonary.cn/wp-content/uploads/2026/03/image-8.png 853w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-8-300x46.png 300w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-8-768x119.png 768w" sizes="auto, (max-width: 853px) 100vw, 853px" /></figure>



<p>上述方法虽然只能在事务提交后，且回滚purge前查到，但大事务造成的回滚文件大小增加都会相当迅猛，所以我们可以配合监控回滚文件大小来使用，则可以更加精准找到对应大事务操作。</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>注意<br>当出现大事务时，log_commit日志中一定会出现大量分配回滚段的信息：</p>



<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" width="968" height="765" src="https://www.lemonary.cn/wp-content/uploads/2026/03/image-10.png" alt="" class="wp-image-2764" srcset="https://www.lemonary.cn/wp-content/uploads/2026/03/image-10.png 968w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-10-300x237.png 300w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-10-768x607.png 768w" sizes="auto, (max-width: 968px) 100vw, 968px" /></figure>



<p>而当大事务执行完并commit后，经过<code>UNDO_RETENTION</code>时间后，日志一定会出现大量purge操作，与此同时我们可以发现，做purge这个操作对应的<code>TRX_ID</code>记录的就是当初大事务的<code>TRX_ID</code>：</p>



<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" width="743" height="768" src="https://www.lemonary.cn/wp-content/uploads/2026/03/image-11.png" alt="" class="wp-image-2765" srcset="https://www.lemonary.cn/wp-content/uploads/2026/03/image-11.png 743w, https://www.lemonary.cn/wp-content/uploads/2026/03/image-11-290x300.png 290w" sizes="auto, (max-width: 743px) 100vw, 743px" /></figure>
</blockquote>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e7%9a%84%e5%9b%9e%e6%bb%9a%e8%a1%a8%e7%a9%ba%e9%97%b4roll/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>达梦数据库的作业系统</title>
		<link>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e4%bd%9c%e4%b8%9a%e7%b3%bb%e7%bb%9f/</link>
					<comments>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e4%bd%9c%e4%b8%9a%e7%b3%bb%e7%bb%9f/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Fri, 27 Feb 2026 02:58:54 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<category><![CDATA[SYSJOB]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2684</guid>

					<description><![CDATA[相关系统视图 查看某存储过程是哪个任务调用的 查看所有作业信息 查看作业运行历史信息 只查看某个作业的历史信息 [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p>相关系统视图</p>



<pre class="wp-block-code"><code>SELECT * FROM SYSJOB.SYSJOBS;
SELECT * FROM SYSJOB.SYSJOBHISTORIES2;
SELECT * FROM SYSJOB.SYSJOBSCHEDULES;
SELECT * FROM SYSJOB.SYSJOBSTEPS;</code></pre>



<p>查看某存储过程是哪个任务调用的</p>



<pre class="wp-block-code"><code>SELECT A.ID,A.NAME,A."ENABLE",A.USERNAME,A.CREATETIME,A.MODIFYTIME,A.DESCRIBE,
B.LAST_DATE||' '||B.LAST_SEC LAST_TIME,B.NEXT_DATE||' '||B.NEXT_SEC NEXT_TIME,B.WHAT::VARCHAR
FROM SYSJOB.SYSJOBS A,SYSJOB.USER_JOBS B
WHERE A.ID=B.JOB AND B.WHAT LIKE '%call procname%';</code></pre>



<p>查看所有作业信息</p>



<pre class="wp-block-code"><code>--查看所有作业信息
SELECT A.ID,A.NAME,A."ENABLE",A.USERNAME,A.CREATETIME,A.MODIFYTIME,A.DESCRIBE,
B.LAST_DATE||' '||B.LAST_SEC LAST_TIME,B.NEXT_DATE||' '||B.NEXT_SEC NEXT_TIME,B.WHAT
FROM SYSJOB.SYSJOBS A,SYSJOB.USER_JOBS B
WHERE A.ID=B.JOB;
 
--查看所有作业调度信息
SELECT * FROM SYSJOB.SYSJOBSCHEDULES;</code></pre>



<p>查看作业运行历史信息</p>



<pre class="wp-block-code"><code>SELECT *
FROM SYSJOB.SYSSTEPHISTORIES2 A
WHERE (SELECT COUNT(*)
          FROM SYSJOB.SYSSTEPHISTORIES2 B
         WHERE B.NAME = A.NAME
           AND B.EXEC_ID &gt;= A.EXEC_ID) &lt;= 10
ORDER BY A.START_TIME DESC,A.NAME;</code></pre>



<p>只查看某个作业的历史信息</p>



<pre class="wp-block-code"><code>SELECT *
FROM SYSJOB.SYSSTEPHISTORIES2 A
WHERE (SELECT COUNT(*)
          FROM SYSJOB.SYSSTEPHISTORIES2 B
         WHERE B.NAME = A.NAME
           AND B.EXEC_ID &gt;= A.EXEC_ID) &lt;= 10 
           AND NAME = '作业名'
ORDER BY A.START_TIME DESC,A.NAME;</code></pre>



<p>批量停止作业</p>



<pre class="wp-block-code"><code>BEGIN FOR JOB_REC IN (
    SELECT
        NAME
    FROM
        SYSJOB.SYSJOBS
) LOOP SP_ENABLE_JOB (JOB_REC.NAME, 0);

-- 0表示禁用
DBMS_OUTPUT.PUT_LINE ('已禁用作业: ' || JOB_REC.NAME);
END LOOP;
END;
/</code></pre>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e4%bd%9c%e4%b8%9a%e7%b3%bb%e7%bb%9f/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>Windows环境安装dmPython时报错：error: Microsoft Visual C++ 14.0 or greater is required.</title>
		<link>https://www.lemonary.cn/windows%e7%8e%af%e5%a2%83%e5%ae%89%e8%a3%85dmpython%e6%97%b6%e6%8a%a5%e9%94%99%ef%bc%9aerror-microsoft-visual-c-14-0-or-greater-is-required/</link>
					<comments>https://www.lemonary.cn/windows%e7%8e%af%e5%a2%83%e5%ae%89%e8%a3%85dmpython%e6%97%b6%e6%8a%a5%e9%94%99%ef%bc%9aerror-microsoft-visual-c-14-0-or-greater-is-required/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Wed, 25 Feb 2026 07:12:37 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<category><![CDATA[dmPython]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2656</guid>

					<description><![CDATA[一、问题概述 当使用内网Windows环境安装dmPython时由于环境中没有Microsoft Visual [&#8230;]]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">一、问题概述</h2>



<p>当使用内网Windows环境安装dmPython时由于环境中没有Microsoft Visual C++ 14.0导致报错。</p>



<pre class="wp-block-code"><code>error: Microsoft Visual C++ 14.0 or greater is required. Get it with "Microsoft C++ Build Tools": https://visualstudio.microsoft.com/visual-cpp-build-tools/</code></pre>



<h2 class="wp-block-heading">二、问题分析</h2>



<p>利用有网络的Windows服务器安装同版本Python，对dmPython源码进行编译，生成whl文件。再将whl文件拿到离线环境进行安装。</p>



<h2 class="wp-block-heading">三、解决步骤</h2>



<h3 class="wp-block-heading">3.1 安装同版本Python</h3>



<p><a href="https://www.python.org/downloads">https://www.python.org/downloads</a></p>



<h3 class="wp-block-heading">3.2 下载dmPython源码</h3>



<p>官网下载地址：<a href="https://www.dameng.com/download/index.html">https://www.dameng.com/download/index.html</a></p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1024" height="525" src="https://www.lemonary.cn/wp-content/uploads/2026/02/image-21-1024x525.png" alt="" class="wp-image-2667" srcset="https://www.lemonary.cn/wp-content/uploads/2026/02/image-21-1024x525.png 1024w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-21-300x154.png 300w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-21-768x394.png 768w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-21-1536x788.png 1536w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-21-2048x1050.png 2048w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></figure>



<p>或直接访问：<a href="https://gitee.com/DamengDB/dmPython">https://gitee.com/DamengDB/dmPython</a></p>



<h3 class="wp-block-heading">3.3 编译生成whl文件</h3>



<pre class="wp-block-code"><code>PS C:\dmPython-main&gt; python setup.py bdist_wheel</code></pre>



<p>whl文件位于dmPython-main\dist目录下</p>



<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" width="660" height="56" src="https://www.lemonary.cn/wp-content/uploads/2026/02/image-18.png" alt="" class="wp-image-2660" srcset="https://www.lemonary.cn/wp-content/uploads/2026/02/image-18.png 660w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-18-300x25.png 300w" sizes="auto, (max-width: 660px) 100vw, 660px" /></figure>



<p>报错的话可能是没有安装模块</p>



<p>python -m pip install &#8211;upgrade wheel setuptools</p>



<h3 class="wp-block-heading">3.4 将whl文件在离线环境安装</h3>



<pre class="wp-block-code"><code>PS C:\dmPython-main\dist&gt; pip install .\dmpython-2.5.26-cp313-cp313-win_amd64.whl</code></pre>



<figure class="wp-block-image size-full"><img loading="lazy" decoding="async" width="975" height="162" src="https://www.lemonary.cn/wp-content/uploads/2026/02/image-20.png" alt="" class="wp-image-2662" srcset="https://www.lemonary.cn/wp-content/uploads/2026/02/image-20.png 975w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-20-300x50.png 300w, https://www.lemonary.cn/wp-content/uploads/2026/02/image-20-768x128.png 768w" sizes="auto, (max-width: 975px) 100vw, 975px" /></figure>



<h3 class="wp-block-heading">3.5 编写程序进行测试</h3>



<pre class="wp-block-code"><code>import dmPython
conn=dmPython.connect(user='SYSDBA',password='SYSDBA',server= '192.168.10.10',port=5236)
cursor = conn.cursor()
cursor.execute('select username from dba_users')
values = cursor.fetchall()
print(values)
cursor.close()
conn.close()</code></pre>



<h2 class="wp-block-heading">四、其他思路</h2>



<p>从可以联网的机器上制作离线包，然后传输到离线环境进行安装Microsoft Visual C++以解决报错问题。</p>



<h3 class="wp-block-heading">4.1 联网机器获取 vs_buildtools.exe</h3>



<p>下载地址：<a href="https://aka.ms/vs/17/release/vs_BuildTools.exe">https://aka.ms/vs/17/release/vs_BuildTools.exe</a></p>



<h3 class="wp-block-heading">4.2 联网机器制作离线包</h3>



<p>打开命令行（cmd或PowerShell），导航到 vs_buildtools.exe 所在的目录，执行以下命令来下载完整的离线安装文件。</p>



<pre class="wp-block-code"><code>PS C:\Downloads&gt; .\vs_BuildTools.exe --layout C:\vs2022_offline --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended --lang zh-CN</code></pre>



<p><code>--layout C:\vs2022_offline</code>指定将完整的离线安装包下载到本地的 C:\vs2022_offline 文件夹，下载完成后，将整个 C:\vs2022_offline 文件夹（确保包含所有文件）拷贝到你的离线目标机上。</p>



<h3 class="wp-block-heading">4.3 离线机器上安装</h3>



<p>在离线机上，<strong>以管理员身份</strong>打开 PowerShell，进入离线包目录，然后运行</p>



<pre class="wp-block-code"><code>PS C:\vs2022_offline&gt; .\vs_setup.exe --noweb --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended</code></pre>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/windows%e7%8e%af%e5%a2%83%e5%ae%89%e8%a3%85dmpython%e6%97%b6%e6%8a%a5%e9%94%99%ef%bc%9aerror-microsoft-visual-c-14-0-or-greater-is-required/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>达梦数据库版本号解析</title>
		<link>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%89%88%e6%9c%ac%e5%8f%b7%e8%a7%a3%e6%9e%90/</link>
					<comments>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%89%88%e6%9c%ac%e5%8f%b7%e8%a7%a3%e6%9e%90/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Fri, 13 Feb 2026 07:44:08 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<category><![CDATA[ID_CODE]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2614</guid>

					<description><![CDATA[达梦ID_CODE版本解析]]></description>
										<content:encoded><![CDATA[
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>达梦ID_CODE版本解析</title>
</head>
<body>
    <!-- ★ 双重隔离盾：外层内联强制白底 + 内部Shadow DOM重置 ★ -->
    <dm-version-tool style="all: initial; display: block; background: white !important; max-width: 1100px; margin: 2rem auto;"></dm-version-tool>

    <script>
        (function() {
            // 如果自定义元素已定义则跳过
            if (customElements.get('dm-version-tool')) return;

            class DmVersionTool extends HTMLElement {
                constructor() {
                    super();
                    const shadow = this.attachShadow({ mode: 'open' });
                    shadow.innerHTML = `
                        <style>
                            /* ========== 全重置 + 暴力 important ========== */
                            :host {
                                all: initial;
                                display: block;
                                background: white !important;
                            }
                            .container {
                                all: initial;
                                display: block;
                                max-width: 1100px;
                                width: 100%;
                                margin: 0 auto;
                                background: white !important;
                                border-radius: 28px;
                                padding: 2.2rem 2.5rem;
                                box-shadow: 0 15px 35px -8px rgba(0,0,0,0.08);
                                border: 1px solid rgba(203, 213, 225, 0.2);
                                color: #1e293b;
                                box-sizing: border-box;
                                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
                            }
                            h1 {
                                all: initial;
                                display: block;
                                margin: 0 0 1.6rem 0;
                                padding: 0 0 0.6rem 0;
                                font-size: 1.95rem;
                                font-weight: 600;
                                color: #0f172a;
                                border-bottom: 3px solid #e6f0ff;
                                background: transparent !important;
                            }
                            /* ===== 输入提示区 · 绝对白底 ===== */
                            .input-desc {
                                all: initial;
                                display: block;
                                font-size: 0.95rem;
                                color: #2c3e50;
                                background: white !important;
                                background-color: white !important;
                                padding: 1.1rem 1.5rem;
                                border-radius: 18px;
                                margin-bottom: 1.4rem;
                                border: 1px solid #f0f4fa;
                                border-left: 6px solid #4f9cf7 !important;
                                box-shadow: 0 4px 12px rgba(0,0,0,0.02);
                                line-height: 1.65;
                            }
                            .input-desc:hover {
                                box-shadow: 0 6px 16px rgba(79,156,247,0.06);
                            }
                            /* 输入框——强控宽度 */
                            .dm-input {
                                all: initial;
                                display: block;
                                width: 100% !important;
                                max-width: 100% !important;
                                min-width: 300px;
                                padding: 0.95rem 1.4rem;
                                font-size: 1.05rem;
                                border: 1.5px solid #e2e8f0;
                                border-radius: 20px;
                                background: white !important;
                                color: #0f172a;
                                box-shadow: 0 2px 4px rgba(0,0,0,0.02);
                                box-sizing: border-box;
                                font-family: inherit;
                            }
                            .dm-input:focus {
                                border-color: #3b82f6;
                                box-shadow: 0 0 0 4px rgba(59,130,246,0.12);
                            }
                            .dm-input::placeholder {
                                color: #94a3b8;
                                font-weight: 300;
                            }
                            /* 错误提示——琥珀色 */
                            .error-tip {
                                all: initial;
                                display: none;
                                margin-top: 0.8rem;
                                padding: 0.75rem 1.2rem;
                                background: #fff7e6 !important;
                                color: #7a5c00;
                                border-radius: 16px;
                                font-size: 0.92rem;
                                border-left: 6px solid #ffaa33 !important;
                                border: 1px solid #ffe0a5;
                                border-left-width: 6px !important;
                                border-left-color: #ffaa33 !important;
                                font-weight: 500;
                                animation: fadeIn 0.2s ease;
                            }
                            @keyframes fadeIn {
                                from { opacity: 0; transform: translateY(-4px); }
                                to { opacity: 1; transform: translateY(0); }
                            }
                            /* 按钮组 */
                            .btn-group {
                                all: initial;
                                display: flex;
                                flex-wrap: wrap;
                                gap: 0.8rem;
                                margin-top: 1.8rem;
                                background: transparent !important;
                            }
                            .btn {
                                all: initial;
                                display: inline-flex;
                                align-items: center;
                                justify-content: center;
                                padding: 0.7rem 1.8rem;
                                font-size: 0.98rem;
                                font-weight: 500;
                                border: none;
                                border-radius: 40px;
                                background: #2563eb !important;
                                color: white !important;
                                cursor: pointer;
                                transition: all 0.18s ease;
                                box-shadow: 0 4px 8px rgba(37,99,235,0.2);
                                min-width: 100px;
                                border: 1px solid transparent;
                            }
                            .btn:hover {
                                background: #1d4ed8 !important;
                                transform: translateY(-1px);
                                box-shadow: 0 8px 14px rgba(37,99,235,0.25);
                            }
                            .btn-secondary {
                                background: #f1f5f9 !important;
                                color: #334155 !important;
                                box-shadow: none;
                                border: 1px solid #e2e8f0;
                            }
                            .btn-secondary:hover {
                                background: #e2e8f0 !important;
                                color: #0f172a !important;
                                border-color: #cbd5e1;
                            }
                            /* 结果区域 */
                            .result-area {
                                all: initial;
                                display: block;
                                margin-top: 2.2rem;
                                background: transparent !important;
                            }
                            .result-title {
                                all: initial;
                                display: flex;
                                align-items: center;
                                font-size: 1.2rem;
                                font-weight: 600;
                                color: #0f172a;
                                margin-bottom: 0.8rem;
                                background: transparent !important;
                            }
                            .result-title::before {
                                content: "📋";
                                margin-right: 8px;
                            }
                            textarea#versionInfo {
                                all: initial;
                                display: block;
                                width: 100%;
                                min-height: 140px;
                                padding: 1.2rem 1.5rem;
                                font-family: 'SF Mono', 'Menlo', 'Consolas', monospace;
                                font-size: 0.98rem;
                                line-height: 1.6;
                                color: #0f172a;
                                background: #f9fbfd !important;
                                border: 1.5px solid #e9edf2;
                                border-radius: 18px;
                                resize: vertical;
                                white-space: pre-wrap;
                                box-sizing: border-box;
                            }
                            textarea#versionInfo[readonly] {
                                background: #f8fafc !important;
                                border-color: #e0e7ef;
                            }
                            @media (max-width: 600px) {
                                .container { padding: 1.5rem; }
                                .btn-group { flex-direction: column; }
                                .btn { width: 100%; }
                            }
                        </style>
                        <div class="container">
                            <h1>达梦ID_CODE版本解析工具</h1>
                            <div class="input-desc">
                                输入ID_CODE<br>
                                ID_CODE格式：03134xxxxxx-yyyyyyyy-zzzzzz-aaaaa 或 03134xxxxxx-yyyyyyyy-zzzzzz-aaaaa packXX<br>
                                例如：03134284058-20240205-217834-20046 pack26 → 8.1.3.26 Pack26
                            </div>
                            <input type="text" id="idCodeInput" class="dm-input" placeholder="请输入ID_CODE，例如 03134284058-20240205-217834-20046 pack26">
                            <div class="error-tip" id="errorTip"></div>
                            <div class="btn-group">
                                <button class="btn" id="parseBtn">查看版本</button>
                                <button class="btn btn-secondary" id="clearBtn">清空</button>
                            </div>
                            <div class="result-area">
                                <div class="result-title">版本信息</div>
                                <textarea id="versionInfo" readonly placeholder="解析后的版本信息将显示在这里..."></textarea>
                            </div>
                        </div>
                    `;

                    // 绑定事件（内部函数不变）
                    const el = (id) => shadow.getElementById(id);
                    const input = el('idCodeInput');
                    const parseBtn = el('parseBtn');
                    const clearBtn = el('clearBtn');
                    const errorTip = el('errorTip');
                    const versionInfo = el('versionInfo');

                    const parseVersion = () => {
                        errorTip.style.display = 'none';
                        let idCode = input.value.trim();
                        if (!idCode) {
                            showError('请输入ID_CODE！');
                            versionInfo.value = '';
                            return;
                        }
                        try {
                            let packPart = '';
                            const packMatch = idCode.match(/pack(\d+)/i);
                            if (packMatch) {
                                packPart = ' Pack' + packMatch[1];
                                idCode = idCode.replace(/pack\d+/i, '').trim();
                            }
                            const firstSegment = idCode.split('-')[0];
                            if (!firstSegment) {
                                showError('ID_CODE格式错误，未找到有效分段！');
                                versionInfo.value = '';
                                return;
                            }
                            const substrVer = firstSegment.substring(2);
                            if (isNaN(Number(substrVer))) {
                                showError('ID_CODE分段包含非数字字符，解析失败！');
                                versionInfo.value = '';
                                return;
                            }
                            const intVer = parseInt(substrVer, 10);
                            let hexVer = intVer.toString(16).toUpperCase();
                            while (hexVer.length < 8) hexVer = '0' + hexVer;
                            const v1 = parseInt(hexVer.substring(0, 2), 16);
                            const v2 = parseInt(hexVer.substring(2, 4), 16);
                            const v3 = parseInt(hexVer.substring(4, 6), 16);
                            const v4 = parseInt(hexVer.substring(6, 8), 16);
                            const innerVer = `${v1}.${v2}.${v3}.${v4}`;
                            const currentVersion = innerVer + packPart;
                            versionInfo.value = `输入的ID_CODE: ${input.value.trim()}\n当前版本: ${currentVersion}`;
                        } catch (e) {
                            showError(`解析失败：${e.message}`);
                            versionInfo.value = '';
                        }
                    };

                    const clearInput = () => {
                        input.value = '';
                        versionInfo.value = '';
                        errorTip.style.display = 'none';
                    };

                    const showError = (msg) => {
                        errorTip.innerText = msg;
                        errorTip.style.display = 'block';
                    };

                    parseBtn.addEventListener('click', parseVersion);
                    clearBtn.addEventListener('click', clearInput);
					input.addEventListener('keydown', (e) => {
						if (e.key === 'Enter') {
							parseVersion();
							e.preventDefault(); // 避免回车触发表单提交
						} else if (e.key === ' ') {
							e.preventDefault();              // 阻止页面滚动
							e.stopPropagation();             // 防止事件冒泡到外部
							// 在光标位置手动插入空格
							const start = input.selectionStart;
							const end = input.selectionEnd;
							input.value = input.value.substring(0, start) + ' ' + input.value.substring(end);
							input.selectionStart = input.selectionEnd = start + 1;
							// 触发 input 事件，便于其他依赖此事件的逻辑响应
							input.dispatchEvent(new Event('input', { bubbles: true }));
						} else if (e.key === 'ArrowLeft') {
							e.preventDefault();              // 阻止外部可能的干扰
							e.stopPropagation();
							// 手动左移光标
							let newPos = input.selectionStart;
							if (newPos > 0) {
								newPos--;
							}
							input.selectionStart = input.selectionEnd = newPos;
						} else if (e.key === 'ArrowRight') {
							e.preventDefault();              // 阻止外部可能的干扰
							e.stopPropagation();
							// 手动右移光标
							let newPos = input.selectionEnd;
							if (newPos < input.value.length) {
								newPos++;
							}
							input.selectionStart = input.selectionEnd = newPos;
						}
					});
                }
            }
            customElements.define('dm-version-tool', DmVersionTool);
        })();
    </script>
</body>
</html>



<p></p>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%89%88%e6%9c%ac%e5%8f%b7%e8%a7%a3%e6%9e%90/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
		<item>
		<title>达梦数据库的全文索引</title>
		<link>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e5%85%a8%e6%96%87%e7%b4%a2%e5%bc%95/</link>
					<comments>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e5%85%a8%e6%96%87%e7%b4%a2%e5%bc%95/#respond</comments>
		
		<dc:creator><![CDATA[shine]]></dc:creator>
		<pubDate>Tue, 27 Jan 2026 06:47:48 +0000</pubDate>
				<category><![CDATA[DM]]></category>
		<category><![CDATA[全文索引]]></category>
		<guid isPermaLink="false">https://www.lemonary.cn/?p=2580</guid>

					<description><![CDATA[全文检索技术是智能信息管理的关键技术之一，其主要目的就是实现对大容量的非结构化数据的快速查找，DM 实现了全文 [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p>全文检索技术是智能信息管理的关键技术之一，其主要目的就是实现对大容量的非结构化数据的快速查找，DM 实现了全文检索功能，并将其作为 DM 服务器的一个较独立的组件，提供更加准确的全文检索功能，较好地解决了模糊查询方式带来的问题。</p>



<p>DM 中，全文索引必须在基表定义，而不能在系统表，视图，临时表，列存表，外部表上定义，同一个列只能创建一个全文索引，在创建全文索引的时候，用户可以为分词器定义分词参数，即控制分词器的数量。</p>



<p>全文检索的中文分词依赖系统词库，该词库是只读的，不允许修改。</p>



<ul class="wp-block-list">
<li>CHINESE_LEXER——中文最少分词</li>



<li>CHINESE_VGRAM_LEXER——机械双字分词</li>



<li>CHINESE_FP_LEXER——中文最多分词</li>



<li>ENGLISH_LEXER——英文分词</li>



<li>DEFAULT_LEXER——默认分词，中文最少分词</li>
</ul>



<p>创建全文索引后，系统会自动产生如下辅助表</p>



<ul class="wp-block-list">
<li>I 表：CTI$INDEX_NAME$I 用来保存分词结果</li>



<li>P 表：CTI$INDEX_NAME$P 用来保存基表发生的增量数据变化</li>



<li>N 表：CTI$INDEX_NAME$N 用来保存原表记录ROWID 和新记录条记录 DOCID 的映射关系</li>



<li>D 表：CTI$INDEX_NAME$D 保存了所有的将被删除的DOCID</li>
</ul>



<p>创建全文索引</p>



<pre class="wp-block-code"><code>CREATE CONTEXT INDEX CTI_PERSON_ADDRESS1 ON PERSON.ADDRESS(ADDRESS1) LEXER DEFAULT_LEXER;</code></pre>



<p>全文索引的基本信息会保存到CTISYS模式下的系统表SYSCONTEXTINDEXES中</p>



<figure class="wp-block-image size-large"><img loading="lazy" decoding="async" width="1024" height="67" src="https://www.lemonary.cn/wp-content/uploads/2026/01/image-2-1024x67.png" alt="" class="wp-image-2581" srcset="https://www.lemonary.cn/wp-content/uploads/2026/01/image-2-1024x67.png 1024w, https://www.lemonary.cn/wp-content/uploads/2026/01/image-2-300x20.png 300w, https://www.lemonary.cn/wp-content/uploads/2026/01/image-2-768x50.png 768w, https://www.lemonary.cn/wp-content/uploads/2026/01/image-2.png 1133w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></figure>



<p>查询分词</p>



<pre class="wp-block-code"><code>--查询前需要在全文索引处右键-完全填充
SELECT WORD FROM PERSON.CTI$CTI_PERSON_ADDRESS1$I;</code></pre>



<p>重建全文索引</p>



<pre class="wp-block-code"><code>ALTER CONTEXT INDEX CTI_PERSON_ADDRESS1 ON PERSON.ADDRESS REBUILD;</code></pre>



<p>利用全文索引搜索</p>



<pre class="wp-block-code"><code>SELECT * FROM PERSON.ADDRESS WHERE CONTAINS(ADDRESS1,'洪山区' AND '春晓' AND '202');</code></pre>



<p>普通模糊查询</p>



<pre class="wp-block-code"><code>SELECT * FROM PERSON.ADDRESS WHERE ADDRESS1 LIKE '%洪山区%' AND ADDRESS1 LIKE '%春晓%' AND ADDRESS1 LIKE '%202%';</code></pre>



<p>用全文索引+条件</p>



<pre class="wp-block-code"><code>SELECT * FROM PERSON.ADDRESS WHERE CONTAINS(ADDRESS1,'洪山区' AND '春晓' AND '202') AND CITY='武汉市洪山区';</code></pre>



<p>更新增加全文索引</p>



<pre class="wp-block-code"><code>ALTER CONTEXT INDEX CTI_PERSON_ADDRESS1 ON PERSON.ADDRESS INCREMENT;</code></pre>



<p>删除全文索引</p>



<pre class="wp-block-code"><code>DROP CONTEXT INDEX CTI_PERSON_ADDRESS1 ON PERSON.ADDRESS;</code></pre>



<p>查看全文索引</p>



<pre class="wp-block-code"><code>SELECT * FROM CTISYS.SYSCONTEXTINDEXES;</code></pre>



<p>自定义函数查看分词</p>



<pre class="wp-block-code"><code>--获取分词的函数
CREATE OR REPLACE FUNCTION F_GET_CTI_TOKEN(V_INPUT VARCHAR2)
RETURN VARCHAR2
IS
  PRAGMA AUTONOMOUS_TRANSACTION;
  V_TMP_TABNAME VARCHAR2(128);
  V_RET VARCHAR2(32767);
BEGIN
  V_TMP_TABNAME := 'T_'||SYS_GUID;
  EXECUTE IMMEDIATE 'CREATE TABLE '||V_TMP_TABNAME||'(VAL VARCHAR2(4000))';
  EXECUTE IMMEDIATE 'INSERT INTO '||V_TMP_TABNAME||' VALUES(?)' USING V_INPUT;
  EXECUTE IMMEDIATE 'COMMIT';
  EXECUTE IMMEDIATE 'CREATE CONTEXT INDEX CTI_'||V_TMP_TABNAME||' ON '||V_TMP_TABNAME||' (VAL) LEXER CHINESE_LEXER SYNC ';
  EXECUTE IMMEDIATE 'SELECT LISTAGG(WORD,'','') WITHIN GROUP (ORDER BY ROWID) FROM CTI$CTI_'||V_TMP_TABNAME||'$I' INTO V_RET;
  EXECUTE IMMEDIATE 'DROP TABLE '||V_TMP_TABNAME||' CASCADE PURGE ';
  RETURN V_RET;
END;

--测试
SELECT F_GET_CTI_TOKEN('我这里测试一下看看效果如何，如果效果不好，要再次换一个办法来测试才行');
--返回
我,这里,测试,一下,看看,效果,如何,如果,不好,要,行,再次,换,一个,办法,来,才

SELECT F_GET_CTI_TOKEN('北京市东城区东长安街33号');
--返回
东,33,号,北京市,东城区,长安街
</code></pre>
]]></content:encoded>
					
					<wfw:commentRss>https://www.lemonary.cn/%e8%be%be%e6%a2%a6%e6%95%b0%e6%8d%ae%e5%ba%93%e7%9a%84%e5%85%a8%e6%96%87%e7%b4%a2%e5%bc%95/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
			</item>
	</channel>
</rss>
