Database Languages and their Compilers

Transcription

1 Database Languages and their Compilers Prof. Dr. Torsten Grust Database Systems Research Group U Tübingen Winter T. Grust Database Languages and their Compilers

2 4 Query Normalization Finally, we have reached a point where our understanding (read: syntactic and semantic analysis) of the input query is complete enough to plan its execution on the underlying DBMS. What we need now is a mapping from MCC to the primitives of the query engine. These primitives (operators) may usually be connected in a tree-like fashion to form a query execution plan: Õ Å Ã 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 115

3 We will, of course, aim to assemble execution plans which 1 contain the minimal number of necessary operators ; this will reduce the need to allocate and manage intermediate query results, thus making the overall I/O costs cheaper; 2 use those operators whose internal workings are simple and thus are efficiently executable; this will help to reduce CPU as well as I/O costs (consider the need for temporary storage during operator execution, e.g., sorting). 3 adhere to specific tree shapes: left-deep right-deep bushy (but we will postpone a discussion of this right now.) 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 116

4 For a first approach to find such a mapping from MCC to query plans, we can fall back on the ÓÐ-based MCC semantics (see Chapter 2): We need a single type of -operator implemented in our query engine, namely ÓÐ; equations (1) through (3) of Section 2.3 provide the mapping from MCC to execution plans; 4.1 Comprehension Normalization SQL ÃMCC ÃÓÐ provides a complete query processor framework for SQL. Unfortunately, ÓÐ s internal workings are not simple in the sense of our previous discussion. Each instance of ÓÐ we can get rid of in a query plan is worth to search for T. Grust Database Languages and their Compilers: 4. Query Normalization 117

5 ½ Ê ÙÑ ½ Ê ÙÑ MCC provides a number of hooks to simplify its expressions while their meaning is preserved: From a bird s eye point of view, the overall structure of a comprehension computing an SQL SUM-aggregate query is (see cases (g) and (h) of mapping Ì): Claim: Irrespective of, this computes the same value as The second comprehension saves a ÓÐ. A comparison of the ÓÐ corresponding programs for both comprehensions justifies this equivalence-preserving simplification step T. Grust Database Languages and their Compilers: 4. Query Normalization 118

6 Õ Ú ¼ Õ ¼ Å ¼ Õ ¼¼ Å Õ Õ ¼ Ú ¼ Õ ¼¼ Å remove ½ Ê ÙÑ ÙÑ This simplification step is an instantiation of a far more general rewriting that MCC allows us to do: Comprehension Unnesting (Å Å ¼ in general): The comprehension on the right hand side uses one generator ( ) less. The unnesting rule implements the simplification procedure of the previous slide: ßÞÐ Õ ½ Ê ßÞÐ ¼¼ Õ unnest ½ Ê ÙÑ 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 119

7 Nested SQL queries of the form shown here may lead to inefficient query execution plans: Let Ô Ô ¼ denote two SQL predicates: SELECT DISTINCT Ü Õ FROM Ü AS WHERE EXISTS Þ IN ¼ Ý SELECT FROM Ý AS Ô Ü Ýµ WHERE ½ Ô ¼ Ü Þµ ßÞ Ð subquery Note that the nested subquery is correlated: Ô Ü Ýµ depends on tuple variable Ü bound in the outer query; consequently, we have to re-evaluate the subquery for every binding of Ü; it looks like we have to read times T. Grust Database Languages and their Compilers: 4. Query Normalization 120

8 Ì Õ ¼ Õ ¼ ÓÑ Õ ¼¼ Ø Õ Õ ¼ ¼ Õ ¼¼ Ø Ü Üµ Ü Ô ¼ Ü Þµ Þ Ý Ýµ Ý Ô Ü Ýµ ÓÑ Ø We can improve the situation with the help of a new MCC rewriting rule: Unnesting of Existential Quantification: N.B.: Unnesting of existential quantifiers is valid only inside a Ø comprehension. This is applicable to Õ after we have switched to MCC with the help of Ì: Ì Õµ unnest Ü Üµ Ü Ô ¼ Ü Þµ Ý Ô Ü Ýµ Þ Ý Ýµ ÓÑ Ø remove Ü Üµ Ü Ô ¼ Ü Ý Ýµµ Ý Ô Ü Ýµ ÓÑ Ø ÓÑ unnest Ü Üµ Ü Ý Ô ¼ Ü Ý Ýµµ Ô Ü Ýµ Ø 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 121

9 If we Ì apply to the rewriting results, we now see that Õ is nothing else but a join ½ between and : SELECT Ü DISTINCT FROM Ü AS AS Ý WHERE Ô ¼ Ü Ý Ýµµ AND Ô Ü Ýµ DBMS query engines can cope with queries of this type much more efficiently (various join algorithms are applicable now). Correlation matters. If we replace Ô Ü Ýµ by Ô Ýµ in the original query Õ, can you take advantage of this modification? How about replacing Ô Ü Ýµ by Ô Üµ? 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 122

10 In company with two additional laws, the repeated and exhaustive application of the unnesting rules rewrites a comprehension into its normal form:! Comprehension Normalization: Õ Ú ¼ Õ ¼ Å ¼ Õ ¼¼ Å Õ Õ ¼ Ú ¼ Õ ¼¼ (4) Å Õ ¼ Õ ¼ ÓÑ Õ ¼¼ Ø Õ Õ ¼ ¼ Õ ¼¼ (5) Ø Õ Ú ÐØ Å ¼ ¼ µ Õ ¼ Å Õ Ú ¼ Õ ¼ (6) Å Õ Ú ¼ Þ Å Õ ¼ Å Þ (7) Å 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 123

11 4.2 Further Rewriting Laws The expressions of MCC are subject to a large number of additional equivalence-preserving rewritings and simplifications. If some of these rules appear to be too obvious, recall that we are trying to implement a completely unguided system so that we have to declare even the most simple facts; rewriting opportunities might occur due to the application of (a number of) other rewriting laws Constant Folding ÓÒ Ø ½ ÓÒ Ø ÓÒ Ø Ã ÓÒ Ø ÓÒ Ø Ã Ã ½ ¾ ½ ¾ ¾ ½ ¾ 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 124

12 Note that the rewriting laws are directed ( Ãinstead of ) to avoid infinite rewriting loops. The first two rules aim to construct a normal form of arithmetic expressions in which numeric constants appear left-most, e.g.: ½¼ ¼µ ¼µ ¾µ ܵ ݵ Þ three applications of the last law finally produce ¾ ܵ ݵ Þ. Some more examples: ÓÒ Ø Ð Ã ÓÒ Ø Ã ÓÒ Ø Ã ØÖÙ Ð ØÖÙ Ð ½ ½ ÐÒ Ò These laws, in turn, may then make the following applicable: Õ ØÖÙ Õ ¼ Å Ã Õ Õ ¼ Å Õ Ð Õ ¼ Å ÃÞ Å 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 125

13 4.2.2 Reordering the Qualifier List For a Õ comprehension, the order of qualifiers in Õ obviously makes a Å difference: moving a predicate towards the beginning of Õ allows to evaluate filters early; moving generators inside Õ may lead to interesting join orders (later) T. Grust Database Languages and their Compilers: 4. Query Normalization 126

14 Ô Õ Å Ô Õ Å ¼ Õ Ô Å Õ Ô Å 1 Exchanging predicates: To see that two adjacent predicates Ô Õ in a qualifier list may be transposed, note that See Section 2.3 (rule (3)) and use the equivalence if Ô then if Õ then else else ¼ Ô Õ if then else. ¼ Finally: Ô Õ Å Ô Õ Å commutative 2010 T. Grust Database Languages and their Compilers: 4. Query Normalization 127

15 Ô Ú ¼ Å Ú ¼ Å 2 Moving generators: Generators introduce variables, so we have to be careful not to move expressions out of scope and to avoid name capture. (a) Transposing a generator and a (Ô predicate may not reference Ú): Ú ¼ Ô Å (b) Transposing two generators ( ¼ may not reference Ú ¼, ¼¼ may not reference Ú, Å ¾ Ø ): Ú Ú ¼ Ú ¼ ¼¼ Å Ú ¼ ¼¼ Ú Ú ¼ ¼ N.B.: These laws are specified for pairs of qualifiers but they can be easily lifted onto sequences of qualifiers of length ¾ T. Grust Database Languages and their Compilers: 4. Query Normalization 128

16 Contents 0 Introduction to Query Compilation Welcome! Administrativa Some Remarks on these Slides Relational Databases and SQL A Guided Tour through an SQL Query Processor Character Streams and Tokens Identify Valid SQL Syntax Resolve the Meaning of Variables and Identifiers Check Types and Schemas T. Grust Database Languages and their Compilers: 4. Query Normalization 129

17 0.5.5 How Could Query Evaluation Look Like? One Query, Many Programs Query Operators Query Operator Trees and Rewriting The Cheaper, the Better: Query Cost Models Executing Operator Trees on a Machine Recommended Reading Query Parsing The Scanner (Lexer) Regular Expressions Regular Expressions for SQL lex A Scanner Generator T. Grust Database Languages and their Compilers: 4. Query Normalization 130

18 1.2 Syntax Analysis (Parsing) Context-Free Grammars Derivations and Parse Trees Ambiguous Grammars Predictive Parsing and Recursive Descent yacc A Parser Generator Recommended Reading A Query Calculus for SQL SQL s Nested Loops Semantics ÓÐ The Monoid Comprehension Calculus Mapping SQL to MCC T. Grust Database Languages and their Compilers: 4. Query Normalization 131

19 2.4.1 Applying Ì to Translate SQL Queries Recommended Reading Variable Scopes and Type Inference for SQL Variables in SQL Variable Environments The Type of an SQL Query Type Inference Semantic Attributes Query Normalization Comprehension Normalization Further Rewriting Laws Constant Folding T. Grust Database Languages and their Compilers: 4. Query Normalization 132

20 4.2.2 Reordering the Qualifier List T. Grust Database Languages and their Compilers: 4. Query Normalization 133