Class: Alf::Sql::Compiler

Inherits:
Compiler
  • Object
show all
Defined in:
lib/alf/sql/compiler.rb

Instance Method Summary collapse

Instance Method Details

#compile(plan, expr, compiled, usage_count) ⇒ Object 



17
18
19
20
21
22
23
 
# File 'lib/alf/sql/compiler.rb', line 17

def compile(plan, expr, compiled, usage_count)
  cog = super
  if (usage_count > 1) and cog.should_be_reused?
    cog = rewrite(plan, cog.expr, cog, Processor::FromSelf, [])
  end
  cog
end

#join(plan) ⇒ Object 



5
6
7
 
# File 'lib/alf/sql/compiler.rb', line 5

def join(plan)
  Builder.new
end

#on_clip(plan, expr, compiled) ⇒ Object

non-relational



33
34
35
 
# File 'lib/alf/sql/compiler.rb', line 33

def on_clip(plan, expr, compiled)
  rewrite(plan, expr, compiled, Processor::Clip, [expr.attributes, :is_table_dee])
end

#on_frame(plan, expr, compiled) ⇒ Object

relational



47
48
49
50
51
52
 
# File 'lib/alf/sql/compiler.rb', line 47

def on_frame(plan, expr, compiled)
  compiled = plan.recompile(compiled){|p|
    p.sort(expr.operand, expr.total_ordering)
  }
  rewrite(plan, expr, compiled, Processor::LimitOffset, [expr.limit, expr.offset])
end

#on_intersect(plan, expr, left, right) ⇒ Object 



54
55
56
 
# File 'lib/alf/sql/compiler.rb', line 54

def on_intersect(plan, expr, left, right)
  rewrite(plan, expr, left, Processor::Merge, [:intersect, right.sexpr])
end

#on_join(plan, expr, left, right) ⇒ Object 



58
59
60
61
62
63
64
65
66
 
# File 'lib/alf/sql/compiler.rb', line 58

def on_join(plan, expr, left, right)
  if right.sexpr.is_table_dee?
    rewrite(plan, expr, left, Processor::SemiJoin, [right.sexpr, false])
  elsif left.sexpr.is_table_dee?
    rewrite(plan, expr, right, Processor::SemiJoin, [left.sexpr, false])
  else
    rewrite(plan, expr, left, Processor::Join, [right.sexpr])
  end
end

#on_leaf_operand(plan, expr) ⇒ Object

base



27
28
29
 
# File 'lib/alf/sql/compiler.rb', line 27

def on_leaf_operand(plan, expr)
  fresh_cog(expr, builder(plan).select_all(expr.heading, expr.name))
end

#on_matching(plan, expr, left, right) ⇒ Object 



68
69
70
 
# File 'lib/alf/sql/compiler.rb', line 68

def on_matching(plan, expr, left, right)
  rewrite(plan, expr, left, Processor::SemiJoin, [right.sexpr, false])
end

#on_minus(plan, expr, left, right) ⇒ Object 



72
73
74
 
# File 'lib/alf/sql/compiler.rb', line 72

def on_minus(plan, expr, left, right)
  rewrite(plan, expr, left, Processor::Merge, [:except, right.sexpr])
end

#on_not_matching(plan, expr, left, right) ⇒ Object 



76
77
78
 
# File 'lib/alf/sql/compiler.rb', line 76

def on_not_matching(plan, expr, left, right)
  rewrite(plan, expr, left, Processor::SemiJoin, [right.sexpr, true])
end

#on_page(plan, expr, compiled) ⇒ Object 



80
81
82
83
84
85
86
87
88
 
# File 'lib/alf/sql/compiler.rb', line 80

def on_page(plan, expr, compiled)
  index, size = expr.page_index, expr.page_size
  compiled = plan.recompile(compiled){|p|
    ordering = expr.total_ordering
    ordering = ordering.reverse if index < 0
    p.sort(expr.operand, ordering)
  }
  rewrite(plan, expr, compiled, Processor::LimitOffset, [size, (index.abs - 1) * size])
end

#on_project(plan, expr, compiled) ⇒ Object 



90
91
92
93
94
95
96
97
98
99
 
# File 'lib/alf/sql/compiler.rb', line 90

def on_project(plan, expr, compiled)
  compiled = plan.recompile(compiled){|p|
    p.clip(expr.operand, expr.stay_attributes)
  }
  preserving = expr.key_preserving? rescue false
  if not(preserving) and not(expr.stay_attributes.empty?)
    compiled = rewrite(plan, expr, compiled, Processor::Distinct)
  end
  rebind(plan, expr, compiled)
end

#on_rename(plan, expr, compiled) ⇒ Object 



101
102
103
 
# File 'lib/alf/sql/compiler.rb', line 101

def on_rename(plan, expr, compiled)
  rewrite(plan, expr, compiled, Processor::Rename, [expr.renaming])
end

#on_restrict(plan, expr, compiled) ⇒ Object 



105
106
107
 
# File 'lib/alf/sql/compiler.rb', line 105

def on_restrict(plan, expr, compiled)
  rewrite(plan, expr, compiled, Processor::Where, [expr.predicate])
end

#on_sort(plan, expr, compiled) ⇒ Object 



37
38
39
40
41
42
43
 
# File 'lib/alf/sql/compiler.rb', line 37

def on_sort(plan, expr, compiled)
  if compiled.orderedby?(expr.ordering)
    rebind(plan, expr, compiled)
  else
    rewrite(plan, expr, compiled, Processor::OrderBy, [expr.ordering])
  end
end

#on_union(plan, expr, left, right) ⇒ Object

def on_summarize(plan, expr, compiled)

# -> SQL's GROUP-BY

end



113
114
115
 
# File 'lib/alf/sql/compiler.rb', line 113

def on_union(plan, expr, left, right)
  rewrite(plan, expr, left, Processor::Merge, [:union, right.sexpr])
end

#reuse(plan, cog) ⇒ Object 



13
14
15
 
# File 'lib/alf/sql/compiler.rb', line 13

def reuse(plan, cog)
  rewrite(plan, cog.expr, cog, Processor::Requalify, [])
end

#supports_reuse? ⇒ Boolean

Returns:

  • (Boolean) 


9
10
11
 
# File 'lib/alf/sql/compiler.rb', line 9

def supports_reuse?
  true
end