一次成功的sql优化，2个表joinI/O 极大，大约9million

最新推荐文章于 2025-10-28 22:47:43 发布
原创 最新推荐文章于 2025-10-28 22:47:43 发布 · 1.4k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#sql

本文通过实例分享了一次SQL优化经验，针对2个表JOIN导致的I/O过高问题进行了解决。优化策略包括更新策略调整、避免大表直接JOIN、使用临时表等，有效减少了数据库操作的资源消耗。


原始sql：

更新#result表，更新warr_bal.I/O大的原因是CIS..trans_acd_bal数据量太大，

并且#result表的数据量并不大，且如果有重复的数据，sum出来的结果呈倍数增长。

	CREATE TABLE #scm(
		scm_no int NULL
		,amt money NULL
		)

	INSERT INTO #scm
	SELECT scm_no
		,sum(isnull(gl_amt, 0))
	FROM #result t
	INNER JOIN CIS..trans_acd_bal ta
		ON ta.gl_project = t.scm_no
	WHERE ta.gl_year = @pre_year
		AND ta.gl_month = @pre_month
	GROUP BY scm_no

	UPDATE #result
	SET warr_bal = scm.amt
	FROM #result t
	INNER JOIN #scm scm
		ON t.scm_no = scm.scm_no


修改后的sql如下：I/O小了，并且时间也减少。

循环的时候最重要的是红色的sql语句


	-----------update trans_bal from CIS..trans_acd_bal begin
	DECLARE @max_idn int
		,@min_idn int
		,@bal_amt money
		,@scm_no int

	SELECT @min_idn = isnull(min(idn), 0)
	FROM #result

	SELECT @max_idn = isnull(max(idn), 0) + 1
	FROM #result

	WHILE (@min_idn < @max_idn)
	BEGIN
		SELECT @scm_no = isnull(scm_no, 0)
			,@bal_amt = warr_bal
		FROM #result t
		WHERE t.idn = @min_idn

		IF (@bal_amt IS NULL)
		BEGIN
			SELECT @bal_amt = sum(gl_amt)
			FROM CIS..trans_acd_bal ta
			WHERE ta.gl_year = @pre_year
				AND ta.gl_month = @pre_month
				AND ta.gl_project = @scm_no

			UPDATE #result
			SET warr_bal = @bal_amt
			FROM #result t
			WHERE t.idn = @min_idn
				OR t.scm_no = @scm_no
		END

		SELECT @min_idn = min(idn)
		FROM #result
		WHERE idn > @min_idn
	END

	-----------update trans_bal from CIS..trans_acd_bal end


第二个例子：

优化前sql,2个表直接inner join I/O 异常大。

journal_entry是个大表，且有索引。

 SELECT b.dept_no
            ,max(b.dept_name) AS dept_name
    FROM journal_entry a
    INNER JOIN department_info b
            ON a.gl_department = b.dept_no
    WHERE a.gl_acct_no > 700000
    GROUP BY b.dept_no

优化后i/O降低了大概只有原来1/10的I/O， 

 SELECT a.gl_department as dept_no
            ,(select max(b.dept_name) from department_info b where a.gl_department = b.dept_no)  AS dept_name
    FROM journal_entry a
    WHERE a.gl_acct_no > 700000
    GROUP BY a.gl_department


第三个例子，普通取模循环

declare @iloop int,@ibatch int
SET @iloop = 0

	SELECT @ibatch = (count(*) / 200000) + 1
	FROM #pay_tmp

	WHILE @iloop < @ibatch
	BEGIN
		EXEC (
				"
		UPDATE #pay_tmp
		SET payment = payment + pay_amt
		FROM #pay_tmp a1701250030(index id_1)
		INNER JOIN #temp_pay b(index id_1)
			ON a1701250030.order_no = b.order_no
				AND a1701250030.order_type = b.order_type
		WHERE abs(isnull(a1701250030.order_no, 0)) % @ibatch = @iloop
		"
				)

		EXEC (
				"
		DELETE #temp_pay
		FROM #pay_tmp a1701250031(index id_1)
		INNER JOIN #temp_pay b(index id_1)
			ON a1701250031.order_no = b.order_no
				AND a1701250031.order_type = b.order_type
		WHERE abs(isnull(a1701250031.order_no, 0)) % @ibatch = @iloop
		"
				)

		INSERT #pay_tmp(
			order_type
			,order_no
			,payment
			)
		SELECT order_type
			,order_no
			,pay_amt
		FROM #temp_pay a
		WHERE abs(isnull(a.order_no, 0)) % @ibatch = @iloop

		SET @iloop = @iloop + 1
	END

第四个例子：old sql update 太大，为降低I/O,增加临时表。

old sql 每个都join 去sum，所以I/O 太大

UPDATE #result
	SET w0 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 0
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w1 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 1
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w2 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 2
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w3 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 3
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w4 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 4
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w5 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 5
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w6 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 6
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w7 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 7
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w8 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 8
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w9 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 9
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w10 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 10
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w11 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 11
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w12 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 12
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w13 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 13
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w14 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 14
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w15 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 15
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w16 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 16
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w17 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 17
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w18 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 18
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w19 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 19
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w20 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 20
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w21 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 21
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w22 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 22
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w23 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 23
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w24 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 24
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w25 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 25
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
		,w26 = (
			SELECT s.reqQty
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND s.idx = 26
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			)
	FROM #result r

	UPDATE #result
	SET forecast_total = (
			SELECT sum(isnull(s.reqQty, 0))
			FROM #res s
			WHERE r.cust_no = s.custNo
				AND r.group_id = s.group_id
				AND r.loc_no = s.loc_no
				AND r.sku_no = s.skuNo
				AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')
			GROUP BY s.custNo
				,s.group_id
				,s.loc_no
				,s.skuNo
				,isnull(ltrim(rtrim(s.refNo)), '')
			)
	FROM #result r

新的sql，放入临时表，把结果计算出来后，再去update 

insert into  #temptable
SELECT s.custNo
	,s.group_id
	,s.loc_no
	,s.skuNo
	,isnull(ltrim(rtrim(s.refNo)), '') AS refNo
	,sum(CASE 
			WHEN s.idx = 0
				THEN s.reqQty
			END) AS w0
	,sum(CASE 
			WHEN s.idx = 1
				THEN s.reqQty
			END) AS w1
	,sum(CASE 
			WHEN s.idx = 2
				THEN s.reqQty
			END) AS w2
	,sum(CASE 
			WHEN s.idx = 3
				THEN s.reqQty
			END) AS w3
	,sum(CASE 
			WHEN s.idx = 4
				THEN s.reqQty
			END) AS w4
	,sum(CASE 
			WHEN s.idx = 5
				THEN s.reqQty
			END) AS w5
	,sum(CASE 
			WHEN s.idx = 6
				THEN s.reqQty
			END) AS w6
	,sum(CASE 
			WHEN s.idx = 7
				THEN s.reqQty
			END) AS w7
	,sum(CASE 
			WHEN s.idx = 8
				THEN s.reqQty
			END) AS w8
	,sum(CASE 
			WHEN s.idx = 9
				THEN s.reqQty
			END) AS w9
	,sum(CASE 
			WHEN s.idx = 10
				THEN s.reqQty
			END) AS w10
	,sum(CASE 
			WHEN s.idx = 11
				THEN s.reqQty
			END) AS w11
	,sum(CASE 
			WHEN s.idx = 12
				THEN s.reqQty
			END) AS w12
	,sum(CASE 
			WHEN s.idx = 13
				THEN s.reqQty
			END) AS w13
	,sum(CASE 
			WHEN s.idx = 14
				THEN s.reqQty
			END) AS w14
	,sum(CASE 
			WHEN s.idx = 15
				THEN s.reqQty
			END) AS w15
	,sum(CASE 
			WHEN s.idx = 16
				THEN s.reqQty
			END) AS w16
	,sum(CASE 
			WHEN s.idx = 17
				THEN s.reqQty
			END) AS w17
	,sum(CASE 
			WHEN s.idx = 18
				THEN s.reqQty
			END) AS w18
	,sum(CASE 
			WHEN s.idx = 19
				THEN s.reqQty
			END) AS w19
	,sum(CASE 
			WHEN s.idx = 20
				THEN s.reqQty
			END) AS w20
	,sum(CASE 
			WHEN s.idx = 21
				THEN s.reqQty
			END) AS w21
	,sum(CASE 
			WHEN s.idx = 22
				THEN s.reqQty
			END) AS w22
	,sum(CASE 
			WHEN s.idx = 23
				THEN s.reqQty
			END) AS w23
	,sum(CASE 
			WHEN s.idx = 24
				THEN s.reqQty
			END) AS w24
	,sum(CASE 
			WHEN s.idx = 25
				THEN s.reqQty
			END) AS w25
	,sum(CASE 
			WHEN s.idx = 26
				THEN s.reqQty
			END) AS w26
	,sum(s.reqQty) as wall
FROM #res s
GROUP BY s.custNo
	,s.group_id
	,s.loc_no
	,s.skuNo
	,isnull(ltrim(rtrim(s.refNo)), '')

UPDATE #result
SET w0 = s.w0
	,w1 = s.w1
	,w2 = s.w2
	,w3 = s.w3
	,w4 = s.w4
	,w5 = s.w5
	,w6 = s.w6
	,w7 = s.w7
	,w8 = s.w8
	,w9 = s.w9
	,w10 = s.w10
	,w11 = s.w11
	,w12 = s.w12
	,w13 = s.w13
	,w14 = s.w14
	,w15 = s.w15
	,w16 = s.w16
	,w17 = s.w17
	,w18 = s.w18
	,w19 = s.w19
	,w20 = s.w20
	,w21 = s.w21
	,w22 = s.w22
	,w23 = s.w23
	,w24 = s.w24
	,w25 = s.w25
	,w26 = s.w26
	,forecast_total = s.wall
FROM #result r
INNER JOIN #temptable s
	ON r.cust_no = s.custNo
		AND r.group_id = s.group_id
		AND r.loc_no = s.loc_no
		AND r.sku_no = s.skuNo
		AND isnull(ltrim(rtrim(r.ref_no)), '') = isnull(ltrim(rtrim(s.refNo)), '')



数据倾斜优化：sql大小表join、group等导致的
.
08-12 1470
1、数据倾斜查看key分布的通用方案 知道数据倾斜了，但无法获知数据倾斜的key信息，可以使用以下方法查看数据倾斜。 假如 select * from tba join tbb on tba.id=tbb.id; 产生了数据倾斜 可以执行如下语句来查看key的分布： select left.key,left.cnt*right.cnt from(select key,count(*) as cnt from tba group by key) left join (select key,coun
第十三届蓝桥杯大赛软件赛决赛（C/C++ 大学C组）
NOW I GOT ONE WAY
06-25 9416
第十三届蓝桥杯大赛软件类决赛 C/C++ 大学 C 组
一条MySQL慢SQL优化（Join优化）
yangfang的博客
08-22 823
查询指定区划下的所有有效供应商 1 慢SQL及背景 ag_protocol_qualification 850万数据，ag_protocol35万数据 explain select protocol_id as id , supplier_code from ag_protocol_qualification t1 where exists (select t2.id from ag_protocol t2 where t2.instance_code = 'HNDZMC' and t2.is_delete
SQL语句优化之JOIN和LEFT JOIN 和 RIGHT JOIN语句的优化
09-09
在数据库的应用中，我们经常需要对数据库进行多表查询，然而当数据量非常大时多表查询会对执行效率产生非常大的影响，因此我们在使用JOIN和LEFT JOIN 和 RIGHT JOIN语句时要特别注意
SQL中的JOIN该如何优化
最新发布
学习Java技术栈
10-28 956
数据库JOIN操作优化指南（145字） JOIN操作是数据库查询的核心，优化需多维度策略：1）优先使用INNER JOIN，避免LEFT JOIN导致数据膨胀；2）遵循"小表驱动大表"原则优化连接顺序；3）为JOIN列创建复合索引，包含WHERE和SELECT字段；4）通过执行计划分析避免临时表和文件排序；5）大数据量时采用分区表或分库分表；6）调整数据库参数如join_buffer_size。典型优化案例显示，合理索引+SQL重写可将5秒查询降至0.1秒，扫描行数减少99%。建议结合E
SQL数据库使用JOIN的优化方法
wenbingcai的专栏
10-30 771
很早以前，也是一提到SQL Server，就觉得它的性能没法跟Oracle相比，一提到大数据处理就想到Oracle。自己一路走来，在本地blog上记录了很多优化方面的 post，对的错的都有，没有时间系列的整理出来，这篇文章将join方法的概念稍微整理在一起，给大家个参考。通过查资料了解里面提到的各种概念，在实 际中不断验证总结，完全可以对数据库一步步深入理解下去的。　　我只对SQL Server
如何应付表数据过大的查询问题?(如何尽量避免大表关联)
dhka8040652的博客
10-26 695
一般来说,对于做B/S架构的朋友来说,更有机会遇到高并发的数据库访问情况,因为现在WEB的普及速度就像火箭升空,同时就会因为高访问量带来一系列性能问题,而数据库一直是用户与商人之间交流的重要平台.用户是没有耐心忍受一个查询需要用上10秒以上的，或者更少些，如果经常出现服务器死机或者是报查询超时，我想那将是失败的项目。做了几年的WEB工作,不才,一直没有遇到过大访问量或者是海量数...
42、多目标约束优化的交互式算法
v4w5x6的博客
07-17 46
本文介绍了一种新颖的多目标约束优化问题（MO-COP）的交互式算法（MO-IA），通过三个阶段的迭代逐步缩小帕累托前沿可能存在的区域，最终为用户提供满意的帕累托解。算法利用伪树结构和诱导宽度的复杂度特性，结合聚合目标函数（AOF）和距离优化策略，有效处理离散域上的多目标权衡问题。实验评估基于不同效用函数用户的行为反应，表明算法对多数用户类型高效，同时提出了针对里昂惕夫效用函数用户的改进策略。
Python 语言创建 SAP2000 s2k 文件
Hulunbuir
09-23 3583
目 录Blog Links一、前沿二、s2k文件数据库2.1 数据库结构2.2 默认Table的创建三、属性3.1 材料属性3.2 框架截面3.3 板壳截面3.4 实体截面四、对象4.1 节点对象4.2 框架对象4.3 平面对象4.4 实体对象五、分组5.1 创建节点对象组5.2 创建框架对象组5.3 创建平面对象组5.4 创建实体对象组六、s2k文件的总成七、尾声 Blog Links DalNur | 博客总目录 Python 语言创建 HyerMesh Tcl 命令 Pytho.
SQL - DELETE
cccccc9955的博客
08-30 277
DELETE Statement 1. 单表删除 用于单个数据表中的删除行 DELETE [LOW_PRIORITY] [QUICK] [IGNORE] FROM tbl_name [[AS] tbl_alias] [PARTITION (partition_name [, partition_name]...)] [WHERE where_condition] [ORDER BY...] [LIMIT row_count] 2. 按照特定顺序删除（一定数目） 例如下面这个例子，筛选出符合wher
阿里巴巴编码规范解读（五）-MySQL数据库
gonghaiyu的博客
08-01 1392
第五部分 MySQL数据库 建表规约 1.【强制】 表达是与否概念的字段，必须使用is_xxx的方式命名，数据类型是unsigned tinyint（1表示是，0表示否）。 说明：任何字段如果为非负数，必须是unsigned。 注意：POJO类中的任何布尔类型的变量，都不要加is前缀，所以，需要在设置从is_xxx到Xxx的映射关系。数据库表示是与否的值，使用tinyint类型，坚持is_xxx的命名方式是为了明确其取值含义与取值范围。 正例：表达逻辑删除的字段名is_deleted，1表示删除，0表示未删
SQL JOIN 优化
rodneyzhaonet的专栏
09-25 495
SQL JOIN 优化大表join优化： -主要的思路还是要看索引构建的是否正确 - 用整形的数字做关联 - 使用loop join - 如果两个输入都是排序的，或者使用OPTION (MERGE JOIN）
mysql中的快连接_MySQL的JOIN（四）：JOIN优化实践之快速匹配
weixin_42363141的博客
01-26 390
这篇博文讲述如何优化扫描速度。我们通过MySQL的JOIN(二)：JOIN原理得知了两张表的JOIN操作就是不断从驱动表中取出记录，然后查找出被驱动表中与之匹配的记录并连接。这个过程的实质就是查询操作，想要优化查询操作，建索引是最常用的方式。那索引怎么建呢？我们来讨论下，首先插入测试数据。CREATE TABLEt1 (idINT PRIMARY KEYAUTO_INCREMENT,typeINT...
sql优化：JOIN
define_us的专栏
03-23 460
连接总是需要顺序的。例如三个表A,B,C。A JOIN B产生结果集合D，D再和C连接产生最终结果。连接就是这么完成的。oracle从来不会多个表同时连接的。 优化器针对可能的连接顺序，连接方法和可行的访问路径，产生一些执行计划。然后优化器估计每个计划计划并选择具有最低消耗（成本)的那个。 hash join 执行计划格式如下 hash join b...
Sql优化_Join
959
01-13 1366
1.join 基本语法 select * from table1 inner join table2 on condition select * from table1 left join table2 on condition select * from table1 right join table2 on condition inner join：内连接（等值连接） left join：左连接 right join：右连接 inner join select user.name, user.ag.
sql调优之：join的优化
norminv的博客
08-15 6611
一、join的原理 mysql都是使用（Nested Loop ）循环套嵌的方式实现join的，用小表做驱动表、大表作为匹配表，开销会小点。 Nested Loop 是有三种的：Simple Nested-Loop Join、Index Nested-Loop Join、Block Nested-Loop Join。这里介绍一下最简单，大概了解一下join的原理。 Simple Nested-Loop Join： 以左边的r表作为驱动表，每次从中取一条取匹配表中查，驱动表每次加载一次就要去匹配表中查，如果驱
SQL 优化（四）：合理使用 join
黄晓宇的博客
07-04 5007
该文章对 join 查询的三种算法做了分析，并给出了 join 语句的使用建议
【数据库】join SQL语句原理优化
芝兰生于深谷，不以无人而不芳
02-25 1152
join sql
20亿与20亿表关联优化方法(超级大表与超级大表join优化方法)
热门推荐
落落的专栏 专注SQL调优 性能调优
02-27 3万+
记得5年前遇到一个SQL，就是一个简单的两表关联，SQL跑了差不多一天一夜，这两个表都非常巨大，每个表都有几十个G，数据量每个表有20多亿，表的字段也特别多。 相信大家也知道SQL慢在哪里了，单个进程的PGA 是绝对放不下几十个G的数据，这就会导致消耗大量temp tablespace，SQL慢就是慢在temp来回来回来回...的读写数据。 遇到这种超级大表与超级大表怎么优化呢？这篇文章将告诉你答案。
12C协议中，数据有效性要求是什么？ ASCL低电平时SDA可变化 BSCL高电平时SDA必须保持稳定 CSDA电平变化需与SCL下降沿同步 DSDA仅在应答位允许跳变
06-18
<think>首先，用户的问题是：“12C协议中，数据有效性要求是什么？”选项是：A.SCL低电平时SDA可变化B.SCL高电平时SDA必须保持稳定C.SDA电平变化需与SCL下降沿同步D.SDA仅在应答位允许跳变用户提到了“12C协议”，但根据上下文，应该是“I2C协议”，因为I2C是一种常见的串行通信协议，而12C可能是个笔误。I2C协议中，数据有效性是关键部分。回忆I2C协议的基本原理：-I2C（Inter-IntegratedCircuit）是一种串行通信协议，使用两根线：SCL（SerialClock）和SDA（SerialData）。-数据有效性规则：在SCL为高电平时，SDA的数据必须保持稳定（不变），以避免错误。只有在SCL为低电平时，SDA的数据才能改变。-这是因为在SCL上升沿时，接收器采样SDA的数据。所以，在SCL高电平时，SDA必须稳定。现在，分析每个选项：A.SCL低电平时SDA可变化-正确，因为数据变化应在SCL低时发生。B.SCL高电平时SDA必须保持稳定-正确，这是数据有效性的核心。C.SDA电平变化需与SCL下降沿同步-实际上，变化通常在SCL下降沿附近，但规则是变化在SCL低时，而采样在上升沿。D.SDA仅在应答位允许跳变-不完全正确；SDA可以在任何时候变化，但只在SCL低时允许变化，应答位也有特定规则。在I2C中，数据位传输时：-当SCL为低时，发送器可以改变SDA（准备数据）。-当SCL为高时，SDA必须稳定，以便接收器在上升沿采样。-应答位（ACK/NACK）是第九位，传输规则相同：SCL高时SDA稳定。所以，最准确的选项是B。但选项A也正确。问题问“数据有效性要求”，核心是SCL高时SDA稳定。参考标准I2C规范：数据有效性定义为SDA仅在SCL低时改变，在SCL高时必须稳定。因此，正确选项应该是A和B，但问题可能只期望一个主要答案。选项C和D有误：-C：变化不需要与下降沿同步；它可以在SCL低时的任何时候变化。-D：SDA变化不只在应答位；在数据传输位也允许变化。在I2C中，SDA变化在SCL低时允许，不仅限于应答位。所以，主要要求是B：SCL高电平时SDA必须保持稳定。现在，用户要求我作为编程专家回答，并提供代码解释等。但这个问题是关于I2C协议的硬件/协议层面，而不是编程代码。不过，用户说“我会向你提问各个编程领域的相关问题”，而I2C在嵌入式编程中常见，所以我可以涉及。用户指定回答流程：回答问题-给出解释。然后提供代码（如果相关），最后提出相关问题。但这个问题不直接涉及写代码，而是协议规则。所以，我可以解释协议，然后如果可能，给出一个示例代码，比如使用Arduino或类似实现I2C通信。最后，提出相关问题。结构化回答：1.**回答问题**：直接给出答案。选项B是正确的。2.**给出解释**：详细解释I2C数据有效性规则。3.**提供代码**：虽然问题不是关于代码的，但为了符合用户要求，我可以给出一个简单的I2C通信代码示例，比如在Arduino上使用Wire库。4.**提出相关问题**：按照指定格式，列出4个相关问题。用户提供的例子是关于快排的代码和解释，所以我应该类似地处理。最终答案：数据有效性要求是SCL高电平时SDA必须保持稳定，所以选项B。但选项A也正确，但问题可能单选。看选项，似乎是多项选择，但用户没有指定。我会解释所有。在回答中，澄清。现在，为代码部分：提供一个简单的I2C主设备发送数据的代码示例。例如，使用Arduino：```cpp#include<Wire.h>voidsetup(){Wire.begin();//joinI2Cbusasmaster}voidloop(){Wire.beginTransmission(0x50);//transmittodeviceaddress0x50Wire.write(&#39;x&#39;);//sendsonebyteWire.endTransmission();//stoptransmittingdelay(100);}```然后解释代码中如何遵循数据有效性规则。最后，提出相关问题。相关问题格式：§§相关问题§§:1.···2.···3.···4.···相关问题应与I2C协议相关。</think>### 回答：I2C协议中数据有效性要求 在I2C（Inter-Integrated Circuit）协议中，数据有效性要求的核心是：**SCL（Serial Clock）高电平时，SDA（Serial Data）必须保持稳定**。这对应于选项B。 同时，选项A（SCL低电平时SDA可变化）也是正确的，因为数据变化只允许在SCL低电平时发生。但主要的数据有效性规则是SCL高电平时的稳定性，以确保在SCL上升沿时数据被可靠采样。 #### 详细解释 I2C协议是一种同步串行通信协议，使用SCL和SDA两根线进行数据传输。数据有效性规则如下： - **SCL高电平时SDA必须稳定（不变）**：这是因为接收设备在SCL的上升沿采样SDA的数据。如果SDA在SCL高电平时变化，可能会导致采样错误（如亚稳态或误读）。 - **SCL低电平时SDA可以变化**：发送设备在SCL低电平时可以改变SDA的状态，以准备下一个数据位。这包括数据位的起始、停止、数据字节传输和应答位（ACK/NACK）。 - **其他选项分析**： - 选项C（SDA电平变化需与SCL下降沿同步）：错误。SDA变化不需要严格同步于SCL下降沿；它可以在SCL低电平期间的任何时候变化，只要在SCL高电平前稳定。 - 选项D（SDA仅在应答位允许跳变）：错误。SDA变化允许在SCL低电平的任何数据位期间（包括起始位、数据字节位和应答位），而不仅限于应答位。 这些规则确保I2C通信的可靠性。例如： - 起始条件：SCL高时，SDA从高到低跳变。 - 停止条件：SCL高时，SDA从低到高跳变。 - 数据传输：每个数据位在SCL低时变化，在SCL高时稳定。 #### 代码示例 虽然I2C协议是硬件层面的规范，但在嵌入式编程中（如Arduino），我们可以使用库函数实现I2C通信。以下代码使用Arduino的Wire库演示I2C主设备发送数据，并遵守数据有效性规则。代码中，Wire库内部处理了SCL和SDA的时序，确保在SCL高时SDA稳定。 ```cpp // Arduino代码：I2C主设备向从设备发送数据 #include <Wire.h> // 引入I2C库 void setup() { Wire.begin(); // 初始化I2C总线，作为主设备 } void loop() { // 开始传输到地址为0x50的从设备 Wire.beginTransmission(0x50); // 发送一个字节的数据（例如字符 &#39;A&#39;） Wire.write(&#39;A&#39;); // 库函数在SCL低时改变SDA，在SCL高时保持稳定 // 结束传输（发送停止条件） Wire.endTransmission(); // 内部处理SCL和SDA时序 delay(100); // 延迟100ms } ``` **代码解释**： - `Wire.begin()`：初始化I2C总线。 - `Wire.beginTransmission(0x50)`：开始向地址0x50的从设备传输数据。库函数自动生成起始条件（SCL高时SDA从高到低）。 - `Wire.write(&#39;A&#39;)`：发送一个字节（ASCII &#39;A&#39;）。在底层，Wire库控制SCL和SDA： - SCL拉低时，SDA变化以设置数据位。 - SCL拉高时，SDA保持稳定，允许从设备采样。 - `Wire.endTransmission()`：结束传输并发送停止条件（SCL高时SDA从低到高）。 - 整个过程中，Wire库抽象了硬件细节，但严格遵循I2C协议的数据有效性规则。 在嵌入式系统中，开发者通常依赖库函数（如Arduino的Wire或Linux的i2c-dev）处理时序，避免手动操作GPIO。但在底层驱动开发时，需直接控制SCL和SDA引脚，确保遵守规则。 #### 注意事项 - I2C协议支持多主设备，数据有效性规则在仲裁期间尤为重要。 - 实际应用中，需考虑上拉电阻、时钟拉伸（clock stretching）和总线速度（标准模式100kHz，快速模式400kHz）。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值