ActiveRecord::QueryMethods

     # File lib/active_record/relation/query_methods.rb, line 149
149:     def arel
150:       @arel ||= build_arel
151:     end

     # File lib/active_record/relation/query_methods.rb, line 174
174:     def build_arel
175:       arel = table
176: 
177:       arel = build_joins(arel, @joins_values) unless @joins_values.empty?
178: 
179:       (@where_values - ['']).uniq.each do |where|
180:         where = Arel.sql(where) if String === where
181:         arel = arel.where(Arel::Nodes::Grouping.new(where))
182:       end
183: 
184:       arel = arel.having(*@having_values.uniq.reject{|h| h.blank?}) unless @having_values.empty?
185: 
186:       arel = arel.take(@limit_value) if @limit_value
187:       arel = arel.skip(@offset_value) if @offset_value
188: 
189:       arel = arel.group(*@group_values.uniq.reject{|g| g.blank?}) unless @group_values.empty?
190: 
191:       arel = arel.order(*@order_values.uniq.reject{|o| o.blank?}) unless @order_values.empty?
192: 
193:       arel = build_select(arel, @select_values.uniq)
194: 
195:       arel = arel.from(@from_value) if @from_value
196:       arel = arel.lock(@lock_value) if @lock_value
197: 
198:       arel
199:     end

     # File lib/active_record/relation/query_methods.rb, line 118
118:     def create_with(value)
119:       relation = clone
120:       relation.create_with_value = value
121:       relation
122:     end

     # File lib/active_record/relation/query_methods.rb, line 153
153:     def custom_join_sql(*joins)
154:       arel = table.select_manager
155: 
156:       joins.each do |join|
157:         next if join.blank?
158: 
159:         @implicit_readonly = true
160: 
161:         case join
162:         when Array
163:           join = Arel.sql(join.join(' ')) if array_of_strings?(join)
164:         when String
165:           join = Arel.sql(join)
166:         end
167: 
168:         arel.join(join)
169:       end
170: 
171:       arel.joins(arel)
172:     end

    # File lib/active_record/relation/query_methods.rb, line 22
22:     def eager_load(*args)
23:       relation = clone
24:       relation.eager_load_values += args unless args.blank?
25:       relation
26:     end

     # File lib/active_record/relation/query_methods.rb, line 130
130:     def extending(*modules, &block)
131:       modules << Module.new(&block) if block_given?
132: 
133:       relation = clone
134:       relation.send(:apply_modules, modules.flatten)
135:       relation
136:     end

     # File lib/active_record/relation/query_methods.rb, line 124
124:     def from(value)
125:       relation = clone
126:       relation.from_value = value
127:       relation
128:     end

    # File lib/active_record/relation/query_methods.rb, line 44
44:     def group(*args)
45:       relation = clone
46:       relation.group_values += args.flatten unless args.blank?
47:       relation
48:     end

    # File lib/active_record/relation/query_methods.rb, line 81
81:     def having(*args)
82:       relation = clone
83:       relation.having_values += build_where(*args) unless args.blank?
84:       relation
85:     end

    # File lib/active_record/relation/query_methods.rb, line 12
12:     def includes(*args)
13:       args.reject! {|a| a.blank? }
14: 
15:       return clone if args.empty?
16: 
17:       relation = clone
18:       relation.includes_values = (relation.includes_values + args).flatten.uniq
19:       relation
20:     end

    # File lib/active_record/relation/query_methods.rb, line 66
66:     def joins(*args)
67:       relation = clone
68: 
69:       args.flatten!
70:       relation.joins_values += args unless args.blank?
71: 
72:       relation
73:     end

    # File lib/active_record/relation/query_methods.rb, line 87
87:     def limit(value)
88:       relation = clone
89:       relation.limit_value = value
90:       relation
91:     end

     # File lib/active_record/relation/query_methods.rb, line 99
 99:     def lock(locks = true)
100:       relation = clone
101: 
102:       case locks
103:       when String, TrueClass, NilClass
104:         relation.lock_value = locks || true
105:       else
106:         relation.lock_value = false
107:       end
108: 
109:       relation
110:     end

    # File lib/active_record/relation/query_methods.rb, line 93
93:     def offset(value)
94:       relation = clone
95:       relation.offset_value = value
96:       relation
97:     end

    # File lib/active_record/relation/query_methods.rb, line 50
50:     def order(*args)
51:       relation = clone
52:       relation.order_values += args.flatten unless args.blank?
53:       relation
54:     end

    # File lib/active_record/relation/query_methods.rb, line 28
28:     def preload(*args)
29:       relation = clone
30:       relation.preload_values += args unless args.blank?
31:       relation
32:     end

     # File lib/active_record/relation/query_methods.rb, line 112
112:     def readonly(value = true)
113:       relation = clone
114:       relation.readonly_value = value
115:       relation
116:     end

    # File lib/active_record/relation/query_methods.rb, line 56
56:     def reorder(*args)
57:       ActiveSupport::Deprecation.warn "reorder is deprecated. Please use except(:order).order(...) instead", caller
58:       relation = clone
59:       unless args.blank?
60:         relation.order_values = args
61:         relation.reorder_flag = true
62:       end
63:       relation
64:     end

     # File lib/active_record/relation/query_methods.rb, line 138
138:     def reverse_order
139:       order_clause = arel.order_clauses.join(', ')
140:       relation = except(:order)
141: 
142:       order = order_clause.blank? ?
143:         "#{@klass.table_name}.#{@klass.primary_key} DESC" :
144:         reverse_sql_order(order_clause)
145: 
146:       relation.order(Arel::SqlLiteral.new(order))
147:     end

    # File lib/active_record/relation/query_methods.rb, line 34
34:     def select(value = Proc.new)
35:       if block_given?
36:         to_a.select {|*block_args| value.call(*block_args) }
37:       else
38:         relation = clone
39:         relation.select_values += Array.wrap(value)
40:         relation
41:       end
42:     end

    # File lib/active_record/relation/query_methods.rb, line 75
75:     def where(opts, *rest)
76:       relation = clone
77:       relation.where_values += build_where(opts, rest) unless opts.blank?
78:       relation
79:     end

     # File lib/active_record/relation/query_methods.rb, line 262
262:     def apply_modules(modules)
263:       unless modules.empty?
264:         @extensions += modules
265:         modules.each {|extension| extend(extension) }
266:       end
267:     end

     # File lib/active_record/relation/query_methods.rb, line 281
281:     def array_of_strings?(o)
282:       o.is_a?(Array) && o.all?{|obj| obj.is_a?(String)}
283:     end

     # File lib/active_record/relation/query_methods.rb, line 215
215:     def build_joins(relation, joins)
216:       association_joins = []
217: 
218:       joins = @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
219: 
220:       joins.each do |join|
221:         association_joins << join if [Hash, Array, Symbol].include?(join.class) && !array_of_strings?(join)
222:       end
223: 
224:       stashed_association_joins = joins.grep(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)
225: 
226:       non_association_joins = (joins - association_joins - stashed_association_joins)
227:       custom_joins = custom_join_sql(*non_association_joins)
228: 
229:       join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
230: 
231:       join_dependency.graft(*stashed_association_joins)
232: 
233:       @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
234: 
235:       to_join = []
236: 
237:       join_dependency.join_associations.each do |association|
238:         if (association_relation = association.relation).is_a?(Array)
239:           to_join << [association_relation.first, association.join_type, association.association_join.first]
240:           to_join << [association_relation.last, association.join_type, association.association_join.last]
241:         else
242:           to_join << [association_relation, association.join_type, association.association_join]
243:         end
244:       end
245: 
246:       to_join.uniq.each do |left, join_type, right|
247:         relation = relation.join(left, join_type).on(*right)
248:       end
249: 
250:       relation.join(custom_joins)
251:     end

     # File lib/active_record/relation/query_methods.rb, line 253
253:     def build_select(arel, selects)
254:       unless selects.empty?
255:         @implicit_readonly = false
256:         arel.project(*selects)
257:       else
258:         arel.project(Arel::SqlLiteral.new(@klass.quoted_table_name + '.*'))
259:       end
260:     end

     # File lib/active_record/relation/query_methods.rb, line 203
203:     def build_where(opts, other = [])
204:       case opts
205:       when String, Array
206:         [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
207:       when Hash
208:         attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
209:         PredicateBuilder.new(table.engine).build_from_hash(attributes, table)
210:       else
211:         [opts]
212:       end
213:     end

     # File lib/active_record/relation/query_methods.rb, line 269
269:     def reverse_sql_order(order_query)
270:       order_query.to_s.split(/,/).each { |s|
271:         if s.match(/\s(asc|ASC)$/)
272:           s.gsub!(/\s(asc|ASC)$/, ' DESC')
273:         elsif s.match(/\s(desc|DESC)$/)
274:           s.gsub!(/\s(desc|DESC)$/, ' ASC')
275:         else
276:           s.concat(' DESC')
277:         end
278:       }.join(',')
279:     end