From 10227d1ae7a5b32039f8f6c2116e0c45251df2bc Mon Sep 17 00:00:00 2001 From: LtWorf Date: Tue, 26 May 2009 14:00:44 +0000 Subject: [PATCH] Cleaned up code git-svn-id: http://galileo.dmi.unict.it/svn/relational/trunk@184 014f5005-505e-4b48-8d0a-63407b615a7c --- relational/optimizations.py | 102 ++++++------------------------------ relational/optimizer.py | 2 +- 2 files changed, 18 insertions(+), 86 deletions(-) diff --git a/relational/optimizations.py b/relational/optimizations.py index 4866a72..6b8353a 100644 --- a/relational/optimizations.py +++ b/relational/optimizations.py @@ -46,6 +46,7 @@ def replace_node(replace,replacement): replace.left=replacement.left def recoursive_scan(function,node,rels=None): + '''Does a recoursive optimization on the tree''' changes=0 #recoursive scan if node.kind==optimizer.UNARY: @@ -53,7 +54,7 @@ def recoursive_scan(function,node,rels=None): changes+=function(node.child,rels) else: changes+=function(node.child) - elif n.kind==optimizer.BINARY: + elif node.kind==optimizer.BINARY: if rels!=None: changes+=function(node.right,rels) changes+=function(node.left,rels) @@ -74,14 +75,7 @@ def duplicated_select(n): changes=1 changes+=duplicated_select(n) - - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=duplicated_select(n.child) - elif n.kind==optimizer.BINARY: - changes+=duplicated_select(n.right) - changes+=duplicated_select(n.left) - return changes + return changes+recoursive_scan(duplicated_select,n) def futile_union_intersection_subtraction(n): '''This function locates things like r ᑌ r, and replaces them with r. @@ -115,14 +109,7 @@ def futile_union_intersection_subtraction(n): n.child=n.left #n.left=n.right=None - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=futile_union_intersection_subtraction(n.child) - elif n.kind==optimizer.BINARY: - changes+=futile_union_intersection_subtraction(n.right) - changes+=futile_union_intersection_subtraction(n.left) - return changes - + return changes+recoursive_scan(futile_union_intersection_subtraction,n) def down_to_unions_subtractions_intersections(n): '''This funcion locates things like σ i==2 (c ᑌ d), where the union @@ -152,31 +139,18 @@ def down_to_unions_subtractions_intersections(n): n.kind=optimizer.BINARY changes+=1 - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=down_to_unions_subtractions_intersections(n.child) - elif n.kind==optimizer.BINARY: - changes+=down_to_unions_subtractions_intersections(n.right) - changes+=down_to_unions_subtractions_intersections(n.left) - return changes + return changes+recoursive_scan(down_to_unions_subtractions_intersections,n) def duplicated_projection(n): '''This function locates thing like π i ( π j (R)) and replaces them with π i (R)''' changes=0 - - + if n.name=='π' and n.child.name=='π': n.child=n.child.child changes+=1 - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=duplicated_projection(n.child) - elif n.kind==optimizer.BINARY: - changes+=duplicated_projection(n.right) - changes+=duplicated_projection(n.left) - return changes + return changes+recoursive_scan(duplicated_projection,n) def selection_inside_projection(n): '''This function locates things like σ j (π k(R)) and @@ -191,13 +165,7 @@ def selection_inside_projection(n): n.name='π' n.child.name='σ' - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=selection_inside_projection(n.child) - elif n.kind==optimizer.BINARY: - changes+=selection_inside_projection(n.right) - changes+=selection_inside_projection(n.left) - return changes + return changes+recoursive_scan(selection_inside_projection,n) def swap_union_renames(n): '''This function locates things like @@ -235,15 +203,7 @@ def swap_union_renames(n): n.prop=n.left.prop n.left=n.right=None - - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=swap_union_renames(n.child) - elif n.kind==optimizer.BINARY: - changes+=swap_union_renames(n.right) - changes+=swap_union_renames(n.left) - return changes - + return changes+recoursive_scan(swap_union_renames,n) def futile_renames(n): '''This function purges renames like id->id''' @@ -276,13 +236,8 @@ def futile_renames(n): if len(n.prop)==0: #Nothing to rename, removing the rename op replace_node(n,n.child) - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=futile_renames(n.child) - elif n.kind==optimizer.BINARY: - changes+=futile_renames(n.right) - changes+=futile_renames(n.left) - return changes + + return changes+recoursive_scan(futile_renames,n) def subsequent_renames(n): '''This function removes redoundant subsequent renames joining them into one''' @@ -330,13 +285,7 @@ def subsequent_renames(n): if len(n.prop)==0: #Nothing to rename, removing the rename op replace_node(n,n.child) - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=subsequent_renames(n.child) - elif n.kind==optimizer.BINARY: - changes+=subsequent_renames(n.right) - changes+=subsequent_renames(n.left) - return changes + return changes+recoursive_scan(subsequent_renames,n) def tokenize_select(expression): '''This function returns the list of tokens present in a @@ -420,13 +369,8 @@ def swap_rename_projection(n): n.child.prop+=i+',' n.child.prop=n.child.prop[:-1] - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=swap_rename_projection(n.child) - elif n.kind==optimizer.BINARY: - changes+=swap_rename_projection(n.right) - changes+=swap_rename_projection(n.left) - return changes + + return changes+recoursive_scan(swap_rename_projection,n) def swap_rename_select(n): '''This function locates things like σ k(ρ j(R)) and replaces @@ -462,14 +406,8 @@ def swap_rename_select(n): n.child.prop='' for i in _tokens: n.child.prop+=i+ ' ' - - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=swap_rename_select(n.child) - elif n.kind==optimizer.BINARY: - changes+=swap_rename_select(n.right) - changes+=swap_rename_select(n.left) - return changes + + return changes+recoursive_scan(swap_rename_select,n) def selection_and_product(n,rels): '''This function locates things like σ k (R*Q) and converts them into @@ -564,13 +502,7 @@ def selection_and_product(n,rels): else:#No need for general select replace_node(n,n.child) - #recoursive scan - if n.kind==optimizer.UNARY: - changes+=selection_and_product(n.child,rels) - elif n.kind==optimizer.BINARY: - changes+=selection_and_product(n.right,rels) - changes+=selection_and_product(n.left,rels) - return changes + return changes+recoursive_scan(selection_and_product,n,rels) general_optimizations=[duplicated_select,down_to_unions_subtractions_intersections,duplicated_projection,selection_inside_projection,subsequent_renames,swap_rename_select,futile_union_intersection_subtraction,swap_union_renames,swap_rename_projection] specific_optimizations=[selection_and_product] diff --git a/relational/optimizer.py b/relational/optimizer.py index 3c74e73..d519a2b 100644 --- a/relational/optimizer.py +++ b/relational/optimizer.py @@ -286,7 +286,7 @@ if __name__=="__main__": '''σ k (r) ᑌ r with r σ k (r) ᑎ r with σ k (r)''' - a=general_optimize('σ k (r) ᑎ r') + a=general_optimize('π indice,qq,name (ρ age➡qq,id➡indice (P1-P2))') #a=general_optimize("σ i==2 (σ b>5 (d))") print a #print node(a)