数据库查询实现

数据库的三大类操作

• 一次单一元组的一元操作–select, projection
• 整个关系的一元操作–distinct, group by, sort
• 整个关系的二元操作：并，交，差，笛卡尔积，join
  对于一次单一元组的一元操作，有迭代器算法；对于整个关系的一元操作，有一趟扫描算法，二趟扫描算法，多趟扫描算法。扫描多次的主要原因是内存容量不够，这些扫描算法的实现都有基于排序、散列和索引的

1. 一次单一元组的一元操作

查询实现有两种策略，一种是物化计算策略，一种是流水线计算策略。其中物化策略的每一个操作都要扫描一遍数据库，且存储中间结果；流水线策略一组关系操作才扫描一遍数据库，不存储中间结果。流水线策略可用迭代器算法实现

迭代器的构造

表空间扫描法读取关系
假设R是一个类，以下是伪代码

Open(){
	b:=R的第一块
	t:=b的第一个元组
}
GetNext(){
	if(t已超过块b的最后一个元组){
		将b前进到下一块
		if(没有下一块)
			return notFound
		else/*b是一个新块*/
			t:=b的第一个元组;
	}
	oldt:=t;
	将t前进到b的下一个元组;
	return oldt;
}
Close(){
}

实现并操作
假设Union(R,S)是一个类

Open(){
	R.Open();
	CurRel:=R;//当前关系为R
}
GetNext(){
	if(CurRel==R){
		t:=R.GetNext();
		if(t<>notfound)
			return t;//未处理完
		else{//已处理完R
			S.Open();
			CurRel:=S;
		}
	}
	return S.GetNext();
}
Close(){
	R.close();
	S.close();
}

实现selection操作
Selection(R)

Open(){
   R.Open();
}
GetNext(){
   cont://一个条件循环
   	t:=R.GetNext();
   	if(t<>notfound)
   		if(F(t)==True)//条件判断
   			return t;
   		else goto cont;
   	else return notfound;
}
Close(){
   R.Close();
}

在selection操作的基础上做projection操作
Projection(Selection(R))

Open(){
   Selection.Open();
}
GetNext(){
   t:=Selection.GetNext();
   if(t<>notfound){
   	p:=Projection(t,alpha)//alpha为投影内容
   	return p
   }
   else return notfound;
}
Close(){
   Selection.Close();
}

这样就可以自动地从前一个操作的迭代器构造后一个操作的迭代器
迭代器实现Join
Join(R,S)

Open(){
   R.Open();
   S.Open();
   r:=R.GetNext();
}
GetNext(){
   repeat{
   	s:=s.GetNext();
   	if(s==notfound){
   		S.Close();
   		r:=R.GetNext();
   		if(r==notfound)
   			return notfound;
   		else{
   			S.Open();
   			s:=S.GetNext();
   		}
   	}
   }
   until(r与s能够连接)
   return r和s的连接
}
Close(){
   R.Close();
   S.Close();
}

2. 整个关系的一元操作

对于关系R，假设B(R)是R的存储块数目；T(R)是R的元组数目

一趟扫描：

• 对于聚簇关系——关系的元组集中存放（一个块中仅是一个关系中的元组）：
  表空间扫描算法：
  TableScan(R)–扫描结果未排序：B(R)
  SortTableScan(R)–扫描结果排序：3B(R)
  索引扫描算法：
  IndexScan(R)–扫描结果未排序：B(R)
  SortIndexScan(R)–扫描结果排序：B(R) or 3B(R)
• 对于非聚簇关系——关系元组不一定集中存放（一个块中不仅是一个关系中的元组）：
  扫描结果未排序：T(R)
  扫描结果排序：T(R)+2B(R)(可以理解为排序后变为聚簇的)

去重复操作：&(R)

• 需要在内存中保存已处理过的元组
• 当新元组到达时，需与之前处理过的元组进行比较
• 建立不同的内存数据结构（比如散列表，B+树），来保存之前处理过的数据，以便快速处理整个关系上的操作（用于快速定位元组）
  算法复杂度为B(R)
  两趟扫描的去重复操作：复杂度和两趟扫描排序相同，考虑输出是$4B_{problem}$，不考虑输出是$3B_{problem}$

分组聚集${\gamma }_L(R)$，$\gamma$为分组计算符号，L为分组条件

• 需要在内存中保存所有的分组
• 保存每个分组上的聚集信息
• 建立不同的内存数据结构（比如散列表，B+树），来保存之前处理过的数据，以便快速处理整个关系上的操作（用于快速定位元组）
  类似去重复操作，算法复杂度为B(R)
  比如使用散列，则散列函数可以是分组条件的函数；新分组通过散列插入相应的桶（页）中；新元组通过散列找到相应的桶，并判断是否是新分组
  两趟扫描：第一趟分组并子表排序；第二趟，归并阶段，在排序的基础上，将不重复的记录作为新分组输出，将重复的记录进行分组聚集计算。复杂度和两趟扫描排序相同，考虑输出是$4B_{problem}$，不考虑输出是$3B_{problem}$

两趟扫描

假设内存只有8块，如何排序70块的数据集？

问题是在全部数据上的操作是否等价于在子集上的操作的并集？
例如：元组在某一子集上无重复即在全集上无重复。
基于散列的两趟扫描算法可以满足这一条件

• 基于散列的两趟扫描算法
  大数据集上的操作可以被转换为某个子集上的操作：
  第一趟：散列子表。用散列函数$h_p$将原始关系划分成M-1个子表，并存储。
  第二趟：处理每个子表。用另一散列函数$h_r$将子表读入内存并建立内存结构。复杂性与上述两趟扫描的复杂性相同
  对于去重复操作：元组在子表上不重复，则在大关系中亦不重复。$H_p$将可能重复的元组散列到同一子表，$h_r$将可能重复的元组散列到同一内存块中。
  对于分组操作：第一趟散列时应该同一个分组在同一子表中；同样第二趟散列时同一个分组应散列到同一个内存块中。两趟散列都应该针对“分组属性”的值进行计算。但可以形成区别，如$H_p$直接计算分组属性，$h_r$用“分组属性”的二进制位串。复杂性与上述两趟扫描的相同。

对于基于排序的两趟扫描算法可以满足 在多个已按横向处理的子集上，纵向归并结果等同于在全集上的处理结果。

• 两阶段多路归并排序（two-phase, multiway merge-sort, TPMMS）
  • 内排序问题和外排序问题的区别：内排序问题–待排序的数据可一次性地装入内存中，即排序这可以完整地看到和操作所有数据。 外排序问题–所有的数据不能一次性装入内存
  • 基本排序策略。假设所有的数据需要磁盘块$B_{problem}$块，内存有$B_{memory}$块，$B_{problem}$远大于$B_{memory}$。则可把$B_{problem}$块数据划分为N个子集合，使得每个子集合的块数小于内存可用的块数，即$B_{problem}/N<B_{memory}$。每个子集合都可装入内存并采用内排序算法排好并重新写回磁盘，这一过程为第一趟排序，也可以叫横向处理。于是问题转化为：N个已排序子集合的数据怎样利用内存进行总排序，这一步称为第二趟排序，是各子集间的归并排序，每个子集都被读取一部分内容放入内存中
    
    算法的效率：子集合排序阶段读一遍写一遍，代价为$2B_{problem}$,归并阶段读一遍写一遍，代价为$2B_{problem}$，总共为$4B_{problem}$.要求是大数据集块数<$B_{memory}^2$
    更大规模的数据集则考虑一多趟/多阶段排序。假设内存大小$B_{memory}=3$，待排序数据$B_{problem}=30$。
    基本策略:
    1.将30块的数据集划分为10个子集合，每个子集合3块，排序并存储。
    2.将10个已排序的子集合分为5组，每组两个子集合，分别进行二路归并，则可得到5个排好序的集合
    3.5个集合再分成3个组：每个组两个子集合，剩余一个单独一组，分别进行二路归并，可得到3个排好序的集合；再分组再归并得到两个排好序的集合；再分组再归并便可完成最终的排序

3.整个关系的二元操作

一趟扫描

先扫描一个关系，再去扫描另一个关系。在集合上的操作（需要去重复）和在包上的操作（需要记录每个元组出现的次数）有所不同。
算法复杂度：B(R)+B(S)

基于有序索引的连接算法–zig-zag连接算法

两趟扫描

包上的操作都无需两趟，直接合并即可。集合上的操作需要两趟。
基于散列的两趟扫描

• 第一趟：使用相同的散列函数散列两个操作对象，如R和S，形成子表$R_i$和$S_i$
• 第二趟：将$S_i$再整体散列读入到内存中，再依次处理$R_i$的每一块。如判断在$R_i$，$S_i$都出现元组t，则只输出t的一个副本，否则输出$R_i$和$S_i$

连接操作：
基于散列的两趟扫描十分适合连接操作，

• 第一趟：使用相同散列函数（散列的属性为连接属性）散列两个操作对象R和S
• 第二趟：将$S_i$再整体散列读入到内存中，再依次处理$R_i$的每一块。进行连接。（散列到相同位置的$R_i$和$S_i$具有相同的连接属性值）