|Publication number||US7010524 B2|
|Application number||US 10/785,328|
|Publication date||Mar 7, 2006|
|Filing date||Feb 24, 2004|
|Priority date||Mar 31, 2000|
|Also published as||US6721724, US7158963, US7194452, US7337169, US20040167891, US20050149492, US20050267874, US20060020573|
|Publication number||10785328, 785328, US 7010524 B2, US 7010524B2, US-B2-7010524, US7010524 B2, US7010524B2|
|Inventors||Cesar A. Galindo-Legaria, Florian Waas|
|Original Assignee||Microsoft Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (23), Non-Patent Citations (2), Referenced by (8), Classifications (21), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This application is a division of U.S. patent application Ser. No. 09/539,824, filed Mar. 31, 2000 now U.S. Pat. No. 6,721,724. The above application is incorporated herein by reference.
The present invention relates to electronic data processing, and more particularly concerns testing the validity of execution plans produced by database search engines for retrieving data from databases in response to user queries.
Many database systems receive user queries written in a non-procedural language such as SQL (structured query language) or QBE (query by example). This class of language allows users to formulate queries against a database in terms characteristics of the desired data, rather than specifying the operations required to extract the desired data from the database. Such database systems contain a search engine that converts the non-procedural query into an execution plan or tree having a sequence of detailed operations that will obtain the requested data. Execution plans for a given query are seldom unique. That is, there is usually a number—frequently a very large number—of different execution plans, each having different operations and/or different orders of operations, that all generate the same set of result data. Not all plans, however, are equally desirable. Some have a lower—sometimes very much lower—execution cost than others. Cost is normally expressed in arbitrary units representing computer time and resources required to carry out all the operations of an execution plan. Search engines of this type almost always contain an optimizer that attempts to produce a plan having a low estimated cost for obtaining the data. Although search engines and optimizers involve a high degree of expertise to design, many of them are available from a number of different sources.
There are situations where it is desirable to obtain information about execution plans in addition to the one chosen by the optimizer for execution. In a product-development setting, for example, the ability to generate and test a large number of candidate plans for the same query is useful in designing, tuning, and checking the large number of components in a search engine, especially in its optimizer subsystem. Some of the purposes for testing multiple plans are:
Validating query plans is extremely valuable during development and testing of a query processor, and it useful even in a regular operating environment. However, the total number of possible alternative plans that can be developed to satisfy commonly encountered queries quickly becomes gigantic. Even the large, fast machines found in development laboratories cannot abide validating such huge numbers of alternative plans from a single query. For these reasons, checking alternative execution plans in database systems has been limited to selecting a relatively small number of plans more or less by hand, and running them through a validation process in the same manner that a single plan would be validated. Much more seriously, even the small number of tested plans in previous systems tend to be distributed in a non-random manner. That is, the plans selected for testing are clumped around certain strategies, and do not test a sample that is widely distributed among all the possible strategies and variations. The sample space is not uniform.
Even where a smaller number of possible alternative plans allows all of them to be validated, conventional methods provide no technique for listing these alternatives in any organized manner. If the alternatives cannot be organized in some way, a test program has no way to ensure that each of them is selected (and selected only once) for testing, and thus no way to guarantee that the test is exhaustive.
Database-system technology thus requires a way to validate execution plans from a single query in a manner that can be sufficiently random or exhaustive.
The present invention permits the validation of large numbers of alternative execution plans for a database query with a process that organizes the components of such plans efficiently. The invention allows sampling a random subset of the alternative plans, rather than a subset confined to a relatively small part of the space of all possible plans. Where time is available for a test of every plan, the invention can provide an exhaustive list of all possible alternative plans for a given query.
The invention achieves these and other advantages by building groups of operators representing alternative plans for a query and that have unique identifiers or ranks. Execution trees for alternative plans can then be quickly assembled by unranking them to assemble different operators from the groups. The execution trees are then tested, analyzed, or otherwise manipulated. If desired, alternatives can be specified for producing only certain plans, for covering a particular range of plans, or for other purposes.
This description and the accompanying drawing illustrate specific examples of embodiments in which the present invention can be practiced, in sufficient detail to allow those skilled in the art to understand and practice the invention. Other embodiments, including logical, electrical, and mechanical variations, are within the skill of the art. Skilled artisans will also recognize features and advantages of the invention other than those explicitly set forth. The scope of the invention is to be defined only by the appended claims, and not by the specific embodiments described below.
Hardware components 120 are shown as a conventional personal computer (PC) including a number of components coupled together by one or more system buses 121 for carrying instructions, data, and control signals. These buses may assume a number of forms, such as the conventional ISA, PCI, and AGP buses. Some or all of the units coupled to a bus can act as a bus master for initiating transfers to other units. Processing unit 130 may have one or more microprocessors 131 driven by system clock 132 and coupled to one or more buses 121 by controllers 133. Internal memory system 140 supplies instructions and data to processing unit 130. High-speed RAM 141stores any or all of the elements of software 110. ROM 142 commonly stores basic input/output system (BIOS) software for starting PC 120 and for controlling low-level operations among its components. Bulk storage subsystem 150 stores one or more elements of software 110. Hard disk drive 151 stores software 110 in a nonvolatile form. Drives 152 read and write software on removable media such as magnetic diskette 153 and optical disc 154. Other technologies for bulk storage are also known in the art. Adapters 155 couple the storage devices to system buses 121, and sometimes to each other directly. Other hardware units and adapters, indicated generally at 160, may perform specialized functions such as data encryption, signal processing, and the like, under the control of the processor or another unit on the buses.
Input/output (I/O) subsystem 170 has a number of specialized adapters 171 for connecting PC 120 to external devices for interfacing with a user. A monitor 172 creates a visual display of graphic data in any of several known forms. Speakers 173 output audio data that may arrive at an adapter 171 as digital wave samples, musical-instrument digital interface (MIDI) streams, or other formats. Keyboard 174 accepts keystrokes from the user. A mouse or other pointing device 175 indicates where a user action is to occur. Block 176 represents other input and/or output devices, such as a small camera or microphone for converting video and audio input signals into digital data. Other input and output devices, such as printers and scanners commonly connect to standardized ports 177. These ports include parallel, serial, SCSI, USB, FireWire, and other conventional forms.
Personal computers frequently connect to other computers in networks. For example, local area network (LAN) 180 connect PC 120 to other PCs 120′ and/or to remote servers 181 through a network adapter 182 in PC 120, using a standard protocol such as Ethernet or token-ring. Although
Software elements 110 may be divided into a number of types whose terminology overlaps to some degree. For example, the previously mentioned BIOS sometimes includes high-level routines or programs which might also be classified as part of an operating system (OS) in other settings. The major purpose of OS 111 is to provide a software environment for executing application programs 112 and for managing the resources of system 100. An OS such as Microsoft® Windows® or Windows NT® commonly implements high-level application-program interfaces (APIs), file systems, communications protocols, input/output data conversions, and other functions. Application programs 112 perform more direct functions for the user. A user normally calls them explicitly, although they can execute implicitly in connection with other applications or by association with particular data files or types. Modules 113 are packages of executable instructions and data which may perform functions for OSs 111 or for applications 112. Dynamic link libraries (.dll) and class definitions, for instance, supply functions to one or more programs. Data 114 includes user data of all types, data generated and/or stored by programs, and digital data that third parties make available on media or by download for use in computer 120. Software elements can be embodied as representations of program instructions and data in a number of physical media, such as memory 140, non-volatile storage 150, and signals on buses 183, 192, etc.
Query optimizer 210 receives a query on line 201 from a client computer such as 120 or from some other source. The optimizer can be of the transformation-driven kind, as described in, e.g., W. J. McKenna, “Efficient Search in Extensible Database Query Optimization: The Volcano Optimizer Generator,” PhD Thesis, University of Colorado, Boulder, 1993 and G. Graefe, et al., “The Volcano Optimizer Generator: Extensibility and Efficient Search,” Int'l Conference on Data Engineering, Vienna, Austria, 1993. It converts the query into a number of possible alternative plans in a conventional manner, determines the costs of these plans in terms of processing time and resources, and selects the best one for execution. (Although this unit could be aptly termed a “plan generator,” this description follows industry custom in naming it according to one of the functions that it usually—but not necessarily—also performs, optimization of the generated plans.) The terms “plan” and “tree” are used interchangeably herein. Query execution plans are normally constructed as trees, although other structures are possible. Line 211 carries this execution plan or tree to an execution engine 220 such as the processors of computers 120, 181, or 191, or an interpreter for a set of operators specially designed for databases. Applying the plan to database 230 returns data on line 221 to satisfy the query, or to affect the database in some way. In normal operation, validation module 240 might (or might not) also receive the selected execution plan and perform some simple checks. Line 241 produces an error signal if the plan fails certain conventional tests. The optimizer stores the alternative plans in data structure 250. This data structure, a table in this embodiment, stores alternative operations and their interconnections at a number of different levels, as described hereinafter. This table is not destroyed in the process of determining an optimum plan, but is kept for later construction of alternative plans other than the single optimum plan. Ranking module 260 builds a directory 251 having pointers to the locations of various operators and groups within structure 250, and computes “rank data.” Alternative plans for the query can be obtained by traversing the operators in different ways. Based on the computed rank data of operators, each complete plans is implicitly assigned a unique “rank,” a numeric or other designation that uniquely identifies one particular alternative plan with respect to all the other possible alternative plans. How the “rank” of a plan is related to the “rank data” of its operators is described later.
Accordingly, the directory also keeps track of the number of plans that it is possible to generate. Module 260 also unranks the alternative plans for validation. That is, it builds execution trees for plans whose components are stored in table 250 by selecting particular alternative plans from the collection of possible plans. A specification 261 determines which plans are selected. Specification 261 characterizes the desired plans by named ranks, a set of randomly selected ranks, or other characteristics. The specification can be input from a test generator, directly from a developer, or from any other origin. Line 261 carries these execution plans to validation module 240, where they can be manipulated or analyzed in the same way as a plan emitted directly from optimizer 210.
A root group, 350, labeled Group 5, has two operators, a “Join” 351 and some other arbitrary operator 352, labeled “???” in
Both of the operators in Group 4 happen to be terminals. That is, they do not have any further operators, and thus do not signal a selection from any other group in table 250.
Both of the operators in Group 3 do, however, require further operations that must be selected from other groups. The dummy variable 331, labeled “???” first requires a selection among operations 311–313 from Group 1, followed by a selection between operations 321–322 from Group 2. “Join” operator 332 entails just the reverse, as indicated by the circles at its lower right corner and the lines proceeding therefrom.
In this abbreviated example, all of the operators in Groups 1 and 2 are terminals.
Diagram 300 contains 2×2×2×2×3=48 alternative plans. Selecting one possible alternative plan involves choosing one alternative from root Group 4, say operator 352. This allows 2×2×2×3=24 possible alternatives from the remaining groups. Both of the operators in Group 4 represent only a single alternative, while both operators in Group 3 represent 2×3=6 alternatives from the groups remaining after a choice made from group 3. All of the operators chosen in Groups 1 and 2 are terminals, each representing only a single alternative.
This final identifier is the global rank of the particular alternative plan. It identifies the plan uniquely. Selecting for validation sample plans having random numbers in the range ‘0’–‘47’ leads to a wide variety of test cases, because the selections can be made entirely independently of the contents of the groups. There is no statistical clumping around any specific area of the collection of possible plans. If an exhaustive test is desired, sequentially selecting all possible numbers ‘0’–‘47’ guarantees that every plan will be tested once and only once. The process of generating an operator tree given its unique “rank” is called “unranking.” For example, unranking plans ‘1’, ‘18’, and ‘43’ means choosing the plans having those ranks from the pool of alternatives. Numeric ranks are convenient in several respects, but any other identifier, such as character designations, bit patterns, or memory addresses, can be employed instead, as long as they can be uniquely assigned to corresponding plan trees.
Some database-system optimizers use logical and physical operators. For example, a logical “join” can be carried out physically by a “hash join,” a “merge join,” and so forth. This embodiment screens out logical operators for counting and ranking. Execution plans only contain physical operators, although logical operators could be accommodated if desired. Some physical operators impose certain requirements upon their children. A merge join, for instance, requires that its input be in sorted order. A group could contain a “table scan” operator that does not deliver a sorted output, and also an “index scan” that does return the required sorted order. Accordingly, one operator can only be the child of another operator if the properties delivered by one are compatible with the properties required by the other. Conventional optimizers derive and check these properties as part of their normal function. Table 250 stores them, and they can be used to influence the ranking (counting) and unranking functions described below.
The number of possible execution plans or trees rooted at some operator ν is denoted N(ν). If the operator has no children groups (such as 341–342 in
First, extracting a tree from a group involves selecting one of the operators of a group, then extracting a tree from that operator. A group G having operators ν1, ν2, . . . , νn generates a number of trees equal to the sum of all the trees for each of the operators in that group: N(G)=N(ν1)+N(ν2)+ . . . +N(νn). In diagram 300, for example, N(Group 1)=3 and N(Group 2)=2.
Second, extracting a tree from an operator involves extracting trees from each of its child groups and integrating them with the operator as a root. An operator ν with child groups G1, G2, . . . , Gn, produces a different tree for every alternative in every group below it. Thus N(ν)=N(G1)×N(G2)× . . . ×N(Gn). For example, N(Operator 331)=6.
To build a directory 251 of alternative plans, blocks 510 of
Unranking a group chooses one of the operators in the selected group, then unranks that operator with an adjusted rank number. As an example of unranking a group, the total number of possible trees that can be extracted from Group 3 in
Unranking an operator calculates an adjusted rank number for each child group of the operator. The children groups are then unranked with their adjusted numbers. Finally, the operator is placed at the root of the result. Taking operator 331,
Method 600 begins by receiving a specification of one or more rank designations in block 610. For the example discussed in connection with
Method 600 ends when block 620 detects that all plans directed by the specification from block 610 have been processed.
As an example, consider unranking a Group-3 plan number, unranking each operator in that group. A person, or a script or random-number generator, can start with any number between ‘1’ and ‘12’. If this entity initially chooses number ‘7’, the top-most call is to UNRANK(Grp 3, 8), which translates to UNRANK(Op 312, 2). At this point a Group-3 operator choice is made by discarding operator 311. Operator 312 has a local rank of ‘2’, which determines how to select its children. A driver program can generate every possible plan by calling UNRANK(Grp 3, 1), UNRANK(Grp 3, 2), etc., thereby obtaining a different operator tree for each call.
If the goal is to generate a random plan, a person or program can generate a random number to use at the root, then follow the deterministic procedure to make subsequent selections from the root to the leaves. Another alternative is to make random selections at each point. This alternative starts at the root group and chooses randomly one of the operators as the plan root. Then, on the selected operator, children are selected randomly, taking into account the annotations N(.) to obtain a uniform distribution. For instance, if a group contains operators Op1, Op2, and Op3, with N(Op1)=1, N(Op2)=20, and N(Op3)=30, selecting Op1 with probability ⅓ would produce plans rooted at OP1 ⅓ of the time, but would rarely generate plans rooted at Op3. That is, local random choices must be biased in order for the final generation of plans to be uniform. The above illustrative numbers would achieve uniform distribution by selecting operator Op1 with 1/51 probability, Op2 with 20/51 probability, and Op3 with 30/51 probability, so each complete plan has the same probability of being obtained. Stated another way, the probability of selecting an operator from each group should be proportional to the number of possible subtrees of that operator in relation to the total number of subtrees of all operators in that group.
The present invention offers methods and apparatus for efficiently constructing large numbers of alternative execution plans for a single database query. This makes it feasible to validate many plans, by testing them, manipulating them, or obtaining information from them in a development or other environment. Logical and physical changes can be made to the illustrative apparatus shown, without departing from the spirit of the invention. The specific definitions and interconnections of the blocks can be varied. The steps of the illustrative methods can be varied; and, can be carried out in an order different from that shown, if desired.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US5091852||Jan 25, 1989||Feb 25, 1992||Hitachi, Ltd.||System for optimizing query processing in a relational database|
|US5598559||May 28, 1996||Jan 28, 1997||Hewlett-Packard Company||Method and apparatus for optimizing queries having group-by operators|
|US5608904 *||Feb 13, 1995||Mar 4, 1997||Hewlett-Packard Company||Method and apparatus for processing and optimizing queries having joins between structured data and text data|
|US5659725||Jun 6, 1994||Aug 19, 1997||Lucent Technologies Inc.||Query optimization by predicate move-around|
|US5717911||Jan 23, 1995||Feb 10, 1998||Tandem Computers, Inc.||Relational database system and method with high availability compliation of SQL programs|
|US5778364 *||Jan 2, 1996||Jul 7, 1998||Verity, Inc.||Evaluation of content of a data set using multiple and/or complex queries|
|US5822747 *||Aug 23, 1996||Oct 13, 1998||Tandem Computers, Inc.||System and method for optimizing database queries|
|US5832477||May 14, 1997||Nov 3, 1998||International Business Machines Corporation||Method and apparatus for reordering complex SQL queries containing inner and outer join operations|
|US5940819 *||Aug 29, 1997||Aug 17, 1999||International Business Machines Corporation||User specification of query access paths in a relational database management system|
|US5956706||May 9, 1997||Sep 21, 1999||International Business Machines Corporation||Method and system for limiting the cardinality of an SQL query result|
|US6341281||Apr 2, 1999||Jan 22, 2002||Sybase, Inc.||Database system with methods for optimizing performance of correlated subqueries by reusing invariant results of operator tree|
|US6353818||Aug 19, 1998||Mar 5, 2002||Ncr Corporation||Plan-per-tuple optimizing of database queries with user-defined functions|
|US6356887 *||Jun 28, 1999||Mar 12, 2002||Microsoft Corporation||Auto-parameterization of database queries|
|US6374263||Jul 19, 1999||Apr 16, 2002||International Business Machines Corp.||System for maintaining precomputed views|
|US6546381||Oct 4, 1999||Apr 8, 2003||International Business Machines Corporation||Query optimization system and method|
|US6581055||Sep 11, 2000||Jun 17, 2003||Oracle International Corporation||Query optimization with switch predicates|
|US6598044 *||Jun 25, 2002||Jul 22, 2003||Microsoft Corporation||Method for choosing optimal query execution plan for multiple defined equivalent query expressions|
|US6618719 *||May 19, 2000||Sep 9, 2003||Sybase, Inc.||Database system with methodology for reusing cost-based optimization decisions|
|US6721724 *||Mar 31, 2000||Apr 13, 2004||Microsoft Corporation||Validating multiple execution plans for database queries|
|US20040030677 *||May 8, 2003||Feb 12, 2004||Sybase, Inc.||Database System with Methodology for Distributing Query Optimization Effort Over Large Search Spaces|
|JP2001045500A||Title not available|
|JP2001218077A||Title not available|
|JP2002232766A||Title not available|
|1||*||Florian Waas et al.:"Counting, enumerating, and sampling of execution plans in a cost-based query optimizer", year 2000, ACM Press,, p. 499-509.|
|2||*||Navin Kabra et al.:"Efficient mid-query re-optimization of sub-optimal query execution plans", year 1998, ACM Press, p. 106-117.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7158963||Mar 24, 2005||Jan 2, 2007||Microsoft Corporation||Validating multiple execution plans for database queries|
|US7194452||Nov 24, 2004||Mar 20, 2007||Microsoft Corporation||Validating multiple execution plans for database queries|
|US7337169 *||Sep 23, 2005||Feb 26, 2008||Microsoft Corporation||Validating multiple execution plans for database queries|
|US9535952||Apr 11, 2012||Jan 3, 2017||International Business Machines Corporation||Dynamic selection of optimal grouping sequence at runtime for grouping sets, rollup and cube operations in SQL query processing|
|US20050027690 *||Jul 29, 2003||Feb 3, 2005||International Business Machines Corporation||Dynamic selection of optimal grouping sequence at runtime for grouping sets, rollup and cube operations in SQL query processing|
|US20050149492 *||Nov 24, 2004||Jul 7, 2005||Microsoft Corporation||Validating multiple execution plans for database queries|
|US20050267874 *||Mar 24, 2005||Dec 1, 2005||Microsoft Corporation||Validating multiple execution plans for database queries|
|US20060020573 *||Sep 23, 2005||Jan 26, 2006||Microsoft Corporation||Validating multiple execution plans for database queries|
|U.S. Classification||1/1, 709/206, 718/104, 707/999.003, 707/999.002, 707/999.101, 707/999.1, 707/999.102|
|Cooperative Classification||Y10S707/99952, Y10S707/99942, Y10S707/99932, Y10S707/959, Y10S707/99933, Y10S707/99943, G06F17/30436, G06F17/30454, G06F17/30463|
|European Classification||G06F17/30S4P2R, G06F17/30S4P3T2, G06F17/30S4P3T5|
|Aug 5, 2009||FPAY||Fee payment|
Year of fee payment: 4
|Aug 18, 2009||CC||Certificate of correction|
|Mar 18, 2013||FPAY||Fee payment|
Year of fee payment: 8
|Dec 9, 2014||AS||Assignment|
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034541/0477
Effective date: 20141014