Class: Alf::Sql::Builder

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

Constant Summary collapse

DISTINCT = 
Grammar.sexpr([:set_quantifier, "distinct"])
ALL = 
Grammar.sexpr([:set_quantifier, "all"])
IS_TABLE_DEE = 
Grammar.sexpr([:select_list,
                                     [:select_item,
[:literal, true],
[:column_name, "is_table_dee"]]])
SELECT_STAR = 
Grammar.sexpr([:select_star])

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(start = 0) ⇒ Builder

Returns a new instance of Builder.



20
21
22
 
# File 'lib/alf/sql/builder.rb', line 20

def initialize(start = 0)
  @next_qualifier = (start || 0)
end

Class Method Details

.builder(meth) ⇒ Object 



13
14
15
16
17
18
 
# File 'lib/alf/sql/builder.rb', line 13

def self.builder(meth)
  old = instance_method(meth)
  define_method(meth) do |*args, &bl|
    Grammar.sexpr(old.bind(self).call(*args, &bl))
  end
end

Instance Method Details

#all ⇒ Object 



29
30
31
 
# File 'lib/alf/sql/builder.rb', line 29

def all
  ALL
end

#column_name(name) ⇒ Object 



104
105
106
 
# File 'lib/alf/sql/builder.rb', line 104

def column_name(name)
  [:column_name, name]
end

#distinct ⇒ Object 



24
25
26
 
# File 'lib/alf/sql/builder.rb', line 24

def distinct
  DISTINCT
end

#exists(subquery) ⇒ Object 



114
115
116
 
# File 'lib/alf/sql/builder.rb', line 114

def exists(subquery)
  Predicate::Grammar.sexpr [ :exists, subquery ]
end

#from_clause(table_name, qualifier) ⇒ Object 



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

def from_clause(table_name, qualifier)
  [:from_clause,
    table_as(table_name, qualifier) ]
end

#from_self(sexpr) ⇒ Object 



140
141
142
 
# File 'lib/alf/sql/builder.rb', line 140

def from_self(sexpr)
  Processor::FromSelf.new(self).call(sexpr)
end

#is_table_dee ⇒ Object 



52
53
54
 
# File 'lib/alf/sql/builder.rb', line 52

def is_table_dee
  IS_TABLE_DEE
end

#limit_clause(limit) ⇒ Object 



130
131
132
 
# File 'lib/alf/sql/builder.rb', line 130

def limit_clause(limit)
  [:limit_clause, limit]
end

#name_intro(name, sexpr) ⇒ Object 



34
35
36
 
# File 'lib/alf/sql/builder.rb', line 34

def name_intro(name, sexpr)
  [:name_intro, table_name(name), sexpr]
end

#next_qualifier! ⇒ Object 



146
147
148
 
# File 'lib/alf/sql/builder.rb', line 146

def next_qualifier!
  "t#{@next_qualifier += 1}"
end

#offset_clause(limit) ⇒ Object 



135
136
137
 
# File 'lib/alf/sql/builder.rb', line 135

def offset_clause(limit)
  [:offset_clause, limit]
end

#order_by_clause(ordering, &desaliaser) ⇒ Object 



118
119
120
121
122
123
124
125
126
127
 
# File 'lib/alf/sql/builder.rb', line 118

def order_by_clause(ordering, &desaliaser)
  ordering.to_a.map{|(s,d)|
    if s.composite?
      raise NotSupportedError, "SQL order by does not support composite selectors"
    end
    name = s.outcoerce.to_s
    name = (desaliaser && desaliaser[name]) || column_name(name)
    [:order_by_term, name, d.to_s]
  }.unshift(:order_by_clause)
end

#qualified_name(qualifier, name) ⇒ Object 



92
93
94
95
96
 
# File 'lib/alf/sql/builder.rb', line 92

def qualified_name(qualifier, name)
  [:qualified_name,
    range_var_name(qualifier),
    column_name(name) ]
end

#range_var_name(qualifier) ⇒ Object 



99
100
101
 
# File 'lib/alf/sql/builder.rb', line 99

def range_var_name(qualifier)
  [:range_var_name, qualifier]
end

#select_all(heading, name, qualifier = next_qualifier!) ) ⇒ Object 



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

def select_all(heading, name, qualifier = next_qualifier!)
  [ :select_exp, all,
    select_list(heading, qualifier),
    from_clause(name, qualifier) ]
end

#select_is_table_dee(subquery) ⇒ Object 



46
47
48
49
 
# File 'lib/alf/sql/builder.rb', line 46

def select_is_table_dee(subquery)
  [ :select_exp, all, is_table_dee,
    [:where_clause, exists(subquery)] ]
end

#select_item(qualifier, name, as = name) ⇒ Object 



63
64
65
66
67
 
# File 'lib/alf/sql/builder.rb', line 63

def select_item(qualifier, name, as = name)
  [:select_item,
    qualified_name(qualifier, name.to_s),
    column_name(as.to_s)]
end

#select_list(heading, qualifier) ⇒ Object 



57
58
59
60
 
# File 'lib/alf/sql/builder.rb', line 57

def select_list(heading, qualifier)
  attrs = heading.to_attr_list.to_a
  attrs.map{|a| select_item(qualifier, a) }.unshift(:select_list)
end

#select_star ⇒ Object 



70
71
72
 
# File 'lib/alf/sql/builder.rb', line 70

def select_star
  SELECT_STAR
end

#table_as(table, qualifier) ⇒ Object 



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

def table_as(table, qualifier)
  table = case table
          when String, Symbol then table_name(table)
          else table
          end
  [:table_as,
    table,
    range_var_name(qualifier) ]
end

#table_name(name) ⇒ Object 



109
110
111
 
# File 'lib/alf/sql/builder.rb', line 109

def table_name(name)
  [:table_name, name]
end