Arel::SqlCompiler::GenericCompiler

   # File lib/arel/engines/sql/relations/compiler.rb, line 6
6:       def initialize(relation)
7:         @relation = relation
8:         @engine = relation.engine
9:       end

    # File lib/arel/engines/sql/relations/compiler.rb, line 65
65:       def add_limit_on_delete(taken)
66:         "LIMIT #{taken}"
67:       end

    # File lib/arel/engines/sql/relations/compiler.rb, line 33
33:       def build_clauses
34:         joins   = relation.joins(self)
35:         wheres  = relation.where_clauses
36:         groups  = relation.group_clauses
37:         havings = relation.having_clauses
38:         orders  = relation.order_clauses
39: 
40:         clauses = [ "",
41:           joins,
42:           ("WHERE     #{wheres.join(' AND ')}" unless wheres.empty?),
43:           ("GROUP BY  #{groups.join(', ')}" unless groups.empty?),
44:           ("HAVING    #{havings.join(' AND ')}" unless havings.empty?),
45:           ("ORDER BY  #{orders.join(', ')}" unless orders.empty?)
46:         ].compact.join ' '
47: 
48:         offset = relation.skipped
49:         limit = relation.taken
50:         @engine.connection.add_limit_offset!(clauses, :limit => limit,
51:                                   :offset => offset) if offset || limit
52: 
53:         clauses << " #{locked}" unless locked.blank?
54:         clauses unless clauses.blank?
55:       end

    # File lib/arel/engines/sql/relations/compiler.rb, line 11
11:       def christener
12:         relation.christener
13:       end

    # File lib/arel/engines/sql/relations/compiler.rb, line 57
57:       def delete_sql
58:         build_query            "DELETE",
59:           "FROM #{relation.table_sql}",
60:           ("WHERE #{relation.wheres.collect { |x| x.to_sql }.join(' AND ')}" unless relation.wheres.blank? ),
61:           (add_limit_on_delete(relation.taken)                        unless relation.taken.blank?  )
62:       end

    # File lib/arel/engines/sql/relations/compiler.rb, line 69
69:       def insert_sql(include_returning = true)
70:         insertion_attributes_values_sql = if relation.record.is_a?(Value)
71:           relation.record.value
72:         else
73:           attributes = relation.record.keys.sort_by do |attribute|
74:             attribute.name.to_s
75:           end
76: 
77:           first = attributes.collect do |key|
78:             @engine.connection.quote_column_name(key.name)
79:           end.join(', ')
80: 
81:           second = attributes.collect do |key|
82:             key.format(relation.record[key])
83:           end.join(', ')
84: 
85:           build_query "(#{first})", "VALUES (#{second})"
86:         end
87: 
88:         build_query            "INSERT",
89:           "INTO #{relation.table_sql}",
90:           insertion_attributes_values_sql,
91:           ("RETURNING #{engine.connection.quote_column_name(relation.primary_key)}" if include_returning && relation.compiler.supports_insert_with_returning?)
92:       end

    # File lib/arel/engines/sql/relations/compiler.rb, line 15
15:       def select_sql
16:         projections = @relation.projections
17:         if Count === projections.first && projections.size == 1 &&
18:           (relation.taken.present? || relation.wheres.present?) && relation.joins(self).blank?
19:           subquery = [
20:             "SELECT 1 FROM #{relation.from_clauses}", build_clauses
21:           ].join ' '
22:           query = "SELECT COUNT(*) AS count_id FROM (#{subquery}) AS subquery"
23:         else
24:           query = [
25:             "SELECT     #{relation.select_clauses.join(', ')}",
26:             "FROM       #{relation.from_clauses}",
27:             build_clauses
28:           ].compact.join ' '
29:         end
30:         query
31:       end

    # File lib/arel/engines/sql/relations/compiler.rb, line 95
95:       def supports_insert_with_returning?
96:         false
97:       end

     # File lib/arel/engines/sql/relations/compiler.rb, line 99
 99:       def update_sql
100:         build_query            "UPDATE #{relation.table_sql} SET",
101:           assignment_sql,
102:           build_update_conditions_sql
103:       end

     # File lib/arel/engines/sql/relations/compiler.rb, line 116
116:       def assignment_sql
117:         if relation.assignments.respond_to?(:collect)
118:           attributes = relation.assignments.keys.sort_by do |attribute|
119:             attribute.name.to_s
120:           end
121: 
122:           attributes.map do |attribute|
123:             value = relation.assignments[attribute]
124:             "#{@engine.connection.quote_column_name(attribute.name)} = #{attribute.format(value)}"
125:           end.join(", ")
126:         else
127:           relation.assignments.value
128:         end
129:       end

     # File lib/arel/engines/sql/relations/compiler.rb, line 112
112:       def build_query(*parts)
113:         parts.compact.join(" ")
114:       end

     # File lib/arel/engines/sql/relations/compiler.rb, line 131
131:       def build_update_conditions_sql
132:         conditions = ""
133:         conditions << " WHERE #{relation.wheres.map { |x| x.to_sql }.join(' AND ')}" unless relation.wheres.blank?
134:         conditions << " ORDER BY #{relation.order_clauses.join(', ')}" unless relation.orders.blank?
135: 
136:         taken = relation.taken
137:         unless taken.blank?
138:           conditions = limited_update_conditions(conditions, taken)
139:         end
140: 
141:         conditions
142:       end

     # File lib/arel/engines/sql/relations/compiler.rb, line 144
144:       def limited_update_conditions(conditions, taken)
145:         conditions << " LIMIT #{taken}"
146:         quoted_primary_key = @engine.connection.quote_column_name(relation.primary_key)
147:         "WHERE #{quoted_primary_key} IN (SELECT #{quoted_primary_key} FROM #{@engine.connection.quote_table_name relation.table.name} #{conditions})"
148:       end

     # File lib/arel/engines/sql/relations/compiler.rb, line 108
108:       def locked
109:         relation.locked
110:       end