CN1609855A

CN1609855A - 查询优化系统和方法

Info

Publication number: CN1609855A
Application number: CNA2004100639914A
Authority: CN
Inventors: M·L·布鲁恩答吉; A·E·基姆巴尔
Original assignee: Microsoft Corp
Current assignee: Microsoft Corp
Priority date: 2003-06-23
Filing date: 2004-06-23
Publication date: 2005-04-27
Anticipated expiration: 2024-06-23
Also published as: EP1492034A2; US7146352B2; US20050004892A1; CN100517307C; KR20050000328A; JP2005018767A; EP1492034A3

Abstract

一种优化器/标准化部件，用于产生输入查询，例如XML输入查询的优化的中间语言表示。用于以中间语言的形式优化输入查询的方法包括，接收该输入查询、以左深度第一方式检查该节点以便识别作为优化主题的代码模式和节点类型、标记被识别的节点模式直到输入查询的中间语言表示已经全部被检查过，从中间语言表示的顶部开始搜索被标记的代码模式，以及用改进的代码模式调整被标记的代码模式从而为输入查询形成最佳表示。假设输入给优化器/标准化部件的输入为一个输入查询，该输入查询被变换为包含代码模式和节点的中间语言表示，每个节点具有各自的节点类型。

Description

查询优化系统和方法

发明领域

本发明一般涉及软件查询优化的领域，尤其涉及用于XML语言和查看定义语言的优化。

发明背景

语言的优化是每个程序员的目标。有效代码运行得越快，消耗的计算机资源就越少，也越紧凑。这些特性对于想使其计算机硬件和软件具有更好的性能的代码消费者是很有吸引力的。代码优化的目标是包括查询语言应用的大多数应用，所期望的，在查询语言应用中，代码可被用于查询大的数据库，例如关系数据库。当用于执行查询的系统使用多种语言在多个数据库中进行查询时，这个问题就变得更加尖锐。在这种情况下，通过比未优化的代码更快地并且更始终如一地返回查询结果，有效代码的产生就有利于查询。优化需求的一个例子是在一个系统中的，在该系统中，可以将XML相关语言查询，例如XSLT、XQuery和XPath，或者查看定义语言，输入到用于在SQL数据库上执行查询的系统中。在这种系统中，优化规则是用于改进执行代码效率。

XML查询提出了至少四种达到标准化和优化的壁垒：代码识别、排序、副作用以及结构。在数据库和功能性编程优化中的一般技术是通过执行置换来消除变量。然而，当执行置换甚至一个简单的置换不能很好地完成时，必然更关注这个问题。

一个问题是许多XML查询语言明确地或隐含地依赖于节点的身份。设想，例如，XQuery：

let $a：＝<foo/>

retum$a Is $a

该XQuery构造了一个单一XML元素，并且然后，测试它是否具有与其本身相同的身份。这个查询应当返回真。将它与查询相比，该查询从置换(即用它的值置换$a的每个实例)中得出：

这个查询构造了两个元素，那么，这两个元素互不相同，这样该查询就返回假。随着操作者隐含地根据文档顺序进行分类或者根据身份消除节点，这个问题可能会变得更加明显。

在标准化和优化方面的另一个复杂因素是对XML进行排序。可能希望这种排序应当根据文档实例是稳定的。考虑下面代码移动技术的例子。这个例子包括，当表达式独立于一个循环时，将表达式准入该循环中或者将它们推出循环。

给出查询：

for $i In $e1

where $condition1

return

for $j In $e2

where $condition2

return $k

典型的重写可能导致：

for $j In $e1

for $j In $e2

where $condition1

and $condition2

return $k

该重写的作用是在该结果的顺序和位置方面是相反的。尽管乍一看该重写似乎是正确的，但内部条件可能是指向该重写已经改变了的那个循环内的位置。当不需要保存该位置时，只应当应用会引起具有不同顺序的表示的任何优化。否则，会发生错误的重写。

在编程语言优化方面的一般技术是，当将不再需要临时表达式的结果时，消除临时表达式。然而，甚至临时XML查询语言表达式的消除可不可能完全摆脱副作用。某些表达式可能是用错误，例如XQuery的error()函数，终止消除的。其它表达式可能发送一个消息输出，例如XSLT的<xsl：message/>操作者。只有当查询语言语义允许它时，才能够消除某些临时表达式。作为两个例子，考虑XQuery error()和false()，以及XSLT路径表达式：

document(′malformed.xml′)//foo[false()]

这些语言的精确实现可能要求报告两个误差，即使优化者想要根据总是false()条件消除两个表达式。幸运的是，甚至当它的操作码中的一个可能是错误的时候，XQuery也允许AND操作进行短路。当试图处理这种错误时，XSLT允许document()函数返回空列表。从而，两个表达式都可以在编译时被优化到空列表中。考虑XQuery表达式，例如：

(<x dupe＝″1″dupe＝″2″>can you get here？</x>)//text()

在这个例子中，优化者可能想要消除无效的临时元素并且只返回文本节点。还要注意，如果这些查询没有被优化，则它们将在运行时出错，但是当被优化以后，它们就不会出错。在商业实现中，与其它编程语言的互用性可能是头等重要的。然而，调用另一种编程语言中的函数写可能会产生不可知的影响，包括可能的副作用，这些影响可能是进行优化的壁垒。

另一个复杂因素是XML的不合适的结构可能具有不良的副作用。XML的结构通常包含复制其内容，并且这种对节点身份的变更应当通过重写和执行进行保存。考虑该XQuery：

foo((<x><y/></x>)//y)

这个查询通过将表达式(<x><y/></x>)//y的结果传递给函数foo()来调用foo()，其中该结果仅仅是<y/>元素。优化程序想要消除明显多余的XML结构和操作(navigation)，并且仅传递所选择的<y/>元素。然而，如果foo()试图访问父节点，并且定义函数：

foo($y){$y/..}

并且如果优化程序已经消除<x>，那么该查询会产生错误的结果。将被传递给外部函数的所构造的XML全部保存以避免结构问题看来是合乎需要的。对于名称空间说明，在某个范围内也会发生类似的问题，该范围例如：

(<x：x xmlns：x＝″x″><y/></x>)//y

以及对于可能出现在临时XML表达式中的其它中间数据指令，也会发生。在类似XSLT的语言中，因为该语言不是合成的，结构副作用可能是比较不关心的，但这种结构问题的确极大地影响了类似XQuery之类的语言的优化，或者在所构造的XML视图上执行XML查询时的语言的优化。

因此，它可能对于XML优化器是有利的，从而避免错误的置换，当被优化的XML表达式中顺序很重要时避免了进行重写而改变被重写表达式的顺序，避免来自临时表达式消除和多语言使用的副作用，以及避免结构问题。本发明解决了以上提及的需要，并且采用不同的系统、方法和技术解决了这些需要，这些系统、方法和技术还提供了用于优化查询的其它优点。

发明概述

本发明涉及优化器/标准化部件，以及相关技术，它产生输入查询，例如XML输入查询的被优化的中间语言表示。本发明可以被用作独立的优化器或者较大系统的一部分，该较大系统包括，例如，XML查询运行时间系统。

本发明包括第一示例性方法，用于通过如下步骤为输入查询构造最佳表示：接收该输入查询、以左深度第一方式检查该节点以便识别作为优化主题的代码模式和节点类型、标记被识别的节点模式直到输入查询的中间语言表示已经全部被检查过、从中间语言表示的顶部开始搜索被标记的代码模式、以及用改进的代码模式调整被标记的代码模式从而为输入查询形成最佳表示。假设输入给优化器/标准化部件的输入为一个输入查询，该输入查询被变换为包含代码模式和节点的中间语言表示，每个代码具有各自的节点类型。

用于为输入查询构造最佳表示的第二示例性方法包括，接收输入查询，检查该节点以便检验与各个节点类型相关的代码模式，利用模式匹配算法比较所检验的代码模式以便检测未被优化的代码模式，以及用改进的代码模式调整未被优化的代码模式和被检验的代码模式以便为输入查询形成最佳表示。再重复一次，输入查询是包含节点的中间语言表示，每个节点都具有各自的节点类型。

本发明可以具体化为一个示例性系统，它包括XML中央运行时间查询处理方法。该方法包括，采用多次XML查询，并将它们变换为中间语言表示，执行优化，并且然后将该查询编译恢复成与数据源格式相兼容的形式。

附图的简要说明

当结合附图进行阅读时，更容易理解前述的概要，还有下面优选实施例的详细表示。为了说明本发明，在附图中给出了本发明的示例性结构；然而，本发明并不限于所公开的特定方法和手段。在附图中：

图1是示出在其上可以实现本发明的示例性计算环境的方块图。

图2描述了在其上可以实现本发明的示例性方块图结构。

图3说明描述本发明的优化方法的一个实施例的流程图。

图4说明描述本发明的优化方法的替换实施例的流程图。

图5说明相应于本发明实施例的中间语言优化的例子。

图6说明相应于本发明实施例的中间语言的例子的分段优化。

示意性实施例的详细表示

优化器/标准化部件的概况

通过消除冗余形式并提高查询执行速度，示例性查询优化器/标准化部件改善了查询效率。示例性标准化部件函数消除了冗余排列，并且因此，通过减少后端必须准备进行处理的查询的类型的数量，简化了后端编译器的实现。由此获得了更好的系统性能。该优化器/标准化部件可以被设计用作独立部件或者用作较大系统的一部分。

通过不执行置换或者不顾节点身份的不正确的其它重写，就可避免在优化中错误置换的问题。这是通过利用作为一个输入的查询的面向节点的中间语言表示来实现的。因此，可以将节点特征作为优化处理的一部分进行分析。最好仅当重新排序对中间表示中的任何子表达式都没有影响时，执行一部分的输入查询的中间语言表示的重写。通过使用输入查询的明确的中间语言表示来清楚地识别顺序敏感表达式，表达式的顺序就不会受到影响。总之，通过有关仔细创建的重写规则的优化壁垒、清楚的操作码和仔细的维护的组合，就可以避免优化错误以及相关因素。

可以用计算机系统中的一组硬件元件和软件元件中的一个或多个实现本发明。据此，在下文描述了可以包括本发明的示例性计算机系统。

示例性计算设备

图1和下面的讨论是想要提供简要的一般性表示，其中可以实现本发明的适当的计算环境的。然而，应当理解，手提式、便携式以及其它计算设备和所有种类的计算对象都是与本发明有关的使用。因此，尽管下面描述了通用的计算机，但是这仅仅是一个例子，并且本发明也可以用其它计算设备实现，例如具有网络/总线互用性和交互性的客户机。因此，本发明可以在网络化宿主服务器的环境中得以实现，在该环境中，包括了很少或最少的客户资源，例如网络化环境，其中客户机设备仅仅用作到网络或总线的接口，例如置于一个装置中的对象，或者其它计算设备还有对象。实质上，数据可以被存储在其中的任何地方，或者可以从中检索数据的位置，是所期望的或者恰当的用于根据本发明的操作的环境。

尽管并不需要，但是本发明可以通过操作系统实现，用于设备或对象的服务开发者使用，和/或被包含在根据本发明进行操作的应用软件内。软件可以用通常计算机可执行指令的概念进行描述，例如程序模块，这些程序模块由一个或多个计算机，例如客户机工作站、服务器或其它设备来执行。通常，程序模块包括例程、程序、对象、组件、数据结构以及类似的执行特定任务或者实现特定抽象数据类型的模块。典型地，程序模块的功能可以根据需要在不同的实施例中进行组合或拆分。而且，本领域技术人员将意识到，本发明可以用其它计算机结构进行实施。适于与本发明一起使用的其它公知的计算系统、环境和/或结构包括，但并不限于，个人计算机(PC)、自动化播音机器人、服务器计算机、手提式或膝上型设备、多处理器系统、基于微处理器的系统、可编程消费电子仪器、网络PC、医疗器械(appliance)、灯具、环境控制元件、小型计算机、大型计算机等。本发明还可以在分布式计算环境中实施，在该环境中，由远程处理设备执行任务，该远程处理设备通过通信网络/总线或其它数据传输媒体进行连接。在分布式计算环境中，程序模块可以位于包括存储器存取设备的本地和远程计算机存储媒体中，并且客户端可以依次作为服务端执行。

因此，图1说明在其中可以实现本发明的适当的计算系统环境100的例子，尽管上面已经给出了清楚的表示，但是计算系统环境100仅仅是适当的计算环境的一个例子，而并不意味着是对本发明的使用或功能性范围的任何限定。不应当将计算环境100解释为具有与示例性操作环境100中所表示的任意一个组件或组件的组合有关的任何从属关系或需求关系。

参见图1，用于实现本发明的示例性系统包括采用计算机系统110的形式的通用计算设备。计算机系统110的部件可包括，但并不限于，处理单元120、系统存储器130以及系统总线121，系统总线将不同的系统部件相连，包括系统存储器到处理单元120的连接。系统总线121可以是多种类型的总线结构中的任何类型，该多种类型的总线结构包括存储器总线或存储器控制器、外部总线以及使用若干总线结构中的任意一个的本地总线。以示例的方式而非限定的方式，这种结构包括工业标准结构(ISA)总线、微通道结构(MCA)总线、加强的ISA(EISA)总线、视频电子标准协会(VESA)本地总线以及外部设备互连(PCI)总线(也称作Mezzanine总线)。

计算机系统110通常包括若干计算机可读媒体。计算机可读媒体可以是能够由计算机系统110访问的任何可用的媒体，并且包括易失性和非易失性媒体、可移动和不可移动媒体。以示例的方式而非限定的方式，计算机可读媒体可包括计算机存储媒体和通信媒体。计算机存储媒体包括采用任何方法或技术存储信息的易失性和非易失性、可移动和不可移动媒体，该信息例如计算机可读指令、数据结构、程序模块或其它数据。计算机存储媒体包括，但并不限于，随机存取存储器(RAM)、只读存储器(ROM)、电可擦除可编程只读存储器(EEPROM)、闪存或其它存储器技术、光盘只读存储器(CDROM)、可重写光盘(CDRW)、数字化视频光盘(DVD)或其它光盘存储器、磁带盒、磁盘存储器或其它磁存储设备、或任何能够被用于存储所需信息并且能够被计算机系统110访问的其它介质。通信媒体一般具体表达计算机可读指令、数据结构、程序模块或模块化的数据信号中的其它数据，该模块化的数据信号例如载波或其它传输机制，并且通信媒体包括任何信息传送媒体。术语“模块化数据信号”意思是具有其特征组中的一个或多个或者是以在该信号中对信息进行编码的方式变化的信号。以示例的方式而非限定的方式，通信媒体包括有线媒体，例如有线网络或直接以线连接，以及无线媒体，例如声音、射频(RF)、红外线和其它无线媒体。以上媒体的任何组合也应当被包含在计算机可读媒体的范围内。

系统存储器130包括采用易失性和/或非易失性存储器，例如只读存储器(ROM)131和随机存取存储器(RAM)132的形式的计算机存储媒体。基本输入/输出系统133(BIOS)包含帮助，例如在启动过程中在计算机系统110的元件之间传送信息的基本例程，BIOS 133通常被存储在ROM 131中。RAM 132通常包含数据和/或程序模块，它们可由处理单元120立即访问和/或处理单元120当前正在操作。以示例的方式而非限定的方式，图1表示操作系统134、应用程序135、其它程序模块136以及程序数据137。

计算机系统110还可包括其它可移动/不可移动、易失性/非易失性计算机存储媒体。仅以示例的方式，图1说明：硬盘驱动器141，硬盘驱动器141从不可移动、非易失性磁性媒体上读取或写入该磁性媒体；磁盘驱动器151，从可移动、非易失性磁盘152上读取或写入该磁盘152，以及光盘驱动器155，从可移动、非易失性光盘156上读取或写入该光盘156，光盘156例如CD ROM、CDRW或其它光介质。其它能够用在示例性操作环境中的可移动/不可移动、易失性/非易失性计算机存储媒体包括，但并不限于，磁带盒、闪存卡、数字通用盘、数字录像带、固态RAM、固态ROM等。硬盘驱动器141通常通过不可移动存储器接口，例如接口140与系统总线121连接，而磁盘驱动器151和光盘驱动器155通常通过可移动存储器接口，例如接口156与系统总线121连接。

以上讨论的和图1中表示的这些驱动器及其相关计算机存储媒体提供了计算机可读指令、数据结构、程序模块以及其它用于计算机系统110的数据的存储。例如，在图1中，硬盘驱动器141被表示为存储操作系统144，应用程序145，其它程序模块146以及程序数据147。注意，这些部件与操作系统134，应用程序135，其它程序模块136以及程序数据137可能是相同的也可能是不同的。在此，为操作系统144，应用程序145，其它程序模块146以及程序数据147提供了最低限度地表示它们是不同的复制的不同的数字。用户可以通过输入设备将命令和信息输入到计算机系统110中，该输入设备例如键盘162和指示设备161，通常是指鼠标，跟踪球或触摸板。其它输入设备(未示出)可包括麦克风，操纵杆，游戏板，卫星反射器，扫描仪等。这些和其它输入设备往往通过连接到系统总线121的用户输入接口160与处理单元120相连接，但是也可以通过其它接口和总线结构，例如并行端口、游戏端口或通用串行总线(USB)进行连接。监视器191或其它类型的显示设备也是通过接口，例如视频接口190与系统总线121连接，该视频接口190可以依次与视频存储器(未示出)进行通信。处理监视器191，计算机系统还可包括其它外围输出设备，例如扬声器197和打印机196，它们可以通过输出外围接口195进行连接。

计算机系统110可以在使用与一个或多个远程计算机，例如远程计算机180进行逻辑连接的网络化或分布式环境中进行操作。远程计算机180可以是个人计算机、服务器、路由器、网络PC、端对端设备或其它公共网络节点，并且尽管在图1中只表示存储器存取设备181，但是远程计算机180通常包括以上描述的与计算机系统110有关的多个或所有元件。图1中描述的逻辑连接包括局域网(LAN)171和广域网(WAN)，但也可以包括其它网络/总线。这种网络环境在家里、办公室、企业范围的计算机网络、企业内部网以及互联网中是很普通的。

当用在LAN网络环境中时，计算机系统110通过网络接口或适配器170与LAN 171相连接。当用在WAN网络环境中时，计算机系统110通常包括调制解调器172或其它用于在WAN 173，例如互联网上建立通信的装置。调制解调器172可以是内置的或外置的，它可以通过用户输入接口160或其它适当机制与系统总线121相连接。在网络化环境中，所描述的与计算机系统110有关的程序模块或其部分可以被存储在远程存储器存取设备中。以示例的方式而非限定的方式，图1说明驻留在存储器设备181上的远程应用程序185。将意识到，所示网络连接是示例性的，也可以使用在计算机之间建立链接的其它装置。

不同的分布式计算框架已经根据个人计算和互联网的集中得到了发展，并且还在反展。为个人和类似的商业用户提供用于应用和计算设备的无缝可互用的并且能够使用Web的接口，使得计算行为日益Web浏览器化或面向网络化。

例如，由华盛顿98052 Redmond的微软公司One Microsoft Way开发的MICROSOFT的NET^TM平台包括服务器，用于创建块服务，例如基于Web的数据存储器，以及可下载设备软件。尽管在此已经就驻留在计算设备上的软件描述了示例性实施例，但是本发明的一个或多个部分也可以通过操作系统、在任何协处理器之间的应用程序接口(API)或“经纪人(middle man)”对象、显示设备以及请求对象来实现，以便根据本发明的操作可以由在所有NET^TM的语言和服务中支持的或者通过所有NET^TM的语言和服务访问的操作来实现，并且在其它分布式计算框架中也是如此。

优化讨论和发明的示例性实施例

在XML查询中效率低的两个主要的来源是缓冲和类型转换。当操作码不能流入(stream)并且代替的某些数据必须被缓存在存储器中，然后经过一次或多次以便求操作码的值时，进行缓冲。当发生缓冲时，流水线处理可以中断，并且进行多路传递。因此，在数据上进行两次操作的查询转到在其上只进行一次操作的查询就是所期望的优化。

通常，缓冲是与如何实现查询紧密联系的物理查询设计的一个方面。然而，在逻辑查询设计中已有能够被检测和重写的模式。例如，查询和($x)除以计数($x)可以等于平均值($x)。以前的表达式要求计算两次$x的值，而后者在一个传递中就能够执行其计算。

在XML中，类型转换通常包括从串表示变为机器类型(象整数)，或反过来的变换。传统上，相关数据库不能对这种查询进行很好的优化，因为它们在已经将数据作为机器类型存储的相关领域中是相对难做到的。在XML查询的实现中，可以认为希望移除尽可能多的类型的转换和测试，尤其是在相关数据上，但甚至对于原始XML数据也希望进行该移除。

例如，暗中查询消费者[@CustomerID＝’ALFKI’]可以要求将CustomerID节点转换到串。如果这个节点已经被输入为xs：string，那么尽管该节点的串值还可重现，但也不要求转换。如果该节点被映射到具有SQL类型例如nvarchar的列，那么也不需要从相关数据转换到XML数据。假设对CustomerID进行索引，消除这两种转换使得SQL查询设计从索引扫描变到索引搜索。这个设计可以达到10倍的性能改进。

这些优化通常本质上是物理的。尽管可以消除不需要的SQL/XML转换，但是也存在一些在逻辑查询设计中已经可行的优化。一种方法可以是，通过在优化过程中改善类型消除类型转换和类型测试。越精确地知道和了解关于查询的静态类型信息，就可以准确地消除更多的操作码。

本发明的实施例使用中间语言表示，该中间语言表示具有由识别查询中的功能操作的图形结构。由此，它表示查询的语义。该中间语言一种查询中间语言，并且被称作QIL。在一起提交的由WA，Redmond的微软公司转让的名称为QUERY INTERMEDIATE LANGUAGE METHOD AND SYSTEM(查询中间语言方法和系统)的专利申请(序列号No.XX/XXX，XXX，与本申请同一申请日提交的)中提供了示例性查询中间语言的定义。该一起提交的申请的内容全部作为参考结合到本申请中。

模式检测是用于识别候选者以便标准化和最优化。由这种中间语言产生的模式不具有任意的复杂性。通常，该模式大多是肤浅的模式，并且以特定的节点类型开始(root)，所有的后沿都被受到约束以便在已知的位置中进行触发。从而，模式匹配算法能够很容易地适应这种表示。

称为QIL的XML中间语言是XML查询或查看的一种表示。该查询中间语言是表示XML查询成分的清楚的表示。查询中间语言可以被看作经过所有XML查询和查看语言编译器的公共的语义表示。QIL与原始的抽象语法树(AST)相似，但是在QIL捕获的不是语言的语法而是查询的语义或意思的情况下是不同的。另一个不同点是，QIL是图形结构而非象AST一样的树结构。

QIL使得多种不同的XML查询语言和查看定义语言(例如XPath、XSLT和XQuery)在不同的目标数据源(例如相关和不相关的数据)上进行抽象。由此，QIL使得公共的结构支持所有相兼容的XML语言。每个操作都是清楚而明确的。

由QIL产生的并由优化器检测的模式根据根节点的类型进行分组，然后用于为模式识别和优化实现产生子类。该子类遍历QIL图形执行左深度优先(即，自下而上)传递，试图依次为所给节点类型匹配各个模式。如果没有模式相匹配，它就复制该节点(及其已经访问过的全部子图)；否则，执行所指示的优化置换。

该方法具有最坏情况下的复杂度O(gn²)，该复杂度是在该语法中的模式的数量，并且n是该图形中的节点数。优化器查看每个节点和所有的子节点以便使各模式相匹配。尽管在实践中，模式倾向于只有一级深度，所以其平均时间被更准确地近似为O(gn)。

图2描述了体现本发明的方面的示例性系统结构的方块图。示出了查询运行时间结构200，它包括中间语言编译器和目标执行引擎。该结构描述了用于在多个数据源上进行XML查询的实现接收、编译、中断和访问数据的示例性基本块。可以实现多个前端语言编译器210，它与XML或XML的有关标准相一致。可以接收原始的或所输入的查询，或者从如图1中所示的多个输入设备中的任意一个中输入该查询。

返回到图2，前端编译器210可以通过输入设备(在图2中未示出)接收XML查询，XML查看或者其它有关XML语言的查询，并且生成表示输入查询的组成成分的已编译的XML中间语言表示215。用于前端编译器210的典型的语言类型包括万维网协会(W3C)出版的XPath、XML样式表语言(XSL)、XSLT以及XML查询语言(XQuery)的标准。还可表示XML查看编译器，它包括在其它标准中的XQuery的W3CXML标准查看。在查询和查看语言以及多个目标模块之间的中间语言抽象允许真实的XML数据，例如来自Microsoft.NET^TM的，以及虚拟的XML数据被用作数据源。

XML中间语言表示215被输入到查询优化器/标准化部件220。优化器的功能是改善查询的性能，并消除所输入的中间语言表示内的冗余形式。该优化器用于通过执行许多算法提高系统性能，其中，在将已优化的XML查询表示传送给后端目标产生器230之前，这些算法减少了尺寸，降低了XML中间语言表示的复杂性。

可以有多个后端目标产生器230来支持多样性的相关目标查询语言执行引擎240。可以构造各个后端目标产生器230，以便它们对与各个所支持的数据源的模型相一致的数据源进行操作。例如，用于SQL数据库源的目标查询语言产生器可以根据在与SQL数据库管理系统的相关数据库上在查询过程中针对效率进行优化。因此，例如，目标查询语言产生器230a还可以与执行引擎240a相配对，以用于将中间语言表示215变换为与特定的数据源250相兼容的目标机器语言。可选地，目标产生器还可以将XML中间语言表示215变换为另一种中间语言，例如Microsoft中间语言(MSIL)，以便执行引擎可以直接查询一个或多个数据源250。

在被编译查询的执行基础上，执行引擎通常生成可用于，例如，进一步处理、存储、显示给用户或供应给后来的软件应用的查询结果260。目标编译器230以及相应的执行引擎240可包括这种查询语言来作为XML和SQL，以命名一些语言。

该结构的另一方面是数据有效性的模块性(模块化)。例如，在产生被优化的XML查询表示(例如输入给目标产生器230)的情况下，可以产生一个输出，以便被优化的XML查询中间语言表示本身可以用在另一个系统中或者用于被延迟的目标编译。还有，在实际上并没有先转换成特定的非XML指令查询的情况下，可以直接执行被优化的XML查询表示本身。因此，在不需要编译器使用尤其适于执行被优化的XML查询中间语言表示的执行引擎的情况下，XML中间语言可以被用于在一个或多个数据源上进行查询。作为在系统输出中的另一可选项，目标编译器的输出(多个)可以被用作一个输出，以用于在一个单独的系统中执行或者由另一个非系统应用程序执行。

应当注意，图2的示例性结构总是(Inherently)允许在结构查询方面具有很大的灵活性。该查询结构允许将要被输入的多次查询，以便可以产生多次查询的被优化的XML中间语言的组成成分。此外，可以适当地使用多个后端目标编译器和执行引擎，以便在不同数据模型的数据源上进行查询。结构200还允许减少前端和后端的置换次数。图2描述了M个前端编译器和N个后端编译器，其中M和N都是整数。通常，这种组成会产生总数为M×N(M倍N)的可能的系统路径。然而，由于利用公共的中间语言，所以置换次数被有利地减少到了M+N(M加N)。

图3表示根据本发明的优化的示例性流程的流程图300。最初，在310接收查询的中间语言表示。该中间语言表示可以是如上所讨论的查询中间语言，或者它可以是某些其它中间语言，例如MSIL。假设中间语言具有图形或节点结构。然后，在320，处理300检查中间语言内的节点，以便确定节点类型和节点模式。在330，在识别节点类型和节点模式的基础上，根据能够被优化的模式的识别，分析该模式。通过比较预存储的一组节点类型和/或节点模式，可以执行该比较，其中该节点类型和/或节点模式可以识别为进行优化的侯选项。可替换地，可以结合节点类型识别使用一种算法来识别用于优化的节点模式。

如果节点类型的被检测的模式可以被优化，则在340通过置换优化该节点模式。可替换地，如果不需要的重复(repetition)被检测，则在340可能发生标准化，这可能会导致该重复的消除。作为标准化或优化的结果，在360收集已改变的和未改变的节点的部分，并且进行合计。

如果因为它与节点类型或节点模式不匹配，在330没有优化该节点类型的被检测模式，那么被检查的节点就可以被传递，以便在360该节点能够被收集。

一旦在360收集了该节点，处理300就确定中间语言表示是否已经为了标准化/优化目的而全部被检查了。如果该节点还没有被全部检查，则在320检查下一个节点，并且重复检查和优化的过程。如果处理300已经完成对中间语言表示节点的检查，那么就传递所合计的节点，并且在380得到被优化的查询。

图4是可以被用作图3的用于优化和标准化的处理的替换处理的示例性处理400的流程图。开始，在405用于优化的被预编译的模式可以被存储在可访问存储器中。然后，处理400可以接收中间语言表示410。如前所述，中间语言表示可以是QIL、MSIL或表示的其它某种图形或节点类型。此处，在420按照向上的方式从该图形的底部开始检查中间语言表示。由于每个节点都被处理400访问，所以在430根据属性显示潜在的标准化和优化。该属性用于识别哪种标准化或优化是所期望的。

然后在440，处理400检验以清楚整个图形是否已经被检查。如果该处理还没有完成，那么在445，处理400在该图形中向上移动，以便测试下一个节点，并且在430识别潜在的优化。

如果在440已经完成检验中间表示的整个图形的处理，那么处理400就移动到该图形的顶部，并且在450搜索标记该节点的属性。某些被标记的属性可以是标准化的那些节点，例如重复节点，或者是优化的那些节点，例如置换节点。该属性可以表示所需动作(即，冗余检测、优化置换等)的种类。处理400在被标记的节点460上从顶部开始往被标记节点的位置的下面进行优化/标准化。在该优化完成执行的最后，整个查询都可以根据节点类型表达式和被优化查询470的结果进行重构。

这就有利于创建一个符号来描述根据基本的(underlying)的中间语言表示所进行的查询重写。重写可以是根据所包含的节点类型，并且，可能希望满足临时的附加条件，例如有关类型或值的条件以便用于要出现的重写。语法是以节点为中心的，但是允许指定附加条件，在本发明的实施例中最好使用该语法。

正如本领域技术人员会意识到的，节点名称可以用圆括号括住，如LISP语言中的节点。节点的孩子，如果有的话，可以沿用其名称。因此，(X)描述一个单独的节点X，而(XYZ)描述具有两个子节点Y和Z的节点X。孩子的顺序是很重要的。树表达式的一个例子1+1＝2可以被写为：

(相等(加(整数1)(整数1)))(整数2)

在重写中，可以在匹配模式之后使用标记＝>将它们分开来重写该置换结构。整个规则还可以被放在前面，用方括号括起来的名称表示；这个名称可以是说明性的。在一个实施例中，这种规则可以根据在代码优化中的灵活性来有选择地使能或禁止。一个示例性重写规则是：

[EliminateOr]

(Or(True)(False))＝＞(True)

代码模式还可以允许模式与任何节点类型相匹配。这是用通配符匹配(*)来表示的。通常，任何模式都可以在它前面用可变的($variableName)和冒号(：)进行标记。然后，可变名称可以代替节点在匹配模式中或在置换中的其它地方使用。标记通常只提供一种方式来表示反向参照(后部标记)。具有反向参照和通配符的图形的例子可以是：

(Sort $i(For(List))(Desc(Negate $x：*)))＝＞(Sort $i(Asc $x))

可以用特定的符号表示附加条件。节点模式可以跟在用花括号括起来的节点后面。该节点可以指属于范围内的任何变量。具有节点条件的一个示例性图形可以是：

(IsEmpty $x：*{$x.IsEmpty})＝＞(True)

下面给出该模式语法的一种扩展的巴克斯-诺尔形式(EBNF)表述，并且表示一种模式语法。

P：＝Pattern*

Pattern：＝Descr Match’＝＞’Action

Descr：＝’[’Ident’]’

Action：＝Replace|Code

Code：＝’{’(Code|[^{}])*’}’

Match：＝(Label’：’)？(Node|Wildcard|string|Number)Code？

Label：＝’$’Ident

Node：＝’(’Ident Match’)’

Replace：＝’(’Ident Action*’)’

PatNode：＝Label|PatNode

Wildcard：＝’*’

Ident：＝[_A-Za-z][_A-Za-z0-9\-]*

String：＝’″’[^″]*’＂’

Number：＝[0-9]+

图5说明优化的一个例子，其中，表达式的重写允许对中间语言代码进行优化。原始代码510是XML查询的查询中间语言表示的一个实施例。所得到的优化520与被重写的特定部分的代码相同。例如，中间语言表示510的虚线部分515可以被转化为优化形式520。所述优化可以看作是在重写520中的虚线插入内容525。

通常，并不立即执行所有的重写，例如图5中的重写，但是替换的，会将该重写划分为较小的重写，其中每一个较小的重写都操作该图形的某个部分。如图6中所描述的，这些较小的重写最好进行级联，以便生成所期望的整体效果。

图6是一串示例性级联重写的表达式。可以通过由下面的规则所描述的父亲的消除利用变换612将原始文本的第一部分610重写为一个优化615，该规则为：

[EliminateParent]

(Parent(For(Content $x：*)))＝＞$x

通过由下面的规则所描述的元组(tuple)的消除使用转换622，中间代码表示620的下一部分可以被重写为一个优化625，该规则为：

[EliminateTuple]

(Tuple $i：(For $x：*)(True)$j：*){$i＝＝$j}＝＞$x

通过由下面的规则所描述的循环重复代码动作利用变换632，对被重写代码630的进一步的处理将得到一个重写635，该规则为：

[IntroduceNTimes]

(Tuple $i：*$w：*$r：*){！DependsOn($r，$i)}

＝＞(Ntimes $r(Length(Tuple $i $w $i)))

最后得到的重写可以被插入查询代码640中，并且通过由下面的规则所描述的元组重写利用变换642，可以是进一步的重写645，该规则为：

[EliminateNTimes]

(DocOderDistinct $t(Tuple***))

＝＞{

QilTuple last＝$t.LastTuple；

If(last.Return.Type＝＝QilNodeType.NTimes){

QilBinary ntimes＝(QilBinary)last.Return；

QilLast list＝f.List()；

list.Type＝f.TypeFactory.Sequence(QilCardinality.Zero，ntimes.Type)；

last.Return＝Replace($0.EliminateNTimes，ntimes，

f.Conditional(f.Gt(ntimes.Right，f.Int32(0))，ntimes.Left，list))；

}

当所得到的代码的结构被插入到原始中间表示650中时，通过由下面的规则所描述的逻辑重写通过变换652，该代码的结构可以被进一步优化655，该规则为：

[IntroduceExists]

(Gt(Length $x：*)(LiteralInt32 0))＝＞(Not(IsEmpty$x))

通过由下面的规则所描述的元组重写使用变换662，可以对总的得到的代码660的进一步的重写进行优化655，该规则为：

[FoldTupleConditional]

(Tuple $i：*$w：*(Conditional $cond：*$return：*$list(List)

{$list.QilType.IsEmpty}))

＝＞(Tuple $i(And $w $cond)$return)

当结果665被插入图5的原始中间语言查询510中时，该结果就是如图5的被优化的中间代码520中所示的优化。因此，本发明的优化过程可以使用多次重写。

优化和标准化的说明

优化通常是作为局部优化或者全局进行分类的。通过查找该图形的小的连接区域，执行局部优化，例如常量合并(folding)。通过查找整个图形，执行全局优化，例如失效代码消除。根据本发明的各方面执行的示例性优化作如下概括：

常量合并

逻辑重写

基本路径重写(孩子，属性)

其它路径重写(根，父亲，自身，子孙等)

循环重复代码动作

元组重写

位置重写

预测重写

元组和列表交换

基准(XSLT，XMark等)

横跨函数边界的组成成分

类型合并

函数内嵌

公共子表达式消除

失效函数消除

类别消除/分组

所执行的局部标准化可被分组为多种不同的种类：常量合并，交换，路径重写，公共子表达式消除，函数内嵌以及杂项标准化。对此所附的附件I中提供了优化规则和技术的示例性的例子。

常量合并优化

常量合并包括消除某些编译时间常量。这些优化减少了查询的大小，减少了将产生的代码的大小，并且可以有效地影响在循环情况下的性能。常量合并模式构成了由优化器执行的模式的大部分。

逻辑重写优化

一些重写并不是真正地进行常量合并，但减少了表达式的逻辑复杂性。其它重写是将不规则的形式，例如比较两个不能被直译为SQL的Boolean表达式变为规则形式。该规则形式实现了在Boolean表达式上的逻辑操作，其中该Boolean表达式能被直译为SQL。

基本路径重写(孩子，属性)优化

操作优化可以在查询执行上起一定的作用，因为XQuery是合成的(即，支持到其它XQuery表达式的操作)。在中间语言例如SQL中的路径通常不用单独的操作码表示。因而，路径重写可以包括许多较小的重写，例如常量合并模式，例如EliminateNameOf。此外，一些路径重写包括将象常量和属性这样的操作操作码与象ElementCtor和AttributeCtor这样的结构操作码进行合并。

循环重复代码动作优化

循环重复代码动作是一种普通的优化技术，在该技术中，在一个循环中，在该循环(即循环重复)过程中不改变的计算能够被提出公因子(即编码动作)。以这种方式，该计算只被执行一次而不是该循环的重复次数。

交换优化

交换是一类重写，它包含解除在收集上的重复或者在重复上的重复。这种重写通常是形式的变换AB＝＞f(B)g(A)；也就是，将A提供给B被重写为将B提供给A或者将B提供给A的某个函数，或者将A的一个列表依次提供给B的每个成员。一些交换模式可能太复杂以致不能全部使用模式语言来表示。因此，这些模式通常可能具有遵循由执行置换的代码动作的匹配模式。

元组重写

在QIL中，元组和筛选程序(filter)节点类型(以及遗传legacy元组节点类型)从事特定的任务(role)，因此具有，并没有将它们分在任何其它种类当中的与它们相关的特定重写。

位置重写

如以上所提及的，保存位置可能出现优化壁垒。因此，消除该位置操作码是非常值得进行的优化。此外，位置操作码满足某些条件。例如，它总是至少为1，并且几乎是该组的长度。此外，使用位置的某些复杂模式还可以一直以保存它的方式进行重写。

基准

众所周知，基准并不表示现实的条件，尽管对于优化器而言，这并不是非常关键的；它们仍表示优化的机会。

类别消除/分组

类别模式具有两种主要种类。一种类型的类别模式消除了不需要的分类，例如将文档顺序提供给已经是按照文档顺序排序的表达式。另一种类别模式可以认为是一种分组模式，它可以由后端编译器利用多路传递来实现。

如上所提及的，尽管本发明的示例性实施例已经结合不同的计算设备和软件结构进行了描述，但是基本原理可以被应用到希望实现代码优化的任何计算设备或系统。因此，本发明所述方法和系统可以应用到各种各样的应用和设备中。尽管在此示例性编程语言、名称和例子选择的都是不同选择的代表性的编程语言、名称和例子，但是这些语言、名称和例子并不意味着就是限定性的。一个本领域普通技术人员将理解，存在许多种方式都可提供目标代码来实现由本发明实现的相同、相似或等效的系统和方法。

可以结合硬件或软件或，在适当情况下，两者的结合实现此处描述的不同技术。因此，本发明的方法和装置，或者其某些方面或部分，可以采取体现在有形媒体中的程序代码(即指令)的方式，该有形媒体例如软盘、CD-ROM、硬盘驱动器或任何其它机器可读存储介质，其中，当程序代码被载入一个机器，例如计算机中，并由该机器执行时，该机器就变成用于实施本发明的装置。在程序代码在可编程计算机上执行的情况下，该计算设备通常包括处理器、由处理器可读的存取介质(包括易失性和非易失性存储器和/或存取元件)、至少一个输入设备以及至少一个输出设备。可以通过利用，例如数据处理API或类似设备使用本发明的信号处理服务的一个或多个程序最好用高级的面向程序或面向对象的编程语言来实现，以便与计算机进行通信。然而，如果需要的话，该程序(多个)能够用汇编或机器语言来实现。在任何情况下，该语言都可以是被编译或被解释的语言，并且是与硬件实现相结合的。

本发明的方法和装置还可以通过以程序代码的形式体现的通信来实现，该程序代码是在某些传输介质，例如电线或电缆上通过光纤进行传输，或者通过任何其它形式进行传输，其中，当程序代码被接收并且被载入一个机器中并且由该机器执行时，例如EPROM、门阵列、可编程逻辑设备(PLD)、客户端计算机、录像机等，或者具有如在以上示例性实施例中所述的信号处理能力的接收机器就变成用于实施本发明的装置。当在通用处理器上实现时，程序代码与处理器相结合，以便提供唯一的装置用于进行操作，从而调用本发明的函数。此外，结合本发明使用的任何存储技术总是可以是硬件和软件的组合。

尽管已经结合不同附图的优选实施例描述了本发明，但是将理解，也可以使用其它类似实施例，或者可以对所描述的实施例作出修改和添加，以在不背离本发明的情况下执行本发明的相同的功能。而且，应当强调，尤其因为无线网络化设备的数量日益激增，所以各种各样的计算机平台，包括手提式设备操作系统以及其它应用专用操作系统都是可预期的。因此，本发明不应当被限定为任何单一的实施例，而应当按照所附权利要求在广度和范围上进行解释。

附件I

下面所附的材料包括优化的例子，它可以是根据本发明的示例性实施例的一部分。该列表仅仅是示例性的，因为更多的实施例可能都是在本发明的范围和精神内的。

示例性常量合并类型优化

用于Boolean操作码的常量合并模式：

1.[EliminateAnd]

(And(True)$x：*)＝＞$x

2.[EliminateAnd]

(And(False)*)＝＞(False)

3.[EliminateAnd]

(And $x：*(True))＝＞$x

4.[EliminateAnd]

(And*(False))＝＞(False)

5.[EliminateOr]

(Or(True)*)＝＞(True)

6.[EliminateOr]

(Or(False)$x：*)＝＞$x

7.[EliminateOr]

(Or*(True))＝＞(True)

8.[EliminateOr]

(Or $x：*(False))＝＞$x

9.[EliminateNot]

(Not(True))＝＞(False)

10.[EliminateNot]

(Not(False))＝＞(True)

11.[EliminateConditional]

(Conditional(True)$x：**)＝＞$x

12.[EliminateConditional]

(Conditional(False)*$x：*)＝＞$x

13.[EliminateConditionaI]/(Conditional $x：*(True)(False))＝＞$x

14.[EliminateConditionaI]

(Conditional $x：*(False)(True))＝＞(Not $x)

15.[EliminateConditionaI]

(Conditional*$x：(True)(True))＝＞$x

16.[EliminateConditionaI]

(Conditional*$x：(False)(False))＝＞$x

用于收集操作码的常量合并模式：

1.[FoldLengthUst]

(Length $x：*){$x.IsEmpty}＝＞(Literallnt32 0)

2.[FoldLengthList]

(Length $x：*){$x.IsSingleton}＝＞(Uterannt32 1)

3.[FoldLengthUst]

(Length $x：(List)){IsConstant($x)}＝＞(Literallnt32{$x.Length})

4.[FoldLengthRange]

(Length(Range $min：*$max：*))＝＞(Convert(Add(Literallnt64 1)(Abs(Subtract $max

$min)))Int32)

5.[FoldLengthNTimes]

(Length(NTimes $x：*$n：*))＝＞(Multiply(Length $x)$n)

6.[EliminateList]

(List $x：*){$x.Count＝1}＝＞{$x(0]}

7.[EliminateRange]

(Range(Literallnt64 $x：*)(Literallnt64 $y：*)){$x＝$y}＝＞$x

8.[EliminateNTimes]

(NTimes*(Literallnt32 0))＝＞(List)

9.[EliminateNTimes]

(NTimes $x：*(Literallnt32 1))＝＞$x

10.[EliminateDistinct]

(Distinct $x：(List))＝＞$x

11.[EliminateDistinctByValue]

(DistinctByValue(For $x：(List){$x.QilType.IsEmpty})*)＝＞$x

12.[Eliminatelntersection]

(Intersection $x：(List){$x.QilType.IsEmpty}*)＝＞$x

13.[Eliminatelntersection]

(Intersection*$x：(List){$x.QilType.IsEmpty})＝＞$x

14.[EliminateDifference]

(Difference $x：(List){$x.QilType.IsEmpty}*)＝＞$x

15.[EliminateDifference]

(Difference $x：*$y：(List){$y.QilType.IsEmpty})＝＞$x

16.[EliminateAverage]

(Average $x：(Ust){$x.QilType.IsEmpty})＝＞{f.Double(Double.NaN)}

17.[EliminateAverage]

(Sum $x：(List){$x.QilType.IsEmpty})＝＞(LiteralDouble 0)

18.[EliminateMinimum]

(Minimum $x：(Ust){$x.QilType.IsEmpty})＝＞$x

19.[EliminateMaximum]

(Maximum $x：(List){$x.QilType.IsEmpty})＝＞$x

用于属性操作码的常量合并模式：

1.[EliminateNegate]

(Negate(LiteralDecimal $x：*))＝＞(LiteralDecimal{-$x})

2.[EliminateNegate]

(Negate(LiteralDouble $x：*))＝＞(LiteralDouble{-$x})

3.[EliminateNegate]

(Negate(UteralFloat $x：*))＝＞(LiteralFloat{-$x})

4.[EliminateNegate]

(Negate(Literallnt32 $x：*))＝＞(Literallnt32{-$x})

5.[EliminateNegate]

(Negate(Literallnt64 $x：*))＝＞(Literallnt64{-$x})

6.[EliminateAdd]

(Add(LiteralDecimal $x：*)(LiteralDecimal $y：*))＝＞(LiteralDecimal{$x+$y})

7.[EliminateAdd]

(Add(LiteralDouble $x：*)(LiteralDouble $y：*))＝＞(LiteralDouble{$x+$y})

8.[EliminateAdd]

(Add(LiteralFloat $x：*)(LiteralFloat $y：*))＝＞(LiteralFloat{$x+$y})

9.[EliminateAdd]

(Add(Literallnt32 $x：*)(LiteraIInt32 $y：*))＝＞(Literallnt32{$x+$y})

10.[EliminateAdd]

(Add(Literallnt64 $x：*)(Literallnt64 $y：*))＝＞(Uterallnt64{$x+$y})

11.[EliminateSubtract]

(Subtract(LiteralDecimal $x：*)(LiteralDecimal $y：*))＝＞(LiteralDecimal{$x-$y})

12.[EliminateSubtract]

(Subtract(LiteralDouble $x：*)(LiteralDouble $y：*))＝＞(LiteralDouble{$x-$y})

13.[EliminateSubtract]

(Subtract(LiteralFloat $x：*)(LiteralFloat $y：*))＝＞(LiteralFloat{$x-$y})

14.[EliminateSubtract]

(Subtract(Literallnt32 $x：*)(Literallnt32 $y：*))＝＞(Literallnt32{$x-$y})

15.[EliminateSubtract]

(Subtract(Literallnt64 $x：*)(Literallnt64 Sy：*))＝＞(Literallnt64{$x-$y})

16.[EliminateMultiply]

(Multiply(LiteralDecimal $x：*)(LiteralDecimal $y：*))＝＞(LiteralDecimal{$x*$y})

17.[EliminateMultiply]

(Multiply(LiteralDouble $x：*)(LiteralDouble $y：*))＝＞(LiteralDouble{$x$y})

18.[EliminateMultiply]

(Multiply(LiteralFloat $x：*)(LiteralFloat $y：*))＝＞(LiteralFloat{$x*$y})

19.[EliminateMultiply]

(Multiply(Literallnt32 $x：)(Literallnt32 $y：*))＝＞(Literallnt32{$x*$y})

20.[EliminateMultiply]

(Multiply(Literallnt64 $x：*)(Literallnt64 $y：*))＝＞(Literallnt64{$x*$y})

21.[EliminateDivide]

(Divide(LiteralDecimal $x：*)(LiteralDecimal $y：*))＝＞{Divide($x，$y)}

22.[EliminateDivide]

(Divide(LiteralDouble $x：*)(LiteralDouble $y：*))＝＞{Divide($x，$y)}

23.[EliminateDivide]

(Divide(LiteralFloat $x：*)(LiteralFloat $y：*))＝＞{Divide($x，$y)}

24.[EliminateDivide]

(Divide(Literallnt32 $x：*)(Literallnt32 $y：*))＝＞{Divide($x，$y)}

25.[EliminateDivide]

(Divide(Literallnt64 $x：*)(Literallnt64 $y：*))＝＞{Divide($x，$y)}

26.[EliminateModulo]

(Modulo(LiteralDecimal $x：*)(LiteralDecimal $y：*))＝＞{Modulo($x，$y)}

27.[EliminateModulo]

(Modulo(UteralDouble $x：*)(LiteralDouble $y：*))＝＞{Modulo($x，$y)}

28.[EliminateModulo]

(Modulo(UteralFloat $x：*)(UteralFloat $y：*))＝＞{Modulo($x.$y)}

29.[EliminateModulo]

(Modulo(Literallnt32 $x：*)(Uterallnt32 $y：*))＝＞{Modulo($x，$y)}

30.[EliminateModulo]

(Modulo(Literallnt64 $x：*)(Literallnt64 $y：*))＝＞{Modulo($x，$y)}

31.[EliminateIntegerDivide]

(IntegerDivide(Literallnt32 $x：*)(Literallnt32 $y：*))＝＞{IntegerDivide($x，$y)}

32.[EliminateIntegerDivide]

(IntegerDivide(Literallnt64 $x：*)(Literallnt64 $y：*)>＝＞{IntegerDivide($x，$y)}

用于串操作码的常量合并模式：

1.[EliminateStrLength]

(StrLength(LiteralString $x：*))＝＞(Literallnt32{$x.Length})

2.[EliminateStrConcat]

$x：(StrConcat*$z：*)

{$z.Count＝1

&&$x.Delimiter.Type＝QilNodeType.LiteraIString

&&((QilLiteral)$x.Delimiter).ReadStringValueO.Length＝0

&&((QilNode)$z[0]).QilType.IsSingleton}＝＞{(QilNode)$z[0]}

用于值比较操作码的常量合并模式：

1.[EliminateEq]

(Eq$x：(LiteralQName***)$y：(LiteralQName***))＝＞(Boolean{$x.Equals($y)})

2.[EliminateEq]

(Eq $x：(LiteralString*)$y：(LiteralString*))＝＞(Boolean{$x.Equals($y)}}

3.[EliminateEq]

(Eq(LiteralDecimal $x：*)(UteralDecimal $y：*))＝＞(Boolean{$x＝$y})

4.[EliminateEq]

(Eq(LiteralDouble $x：*)(UteraIDouble $y：*))＝＞(Boolean{$x＝$y})

5.(EliminateEq]

(Eq(LiteralFloat $x：*)(LiteralFloat $y：*))＝＞(Boolean{$x＝$y})

6.[EliminateEq]

(Eq(Literallnt64 $x：*)(Literallnt64 $y：*))＝＞(Boolean{$x＝$y})

7.[EliminateEq]

(Eq(Literallnt32 $x：*)(Literallnt32 $y：*))＝＞(Boolean{$x＝$y})

8.[EliminateNe]

(Ne $x：(LiteralQName***)$y：(LiteralQName***))＝＞(Boolean{！$x.Equals($y)})

9.(EliminateNe]

(Ne $x：(LiteralString*)$y：(LiteralString*))＝＞(Boolean{！$x.Equals($y)}}

10.[EliminateNe]

(Ne(UteralDecimal $x：*)(LiteralDecimal $y：*))＝＞(Boolean{$x！＝$y})

11.[EliminateNe]

(Ne(UteralDouble $x：*)(UteralDouble $y：*))＝＞(Boolean{$x！＝$y})

12.[EliminateNe]

(Ne(UteralFloat $x：*)(LiteralFloat $y：*))＝＞(Boolean{$x！＝$y})

13.[EliminateNe]

(Ne(Uterallnt64 $x：*)(Literallnt64 $y：*))＝＞(Boolean{$x！＝$y})

14.[EliminateNe]

(Ne(Literallnt32 $x：*)(Literallnt32 $y：*))＝＞(Boolean{$x！＝$y})

15.[EliminateGt]

(Gt(LiteralDecimal $x：*)(LiteralDecimal $y：*))＝＞(Boolean{$x＞$y})

16.[EliminateGt]

(Gt(UteralDouble $x：*)(LiteralDouble $y：*))＝＞(Boolean{$x＞$y})

17.[EliminateGt]

(Gt(UteralFloat $x：*)(UteralFloat $y：*))＝＞(Boolean{$x＞$y})

18.[EliminateGt]

(Gt(Uterallnt64 $x：*)(Literallnt64 $y：*))＝＞(Boolean{$x＞$y})

19.[EliminateGt] ″

(Gt(Uterallnt32 $x：*)(Literallnt32 $y：*))＝＞(Boolean{$x＞$y})

20.[EliminateGe]

(Ge(LiteralDecimal $x：*)(LiteralDecimal $y：··′))＝＞(Boolean{$x＞＝$y})

21.[EliminateGe]

(Ge(UteralDouble $x：*)(UteralDouble $y：*))＝＞(Boolean{$x＞＝$y})

22.[EliminateGe]

(Ge(UteralPloat $x：*)(UteralFloat $y：*))＝＞(Boolean{$x＞＝$y})

23.[EliminateGe]

(Ge(Uterallnt64 $x：*)(Literallnt64 $y：*))＝＞(Boolean{$x＞＝$y})

24.[EliminateGe]

(Ge(Literallnt32 $x：*)(Literallnt32 $y：*))＝＞(Boolean{$x＞＝$y})

25.[EliminateLt]

(Lt(LiteralDecimal $x：*)(LiteralDecimal $y：*))＝＞(Boolean{$x＜$y})

26.[EliminateLt]

(Lt(UteralDouble $x：*)(LiteralDouble $y：*))＝＞(Boolean{$x＜$y})

27.[EliminateLt]

(Lt(UteralFloat $x：*)(UteralFloat $y：*))＝＞(Boolean{$x＜$y})

28.[EliminateLt]

(Lt(Uterallnt64 $x：*)(Uterallnt64 $y：*))＝＞(Boolean{$x＜$y})

29.[EliminateLt]

(Lt(Uterallnt32 $x：*)(Literallnt32 $y：*))＝＞(Boolean{$x＜$y})

30.[EliminateLe]

(Le(LiteralDecimal $x：*)(UteralDecimal $y：*))＝＞(Boolean{$x＜＝$y})

31.[EliminateLe]

(Le(LiteralDouble $x：*)(LiteraIDouble $y：*))＝＞(Boolean{$x＜＝$y})

32.[EliminateLe]

(Le(LiteralFloat $x：*)(LiteralFloat $y：*))＝＞(Boolean{$x＜＝$y})·

33.[EliminateLe]

(Le(Literallnt64 $x：*)(Literallnt64 $y：*))＝＞(Boolean{$x＜＝$y})

34.[EliminateLe]

(Le(Literallnt32 $x：*)(Literallnt32 $y：*))＝＞(Boolean{$x＜＝$y})

用于XML节点性质的常量合并模式：

1.[EliminateNameOf]

(NameOf(ElementCtor$name：**))＝＞$name

2.[EliminateNameOf]

(NameOf(Let(ElementCtor$name：**)))＝＞$name

3.[EliminateNameOf]

(NameOf(For(ElementCtor$name：**)))＝＞$name

4.[EliminateNameOf]

(NameOf(AttributeCtor$name：**))＝＞$name

5.[EliminateNameOf]

(NameOf(Let(AttributeCtor$name：**)))＝＞$name

6.[EliminateNameOf]

(NameOf(For(AttributeCtor$name：**)))＝＞$name

7.[EliminateNameOf]

(NameOf(CommentCtor*))＝＞

8.{EliminateNameOf]

(NameOf(Let(CommentCtor*)))＝＞

9.[EliminateNameOf]

(NameOf(For(CommentCtor*)))＝＞

10.[EliminateNameOf]

(NameOf(PICtor**))＝＞

11.[EliminateNameOf]

(NameOf(Let(PICtor**)))＝＞

12.[EliminateNameOf]

(NameOf(For(PICtor**)))＝＞

13.[EliminateNameOf]

(NameOf(TextCtor*))＝＞

14.[EliminateNameOf]

(NameOf(Let(TextCtor*)))＝＞

15.[EliminateNameOf]

(NameOf(For(TextCtor*)))＝＞

16.[EliminateNameOf]

(NameOf(DocumentCtor*))＝＞

17.[EliminateNameOf]

(NameOf(Let(DocumentCtor*)))＝＞

18.[FliminateNameOf]

(NameOf(For(DocumentCtor*)))＝＞

19.[EliminateLocalNameOf]

(LocalNameOf(ElementCtor$name：**))＝＞(LiteralString{$name.LocalName})

20.[EliminateLocalNameOf]

(LocalNameOf(Let(ElementCtor $name：**)))＝＞(LiteralString{$name.LocalName})

21.[EliminateLocalNameOf]

(LocalNameOf(For(ElementCtor $name：**)))＝＞(LiteralString{$name.LocalName})

22.[EliminateLocalNameOf]

(LocalNameOf(AttributeCtor $name：**))＝＞(UteralString{$name.LocalName})

23.[EliminateLocalNameOf]

(LocalNameOf(Let(AttributeCtor $name：**)))＝＞(LiteralString{$name.LocalName})

24.[EliminateLocalNameOf]

(LocalNameOf(For(AttributeCtor $name：**)))＝＞(LiteralString{$name.LocalName})

25.[EliminateLocalNameOf]

(LocalNameOf(CommentCtor*))＝＞

26.[EliminateLocalNameOf]

(LocalNameOf(Let(CommentCtor*)))＝＞

27.[EliminateLocalNameOf]

(LocalNameOf(For(CommentCtor*)))＝＞

28.[EliminateLocalNameOf]

(LocalNameOf(PICtor**))＝＞

29.[EliminateLocalNameOf]

(LocalNameOf(Let(PICtor**)))＝＞

30.[EliminateLocalNameOf]

(LocalNameOf(For(PICtor**)))＝＞

31.[EliminateLocalNameOf]

(LocalNameOf(TextCtor*))＝＞

32.[EliminateLocalNameOf]

(LocalNameOf(Let(TextCtor*)))＝＞

33.[EliminateLocalNameOf]

(LocalNameOf(For(TextCtor*)))＝＞

34.[EliminateLocalNameOf]

(LocalNameOf(DocumentCtor*))＝＞

35.[EliminateLocalNameOf]

(LocalNameOf(Let(DocumentCtor*)))＝＞

36.[EliminateLocalNameOf]

(LocalNameOf(For(DocumentCtor*)))＝＞

37.[EliminateNamespaceUriOf]

(NamespaceUriOf(ElementCtor $name：**))＝＞(LiteralString{$name.NamespaceURI}).

38.[EliminateNamespaceUriOf]

(NamespaceUriOf(Let(ElementCtor $name：**)))＝＞(LiteralString{$name.NamespaceURI})

39.[EliminateNamespaceUriOf]

(NamespaceUriOf(For(ElementCtor $name：**)))＝＞(LiteralString{$name.NamespaceURI})

40.[EliminateNamespaceUriOf]

(NamespaceUriOf(AttributeCtor $name：**))＝＞(LiteralString{$name.NamespaceURI})

41.(EliminateNamespaceUriOf]

(NamespaceUriOf(Let(AttributeCtor$name：**)))＝＞

(LiteralString{$name.NamespaceURI})

42.[EliminateNamespaceUriOf]

(NamespaceUriOf(For(AttributeCtor$name：**)))＝＞

(LiteralString{$name.NamespaceURI})

43.[EiminateNamespaceUriOf]

(NamespaceUriOf(CommentCtor*))＝＞

44.[EliminateNamespaceUriOf]

(NamespaceUriOf(Let(CommentCtor*)))＝＞

45.[EliminateNamespaceUriOf]

(NamespaceUriOf(For(CommentCtor*)))＝＞

46.[EliminateNamespaceUriOf]

(NamespaceUriOf(PICtor**))＝＞

47.[EliminateNamespaceUriOf]

(NamespaceUriOf(Let(PICtor**)))＝＞

48.[EliminateNamespaceUriOf](NamespaceUriOf(For(PICtor**)))＝＞

49.[EliminateNamespaceUriOf]

(NamespaceUriOf(TextCtor*))＝＞

50.[EliminateNamespaceUriOf]

(NamespaceUriOf(Let(TextCtor*)))＝＞

51.[EliminateNamespaceUriOf]

(NamespaceUriOf(For(TextCtor*)))＝＞

52.[EliminateNamespaceUriOf]

(NamespaceUriOf(DocumentCtor*))＝>

53.[EliminateNamespaceUriOf]

(NamespaceUriOf(Let(DocumentCtor*)))＝＞

54.(EliminateNamespaceUriOf]

(NamespaceUriOf(For(DocumentCtor*)))＝＞

用于类型操作码的常量合并模式：

1.[EliminateIsEmpty]

(IsEmpty $x：*){$x.QilType.IsEmpty}＝＞(True)

2.[EliminateIsEmpty]

(IsEmpty $x：*){($x.QilType.Cardinality & QilCardinality.Zero)＝0}＝＞(False)

用于XPath操作码的常量合并模式：

1.[FoldXPathNodeValueCtor]

(XPathNodeValue(AttributeCtor$name：*$content：*{IsConvertibleToString($content)}))＝＞{ConvertToString($content)}

2.[FoldXPathNodeValueCtor]

(XPathNodeValue(For(AttributeCtor$name：*$content：*

{IsConvertibleToString($content)})))＝＞{ConvertToStruig($content)}

3.[FoldXPathNodeValueCtor]

(XPathNodeValue(ElementCtor$name：*(TextCtorScontent：*{IsConvertibleToString($content)})))＝＞{ConvertToString($content)}

4.[FoldXPathNodeValueC′tor]

(XPathNodeValue(For(ElementCtor$name：*(TextCtor$content：*{IsConvertibleToString($content)}))))＝＞{ConvertToString($content)}

5.[FoldXPathNodeValueCtor]

(XPathNodeValue(ElementCtor$name：*$content：*{IsConvertibleToString($content)}))＝＞{ConvertToString($content)}

6.[FoldXPathNodeValueCtor]

(XPathNode Value(For(ElementCtor$name：*$content：*

{IsConvertibleToString($content)})))＝＞{ConvertToString($content)}

7.[FoldXPathNodeValueCtor]

(XPathNode Value(TextCtor$content：*

{IsConvertibleToString($content)}))＝＞{ConvertToString($content)}

8.[FoldXPathNodeValueCtor]

(XPathNode Value(For(TextCtor$content：*

{IsConvertibleToString($content)})))＝＞{ConvertToString($content)}

9.[FoldXPathNodeValueCtor]

(XPathNode Value(NamespaceDecl**))＝＞(LiteralStnng″″)

10.FoldXPathNodeValueCtor]

(XPathNode Value(For(NamespaceDecl**)))＝＞(LiteralStnng″″)

逻辑重写模式：

1.[FoldNotNot]

(Not(Not$x：*))＝＞$x

2.[IntroduceNand]

(Not(Or $x：*$y：*))＝＞(And(Not $x)(Not $y))

3.[FoldNotEq]

(Not(Eq $x：*$y：*))＝＞(Ne $x $y)

4.[FoldNotNe]

(Not(Ne $x：*$y：*))＝＞(Eq $x $y)

5.[FoldNotLt]

(Not(Lt $x：>>$y：*))＝＞(Ge $x $y)

6.[FoldNotLe]

(Not(Le $x：*$y：*))＝＞(Gt $x $y)

7.[FoldNotGt]

(Not(Gt $x：*$y：*))＝＞(Le $x $y)

8.[FoldNotGe]

(Not(Ge $x：*$y：*))＝＞(Lt $x $y)

9.[FoldNofls]

(Not Os $x：*$y：*))＝＞(IsNot $x：*$y：*)

10.[FoldNotIsNot]

(Not(IsNot $x：*$y：*))＝＞(Is $x $y)

11.[PoldConditionalNot]

(Conditional(Not $x：*)$true：*$false：*)＝＞(Conditional$x$false$true)

12.[EliminateConditional]

(Conditional(IsEmpty $x：*)$y：(Ust){$y.QilType.IsEmpty}$z：*{$z＝$x})＝＞$x

13.[FoldBooleanEquality]

(Eq(True)$x：*)＝＞$x

14. [FoldBooleanEquality]

(Eq(False)$x：*)＝＞(Not $x)

15.[FoldBooleanEquality]

(Eq $x：*(True))＝＞$x

16.[FoldBooleanEquality]

(Eq $x：*(False))＝＞(Not$x)

17.[FoldBooleanEquality]

(Eq $x：*$y：*){$x.QilType.IsBoolean && $y.QilType.IsBoolean}

＝＞(Or(And $x $y)(And(Not $x)(Not $y)))

18.[FoldBooleanInquality]

(Ne(True)$x：*)＝＞(Not $x)

19.[FoldBooleanInquality]

(Ne(False)$x：*)＝＞$x

20.[FoldBooleanInquality]

(Ne$x：*(True))＝＞(Not$x)

21.[FoldBooleanInquality]

(Ne $x：*(False))＝＞$x

22.[FoldBooleanInquality]

(Ne $x：*$y：*){$x.QilType.IsBoolean && $y.QilType.IsBoolean}

＝＞(Or(And $x(Not $y))(And(Not $x)$y))

23.[IntroduceExists]

(Gt(Length $x：*)(Literallnt32 0))＝＞(Not(IsEmpty $x))

24.(IntroduceExists]

(Ne(Length $x：*)(Literallnt32 0))＝＞(Not(IsEmpty $x))

25.[IntroduceIsEmpty]

(Eq(Length！\：*)(Literallnt32 0))＝＞(IsEmpty $x)

26.[IntroduceIsEmpty]

(Le(Length$ x：*)(Literallnt32 0))＝＞(IsEmpty $x)

27.[ConstrainLength]

#Use the constraint that Length＝＞0

(Ge(Length $x：*)(Literallnt32 0))＝＞(True)

28.[ConstrainLength]

#Use the constraint that Length＞＝0

(Lt(Length $x：*)(Literallnt32 0))＝＞(False)

基本路径重写模式：

1.#Should be(Content(DocumentCtor$content：*))＝＞$content

[FoldContentDocuroentCtor]

$x：(Contcnt(DocumentCtor$content：*))

＝＞(FixupNavigation $x，$content)

2.[FoldContentDocumentCtor]

$x：(Content(For(DocumentCtor$content：*)))

＝＞{FixupNavigation($x，$content)}

3.#Should be(Content(ElementCtor$content：*))＝＞$content

[FoldContentElementCtor]

$x：(Conten(ElementCtor*$content：*))

＝＞{FixupNavigation($x，$content)}

4.[FoldContentElementCtor]

$x：(Content(For(ElementCtor*$content：*)))

＝＞{FixupNavigation($x，$conient)}

5.[CommuteContentTupIe]

(Content(Tuple $fbr：*$w：*$r：*))＝＞(Tuple $fbr $w(Content $r))

6.[FoldContentAttributeCtor]

(Content(AttributeCtor**))＝＞(List)

7.[FoldContentAttributeCtor]

(Content(For(AttributeCtor**))＝＞(List)

其它路径重写模式：

1.[EliminateParent]

(Parent(For(Content $x：*)))＝＞$x

2.[EliminateSelf]

(Self$x：*)＝＞$x

3.[EliminateDescendantOrSelf]

(DescendantOrSelf(For $x：*){IsConstructed2($x)}

＝＞{EvaluateDescendantOrSelf($x)}

4.[EliminateXPathDescendant]

$d：(XPathDescendant(For$x：*)){IsConstructed2($x))

＝＞{

QilList list＝f.List()；

Ust-QilType＝f.TypeFactory.Sequence($d.Type，QilCardinality.Zero)；

}{EvaluateDescendant($x，list}

循环重复重写模式：

1.[EliminateTuple]

(Tuple $i：(For $b：*)$w：*$r：*){$r＝$i && ！DependsOn($w，$i)}

＝＞(Conditional $w $b(List))

2.[EliminateTuple]

(Tuple $i：(For $b：*){$b.QilType.IsSingleton}$w：*$r：*){！DependsOn($w，$i)&&

！DependsOn($r，$i)}＝＞(Conditional $w $r(List))

3.[EliminateTuple]

(Tuple $i：(For $b：*)$w：*$r*)

{！DependsOn($w，$i)&&！DependsOn($r，$i)}

＝＞(Conditional $w(NTimes $r(Length $b))(List))

4.[IntroduceNTimes]

(Tuple $i：*$w：*$r：*){！DependsOn($r，$i)}

＝＞(NTimes $r(Length(Tuple$i$w$i)))

元组重写模式：

1.[FoldTupleTuple]

(Tuple $f：(For*){$f.Binding.QilType.IsSingleton}

$x：*{！DependsOn($x，$f)}

$t：(Tuple $g：(For*){((Qimerator)$g).Binding＝$f}

$w：*

$r：*){！DependsOn($w，$f)&&！DependsOn($r，$f)})

＝＞{

$g.Binding＝$f.Binding；

((QilTuple)$t).Where＝f.And($x，$w)；

}

$t

2.[MiscCollapseTuple]

(Tuple $i：*$w：*(Tuple $j：(Let $binding：*)$x：*$k：*)

{$j＝$k})＝＞(Tuple $i(And $w $x)$binding)

3.[FoldTupleConditional]

(Tuple $i：*$w：*(Conditional $cond：*$return：*$list：(List)

{$list.QilType.IsEmpty}))

＝＞(Tuple $i(And $w $cond)$return)

4.[FoldTupleConditional]

(Tuple $i：*$w：*(Conditional $cond：*$list：(List)

{$list.QilType.IsEmpty}$return：*))

＝＞(Tuple $i(And $w(Not$cond))$return)

5.[EliminateReturn]

$x：(IsEmpty $t：(Tuple***))

＝＞{

QilTuplet＝(QilTuple)$t；

while(t.For.Type！＝QilNodeType-Let

&&t.Return.Type＝QilNodeType.Tuple)

t＝(QilTuple)t.Return；

if(t.For.Type！＝QilNodeType.Let&&

！((.Return is Qillterator)&&t.Return.QilType.IsSingleton){

t.Return＝t.For；

return Replace($O.EliminateRetum，$x，f.IsEmpty($t)，true)；

}

6.[IntroduceList]

(Tuple*(False)*)＝＞(List)

7.(IntroduceList]

(Tuple**$list：(List){$list.QilType.IsEmpty})＝＞$list

8.[IntroduceList]

(Tuple(For $list：(List){$list.QilType.IsEmpty})**)＝＞$list

9.[EliminateTuple]

(Tuple $i：(For$x：*)(True)$j：*){$i＝$j}＝＞$x

10.[EliminateTuple]

(Tuple $i：(Let$x：*)(True)$j：*){$i＝$j}＝＞$x

11.[EliminateNTtmes]

(DocOrderDistinct $t：(Tuple***))

＝＞{

QilTuple last＝$t.LastTuple；

if(last.Return.Type＝QilNodeType.NTimes){

QilBinary ntimes＝(QiIBinary)last；Return；

QilUst list＝f.ListQ；

list.Type＝f.TypeFactory.Sequence(QilCardinality.Zero，ntimes.Type)；

last.Return＝Replace($O.EliminateNTimes，ntimes，

f.Conditional(f.Gt(ntimes.Right，f.Int32(0)).ntimes.Left，list))；

}

位置重写模式：

1.[EliminatePositionOf]

(PositionOf(Let*))＝＞(Literallnt32 1)

2.[EliminatePositionOf]

(PositionOf(For $x：*){$x.QUType.IsSingleton})＝＞(Literallnt32 1)

3.[ConstrainPositionOf]

(Ge(PositionOf*)(Literallnt32 1))＝＞(True)

4.[ConstrainPositionOf]

(Lt(PositionOf*)(Literallnt32 1))＝＞(False)

5.[ConstrainPositionOf]

(Gt $p：(PositionOf*)$one：(Literallnt32 1))＝＞(Ne $p $one)

6.[ConstraintPositionOf]

(Le $p：(PositionOf*)$one：(UteralInt32 1))＝＞(Eq $p $one)

交换模式：

1.[CommuteIsEmptyList]

$x：(IsEmpty $list：(List*))＝＞{

QilNode result＝f.TrueQ；

foreach(QilNode member in((QilList)$list)){

if(member.QilType.IsEmpty){

//contributes nothing没有东西提供

}

else if((member.QilType.Cardinality & QilCardinality.Zero)＝0){

//whole List is non-empty整个列表非空

return Replace($O.ConunuleIsEmptyList，$x，f.False())；

}

else{

result＝f.And(result，f.IsEmpty(member))；

}

return Replace($O.CommuteIsEmptyList，$x，result，true)；

}

2.[CommuteXPathNodeValueUst]

$x：(XPathNode Value $members：(List*))＝＞{

boot fSuccess＝true；

QilStrConcat result＝f.StrConcatQ；

foreach(QilNode member in((QilList)$members)){

if(！IsConvertibleToString(member)){

fSuccess＝false；

break；

}

else

result.Add(ConvertToString(member))；

}

if(fSuccess)

return Replace($O.CommuteXPathNodeValueList，$x，result，true)；

}

3.[CommuteIsEmptyTuple]

(IsEmpty(Tuple*(False)*))＝＞(True)

4.[CommuteSetIsEmptyTuple]

(IsEmpty(Tuple $i：*$w：*$r：*))

{！DependsOn($w，$i)&&！DependsOn($r，$i)}

＝＞(Or(Not $w)(IsEmpty $r))

5.[CommuteIsEmptyConditional]

(IsEmpty(Conditional $cond：*$true：*$false：*))

＝＞(Conditional $cond(IsEmpty $true)(IsEmpty $false))

6.[CommuteTupleTuple]

$outer：(Tuple

$ai：(For $inner：(Tuple $bi：*$bw：*$br：*))$aw：*$ar：*)

＝＞{

//(Tuple $$bi $$bw(Tuple(For $$br)$$aw $$ar))

//Avoid having to push substitutions：避免必须推进置换

SaLBinding＝$br；

((QilTuple)$inner).Return＝f.Tuple($ai，$aw，$ar)；

return Replace($O.CommuteTupleTuple，$outer，$inner，true)；

}

7.[CommuteTupleUst]

$t：(Tuple $i：(For $list：(Ust*))$w：*$r：*)＝＞{

QilUst result＝f.ListO；

foreach(QilNode member in((QilList)$list)){

Qillteratorj＝f.For(member)；

PushSubstitution($i，j)；

result.Add(f.Tuple(j，Clone($w)，Clone($r)))；

}

return RepIace($O.CommuteTupleList，$t，result，true)；

}

8.[CommuteTupleConditional]

$t：(Tuple $i：(For(Conditional $cond：*$true：*

list：(List){$list.QilType.IsEmpty}))$w：*$r：*)＝＞{

//(Tuple(For $$true)(And $$w $$cond)$$r)

//avoid having to push substitutions避免必须推进置换

$i.Binding＝$true；

return Replace($O.CommuteTupleConditional，$t，

f.Tuple($i，f.And($w，Scond)，$r)，true)；

}

9.[CommuteTupleConditional]

$t：(Tuple $i：(For(Conditional $cond：*

$list：(List){$list.QiIType.IsEmpty}$false：*))$w：*$r：*)

＝＞{

//(Tuple(For $$false)(And $$w(Not$$cond))$$r)

//avoid having to push substitutions避免必须推进置换

$i.Binding＝$false；

return Replace($O.CommuteTupleConditional，$t，

f.Tuple($i，f.And($w，f.Not($cond))，$r)，true)；

}

10.[ConunuteDocOrderDistinctConditional]

(DocOrderDistinct(Conditional $cond：*$true：*$false：*))

＝＞(Conditional $cond(DocOrderDistinct $true)(DocOrderDistinct $false))

类型合并模式：

1.[EliminateIsType]

(IsType $x：*$t：*){TypesMatch($x.QilType，$t)}＝＞(True)

2.[EliminateIsType]

(IsType $x：*$t：*){TypesDontMatch($x.QilType，.$t)}＝＞(False)

3.[EliminateConvert]

(Convert $x：*$t：*){$x.QilType＝$t}＝＞$x

种类消除/分组模式：

1.[EliminateDocOrderDistinct]

(DocOrderDistinct $x：*){IsConstructed($x)}＝＞$x

2.[EliminateDocOrderDistinct]

(DocOrderDistinct $t：(01dTuple***)){IsConstructed($t.LastTuple.Return)}＝＞$t

3.[EliminateDocOrderDistinct]

(DocOrderDistinct $x：(List)){$x.QilType.IsEmpty})＝＞$x

4.[EliminateSort]

(Sort(For $x：(List){$x.QilType.IsEmpty})*)＝＞$x

Claims

1.一种用于为输入查询构造最佳表示，该方法包括：

接收输入查询，其中输入查询是包括节点的中间语言表示，每个节点都具有各自的节点类型；

以左深度第一方式检查该节点，以便识别用于优化的节点类型；

标记相应于被识别的节点类型的节点；

向上移动到下一个节点，直到输入查询的中间语言表示已经全部被检查过；

从中间语言表示的顶部开始搜索被标记的节点，并且识别将被优化的相关代码模式；以及

用改进的代码模式调整被标记的代码模式，以便为输入查询形成最佳表示。

2.根据权利要求1的方法，其中接收步骤包括接收语义中间语言表示。

3.根据权利要求2的方法，其中该语义表示包括包含节点的图形结构。

4.根据权利要求1的方法，其中改进的代码模式是利用一个或多个变换产生的，该变换包括常量合并、逻辑重写、路径重写、循环重复代码重写、元组重写、位置重写、交换、内嵌以及种类消除中的至少一个。

5.一种计算机可读介质，具有计算机可执行指令，该指令用于执行用来为输入查询构造最佳表示的方法，该方法包括：

接收输入查询，其中输入查询是包含代码模式和节点的中间语言表示，每个代码具有各自的节点类型；

以左深度第一方式检查该节点以便识别用于优化主题的代码模式和节点类型；

标记被识别的节点模式直到输入查询的中间语言表示已经全部被检查过；

从中间语言表示的顶部开始搜索被标记的代码模式；以及

用改进的代码模式调整被标记的代码模式从而为输入查询形成最佳表示。

6.一种计算机系统，用于为输入查询产生优化的表示，该系统包括：

一输入设备，用于接收输入查询；

一个或多个中间语言编译器，其中根据输入查询产生包含节点的中间语言表示；以及

一优化器，执行如下动作：

标记相应于被识别的节点类型的节点；

7.根据权利要求6的系统，还包括优化后处理部分，用于形成查询结果，包括：

一个或多个目标产生器，其中最佳表示被变换为一个或多个目标表示，形成目标查询；

一个或多个数据源，用于在其上进行查询；以及

一个或多个执行引擎，其中在一个或多个数据源上执行目标查询，以便生成查询结果。

8.一种计算机系统，用于产生一个或多个输入查询的XML中间语言表示的最佳表示，包括：

一个或多个输入设备，用于接收一个或多个输入查询；

一个或多个中间语言编译器，其中每个编译器产生输入查询的中间语言表示；

一表达式计算器，它将每个中间语言表示组合到单独的XML中间语言表示中；以及

一优化器，执行如下动作：

以左深度第一方式检查该节点以便识别作为优化主题的代码模式和节点类型；

从中间语言表示的顶部开始搜索被标记的代码模式；以及

9.根据权利要求8的系统，其中一个或多个输入查询包括一个或多个XML查询和XML查看。

10.根据权利要求8的系统，还包括优化后处理部分，用于形成查询结果，该系统包括：

一个或多个数据源，用于在其上进行查询；以及

11.一种用于为输入查询构造最佳表示的方法，该方法包括：

接收输入查询，其中输入查询是包含节点的中间语言表示，每个节点都具有各自的节点类型；

检查该节点，以便检验与各个节点类型相关的代码模式；

利用模式匹配算法来比较所检验的节点模式，以便检测未被优化的代码模式；以及

用改进的代码模式调整未被优化的代码模式和被检验的代码模式中的一个或多个，以便为输入查询形成最佳表示。

12.根据权利要求11的方法，其中接收步骤包括接收语义中间语言表示。

13.根据权利要求12的方法，其中该语义表示包括包含节点的图形结构。

14.根据权利要求11的方法，其中改进的代码模式是利用一个或多个变换产生的，该变换包括常量合并、逻辑重写、路径重写、循环重复代码重写、元组重写、位置重写、交换、内嵌以及种类消除中的至少一个。

15.一种计算机可读介质，具有计算机可执行指令，该指令用于实现为输入查询构造最佳表示的方法，该方法包括：

检查该节点，以便检验与各个节点类型相关的代码模式；

16.一种计算机系统，用于产生一个或多个输入查询的XML中间语言表示的最佳表示，包括：

一个或多个输入设备，用于接收一个或多个输入查询；

一优化器，执行如下动作：

检查该节点，以便检验与各个节点类型相关的代码模式；