查询数据量大时,关联表查询与循环查询哪个更好

数据库 SQL Server
本文通过实例来验证关联表查询和循环查询的执行速度问题,希望能对读者有所帮助。

SQL Server数据库开发中,涉及多表数据联合查询时,一般都会想当然的Inner Join、Left Join,也经常出现数据量一大查询就特别慢的问题。如果不关联表,而是在循环中,需要时再查询数据库,获取其他表的数据。本文通过以下的例子来验证查询的方式和速度的关系。

首先看看在游标中,关联表循环和循环中再查询单个数据比较:

(PS:Order表中数据共5000多一点,Member表中数据近16000)

SQL代码 关联表

 

  1. Declare @idx int,@idxCount int,@MbCd varchar(20)  
  2.  
  3. Set @idxCount = 0 
  4.  
  5. Declare Cur_Test Cursor For  
  6.  
  7. Select M.MB_CD From Order O Inner Join Member M On O.MB_CD=M.MB_CD  
  8.  
  9. Open Cur_Test  
  10.  
  11. Fetch Next From Cur_Test Into @MbCd  
  12.  
  13. While (@@FETCH_STATUS = 0)  
  14.  
  15. Begin  
  16.  
  17. Set @idx = 1 
  18.  
  19. Set @idxCount = @idxCount + @idx  
  20.  
  21. Fetch Next From Cur_Test Into @MbCd  
  22.  
  23. End  
  24.  
  25. Close Cur_Test  
  26.  
  27. DEALLOCATE Cur_Test  
  28.  
  29. print @idxCount 

 

执行时间:34秒

SQL代码 不关联表

 

  1. Declare @idx int,@idxCount int,@MbCd varchar(20)  
  2.  
  3. Set @idxCount = 0 
  4.  
  5. Declare Cur_Test Cursor For  
  6.  
  7. Select MB_CD From ORDER  
  8.  
  9. Open Cur_Test  
  10.  
  11. Fetch Next From Cur_Test Into @MbCd  
  12.  
  13. While (@@FETCH_STATUS = 0)  
  14.  
  15. Begin  
  16.  
  17. Set @idx = 0 
  18.  
  19. Select @idx = COUNT(*) From MEMBER Where MB_CD=@MbCd  
  20.  
  21. Set @idxCount = @idxCount + @idx  
  22.  
  23. Fetch Next From Cur_Test Into @MbCd  
  24.  
  25. End  
  26.  
  27. Close Cur_Test  
  28.  
  29. DEALLOCATE Cur_Test  
  30.  
  31. print @idxCount 

 

执行时间:18秒

确实,不关联表快了将近一倍。

不过,考虑到实际使用中,如果是代码中循环执行查询语句去查询单个数据,打开数据库连接、关闭数据库连接也需要消耗时间,而在游标中是不需要的,所以,也在C#中测试了一下。

首先是未关联表查询数据,代码如下:

C#代码 关联表

 

  1. int intIdxCount = 0;  
  2.  
  3. DateTime dtmBegin = DateTime.Now;  
  4.  
  5. using (DataTable dtList = new SqlDBOperator().exeSqlForDataTable("Select M.MB_CD,O.ORD_NO From ORDER O Inner Join MEMBER M On M.MB_CD=O.MB_CD"))  
  6.  
  7. 5  
  8.  
  9. {  
  10.  
  11. foreach (DataRow dr in dtList.Rows)  
  12.  
  13. {  
  14.  
  15. intIdxCount += 1;  
  16.  
  17. }  
  18.  
  19. }  
  20.  
  21. DateTime dtmEnd = DateTime.Now;  
  22.  
  23. this.litlMsg.Text = "开始执行:" + dtmBegin.ToString() + "<br/>结束执行:" + dtmEnd.ToString() + "<br/>"; 

 

执行结果:

开始执行:2011/7/19 22:15:31

结束执行:2011/7/19 22:15:31 

大约 0 秒

C#代码 不关联表

 

  1. DataTable dtTemp = new DataTable();  
  2.  
  3. DateTime dtmBegin = DateTime.Now;  
  4.  
  5. using (DataTable dtList = new SqlDBOperator().exeSqlForDataTable("Select MB_CD From ORDER"))  
  6.  
  7. {  
  8.  
  9. foreach (DataRow dr in dtList.Rows)  
  10.  
  11. {  
  12.  
  13. dtTemp = new SqlDBOperator().exeSqlForDataTable("select count(*) From MEMBER where MB_CD='" + dr["MB_CD"].ToString().Trim() + "'");  
  14.  
  15. }  
  16.  
  17. }  
  18.  
  19. DateTime dtmEnd = DateTime.Now;  
  20.  
  21. this.litlMsg.Text = "开始执行:" + dtmBegin.ToString() + "<br/>结束执行:"+dtmEnd.ToString(); 

 

执行结果:

开始执行:2011/7/19 21:56:22

结束执行:2011/7/19 21:56:43 

大约21秒

通过上面的实验得出:当数据量过大时关联查询会使执行速度过慢,我们在实际的查询过程中应根据实际情况来选择使用何种查询方式。

【编辑推荐】

  1. 误删SQL Server日志文件后怎样附加数据库
  2. SQL Server 2005数据库用户权限管理的设置
  3. 浅析SQL Server数据库专用管理员连接DAC的使用
  4. 在SQL SERVER 2005执行存储过程的权限分配问题
  5. T-SQL行列相互转换命令:PIVOT和UNPIVOT使用详解
责任编辑:赵鹏 来源: 博客园
相关推荐

2021-01-07 07:46:34

MyBatis 数据量JDBC

2012-06-05 02:20:24

JPAJava查询语言

2017-07-25 15:35:07

MysqlMysql优化LIMIT分页

2009-09-25 10:22:35

Hibernate多表

2017-09-07 16:20:39

SQL查询语句查询优化

2020-11-05 10:59:45

Mybatis

2018-09-06 16:46:33

数据库MySQL分页查询

2022-09-19 08:41:02

数据查询分离

2009-09-15 13:28:49

LINQ表间关系查询

2020-06-11 08:56:34

数据仓库数据库数据

2010-07-16 08:50:00

SQL Server表

2010-06-01 18:04:22

MySQL随机

2009-11-24 19:40:07

PHP关联数组查询结果

2021-05-11 11:05:43

SAL子查询

2018-07-11 20:07:06

数据库MySQL索引优化

2021-09-02 18:36:35

SQLWhereOn

2010-09-08 16:53:43

SQL查询循环

2010-09-30 15:52:55

DB2循环查询

2010-09-09 16:26:51

SQL循环For

2010-08-04 11:03:03

DB2数据表
点赞
收藏

51CTO技术栈公众号