问题描述： 有一个查询如下，去掉 top 1 的时候，很快就出来结果了，但加上 top 1 的时候，一般要 2~3 秒才出数据，何解？ select top 1 ? a . invno from a , b where a . item = b . itemnumber ? and b . ownercompanycode is not null ? 问题原因分
问题描述：
有一个查询如下，去掉top 1的时候，很快就出来结果了，但加上top 1的时候，一般要2~3秒才出数据，何解？
select top 1
? a.invno
from a, b
where a.item = b.itemnumber
? and b.ownercompanycode is not null
?
问题原因分析：
在使用top 1的时候，sql server会尽力先找出这条top 1的记录，这就导致它采用了与不加top时不一致的扫描算法，sql server查询优化器始终认为，应该可以比较快的找到匹配的第1条记录，所以一般是使用嵌套循环的联接，则不加top 1时，sql server会根据结构和数据的统计信息决策出联接策略。嵌套循环一般适用于联系的两个表，一个表的数据较大，而另一个表的数据较小的情况，如果查询匹配的值出现在扫描的前端，则在取top 1的情况下，是符合嵌套循环联系的使用条件的，但当匹配的数据出现在扫描的后端，或者是基本上没有匹配的数据时，则嵌套循环要扫描完成两个大表，这显然是不适宜的，也正是因为这种情况，导致了top 1比不加top 1的效率慢很多
?
关于此问题的模拟环境：
use tempdb
go
?
set nocount on
--======================================
--创建测试环境
--======================================
raiserror('创建测试环境', 10, 1) with nowait
-- table a
create table [dbo].a(
? [trannumber] [int] identity(1, 1) not null,
? [invno] [char](8) not null,
? [item] [char](15) null default (''),
? primary key([trannumber])
)
?
create index [indexoninvno] on [dbo].a([invno])
create index [indexonitem] on [dbo].a ([item])
create index [indexoniteminnvo] on [dbo].a([invno], [item])
go
?
-- table b
create table [dbo].b(
? [itemnumber] [char](15) not null default (''),
? [companycode] [char] (4) not null,
? [ownercompanycode] [char](4) null,
? primary key([itemnumber], [companycode])
)
?
create index [itemnumber] on [dbo].b([itemnumber])
create index [companycode] on [dbo].b([companycode])
create index [ownercompanycode] on [dbo].b([ownercompanycode])
go
?
--======================================
--生成测试数据
--======================================
raiserror('生成测试数据', 10, 1) with nowait
insert [dbo].a([invno], [item])
select left(newid(), 8), right(newid(), 15)
from syscolumns a, syscolumns b
?
insert [dbo].b([itemnumber], [companycode], [ownercompanycode])
select right(newid(), 15), left(newid(), 4), left(newid(), 4)
from syscolumns a, syscolumns b
go
?
速度测试脚本：
--======================================
--进行查询测试
--======================================
raiserror('进行查询测试', 10, 1) with nowait
declare @dt datetime, @id int, @loop int
declare @ table(
? id int identity,
? [top 1] int,
? [without top] int)
?
set @loop = 0
while @loop 10
begin
? set @loop = @loop + 1
? raiserror('test %d', 10, 1, @loop) with nowait
? set @dt = getdate()
? select top 1
? a.invno
? from a, b
? where a.item = b.itemnumber
? and b.ownercompanycode is not null
? insert @([top 1]) values(datediff(ms, @dt, getdate()))
? select @id = scope_identity(), @dt = getdate()
? select --top 1
? a.invno
? from a, b
? where a.item = b.itemnumber
? and b.ownercompanycode is not null
? update @ set [without top] = datediff(ms, @dt, getdate())
? where id = @id
end
select * from @
union all
select null, sum([top 1]), sum([without top]) from @
go
?
测试数据的变更脚本：
declare @value char(15), @value1 char(15)
select
? @value = left(newid(), 15),
? @value1 = left(newid(), 15)
?
update a
set item = @value
from a
? inner join(
? select top 1
? [trannumber]
? from(
? select top 20 percent
? [trannumber]
? from a
? order by [trannumber]
? )aa
? order by [trannumber] desc
? )b
? on a.[trannumber] = b.[trannumber]
?
update b
set itemnumber = @value
from b
? inner join(
? ? select top 1
? [itemnumber], [companycode]
? from(
? select top 20 percent
? [itemnumber], [companycode]
? from b
? order by [itemnumber], [companycode]
? )bb
? order by [itemnumber] desc, [companycode] desc
? )b1
? on b.[itemnumber] = b1.[itemnumber]
? and b.[companycode] = b1.[companycode]
go
?
测试说明：
1． 在刚建立好测试环境的时候，是没有任何匹配项的，这时候，top 1会扫描两个表的所有数据，运行“速度测试脚本”可以看到此时有无top 1的效率差异：top 1明显比不加top 慢
2． 修改“测试数据的变更脚本”中，红色的20，让匹配的数据出现在扫描的顶端、中间和尾端，分别使用“速度测试脚本”测试，可以看到，匹配的值靠近扫描的前端的时候，top 1比不加top 快，随着匹配数据很后端的推移，这种效率差异会越来越小，到后面就变成top 1比不加top 1慢。
注意：每次变更数据，并且完成“速度测试脚本”测试后，需要修改“测试数据的变更脚本”中，红色的@value为@value1，让刚才设置匹配的数据再变回为不匹配
?
附：联接的几种方式
1． 嵌套循环联接
嵌套循环联接也称为“嵌套迭代”，它将一个联接输入用作外部输入表（显示为图形执行计划中的顶端输入），将另一个联接输入用作内部（底端）输入表。外部循环逐行处理外部输入表。内部循环会针对每个外部行执行，在内部输入表中搜索匹配行。
最简单的情况是，搜索时扫描整个表或索引；这称为“单纯嵌套循环联接”。如果搜索时使用索引，则称为“索引嵌套循环联接”。如果将索引生成为查询计划的一部分（并在查询完成后立即将索引破坏），则称为“临时索引嵌套循环联接”。查询优化器考虑了所有这些不同情况。
如果外部输入较小而内部输入较大且预先创建了索引，则嵌套循环联接尤其有效。在许多小事务中（如那些只影响较小的一组行的事务），索引嵌套循环联接优于合并联接和哈希联接。但在大型查询中，嵌套循环联接通常不是最佳选择。
?
2． 合并联接
合并联接要求两个输入都在合并列上排序，而合并列由联接谓词的等效 (on) 子句定义。通常，查询优化器扫描索引（如果在适当的一组列上存在索引），或在合并联接的下面放一个排序运算符。在极少数情况下，虽然可能有多个等效子句，但只用其中一些可用的等效子句获得合并列。
由于每个输入都已排序，因此 merge join 运算符将从每个输入获取一行并将其进行比较。例如，对于内联接操作，如果行相等则返回。如果行不相等，则废弃值较小的行并从该输入获得另一行。这一过程将重复进行，直到处理完所有的行为止。
合并联接操作可以是常规操作，也可以是多对多操作。多对多合并联接使用临时表存储行。如果每个输入中有重复值，则在处理其中一个输入中的每个重复项时，另一个输入必须重绕到重复项的开始位置。
如果存在驻留谓词，则所有满足合并谓词的行都将对该驻留谓词取值，而只返回那些满足该驻留谓词的行。
合并联接本身的速度很快，但如果需要排序操作，选择合并联接就会非常费时。然而，如果数据量很大且能够从现有 b 树索引中获得预排序的所需数据，则合并联接通常是最快的可用联接算法。
?
3． 哈希联接
哈希联接有两种输入：生成输入和探测输入。查询优化器指派这些角色，使两个输入中较小的那个作为生成输入。
哈希联接用于多种设置匹配操作：内部联接；左外部联接、右外部联接和完全外部联接；左半联接和右半联接；交集；联合和差异。此外，哈希联接的某种变形可以进行重复删除和分组，例如 sum(salary) group by department。这些修改对生成和探测角色只使用一个输入。
以下几节介绍了不同类型的哈希联接：内存中的哈希联接、grace 哈希联接和递归哈希联接。
内存中的哈希联接
哈希联接先扫描或计算整个生成输入，然后在内存中生成哈希表。根据计算得出的哈希键的哈希值，将每行插入哈希存储桶。如果整个生成输入小于可用内存，则可以将所有行都插入哈希表中。生成阶段之后是探测阶段。一次一行地对整个探测输入进行扫描或计算，并为每个探测行计算哈希键的值，扫描相应的哈希存储桶并生成匹配项。
grace 哈希联接
如果生成输入大于内存，哈希联接将分为几步进行。这称为“grace 哈希联接”。每一步都分为生成阶段和探测阶段。首先，消耗整个生成和探测输入并将其分区（使用哈希键上的哈希函数）为多个文件。对哈希键使用哈希函数可以保证任意两个联接记录一定位于相同的文件对中。因此，联接两个大输入的任务简化为相同任务的多个较小的实例。然后将哈希联接应用于每对分区文件。
递归哈希联接
如果生成输入非常大，以至于标准外部合并的输入需要多个合并级别，则需要多个分区步骤和多个分区级别。如果只有某些分区较大，则只需对那些分区使用附加的分区步骤。为了使所有分区步骤尽可能快，将使用大的异步 i/o 操作以便单个线程就能使多个磁盘驱动器繁忙工作。
border: 1pt solid #dedfef; padding: 0cm