Module: Ansr::QueryMethods

Includes:
ActiveRecord::QueryMethods, Configurable
Included in:
Base, Relation
Defined in:
lib/ansr/relation/query_methods.rb

Instance Method Summary collapse

Methods included from Configurable

#config

Instance Method Details

#all_filter_fields ⇒ Object 



204
205
206
 
# File 'lib/ansr/relation/query_methods.rb', line 204

def all_filter_fields
  FACETS
end

#all_sort_fields ⇒ Object 



208
209
210
 
# File 'lib/ansr/relation/query_methods.rb', line 208

def all_sort_fields
  SORTS
end

#ansr_qeury ⇒ Object 



299
300
301
 
# File 'lib/ansr/relation/query_methods.rb', line 299

def ansr_qeury
  @ansr_query
end

#as(args) ⇒ Object 



104
105
106
 
# File 'lib/ansr/relation/query_methods.rb', line 104

def as(args)
  spawn.as!(args)
end

#as!(args) ⇒ Object 



108
109
110
111
 
# File 'lib/ansr/relation/query_methods.rb', line 108

def as!(args)
  self.as_value= args
  self
end

#as_unscoping(*args) ⇒ Object 



122
123
124
 
# File 'lib/ansr/relation/query_methods.rb', line 122

def as_unscoping(*args)
  @values.delete(:as)
end

#as_value ⇒ Object 



113
114
115
 
# File 'lib/ansr/relation/query_methods.rb', line 113

def as_value
  @values[:as]
end

#as_value=(args) ⇒ Object

Raises:

  • (ActiveRecord::ImmutableRelation) 


117
118
119
120
 
# File 'lib/ansr/relation/query_methods.rb', line 117

def as_value=(args)
  raise ActiveRecord::ImmutableRelation if @loaded
  @values[:as] = args
end

#build_arel ⇒ Object

Could filtering be moved out of intersection into one arel tree?



243
244
245
246
247
248
249
250
251
 
# File 'lib/ansr/relation/query_methods.rb', line 243

def build_arel
  arel = super
  collapse_filters(arel, (filter_values).uniq)
  arel.projections << @values[:spellcheck] if @values[:spellcheck]
  arel.projections << @values[:highlight] if @values[:highlight]
  arel.projections += facet_values
  arel.from arel.create_table_alias(arel.source.left, as_value) if as_value
  arel
end

#build_facets(expr, opts = {}) ⇒ Object

cloning from ActiveRecord::QueryMethods.build_where as a first pass



254
255
256
257
258
259
260
261
262
263
264
265
266
267
 
# File 'lib/ansr/relation/query_methods.rb', line 254

def build_facets(expr, opts={})
  case expr
  when Hash
    build_facets(::Arel.star,expr)
  when Array
    r = expr.inject([]) {|m,e| m.concat build_facets(e,opts)}
  when String, Symbol, Arel::SqlLiteral
    [Ansr::Arel::Nodes::Facet.new(::Arel::Attributes::Attribute.new(table, expr.to_s), opts)]
  when ::Arel::Attributes::Attribute
    [Ansr::Arel::Nodes::Facet.new(expr, opts)]
  else
    [expr]
  end
end

#build_where(opts, other = []) ⇒ Object

cloning from ActiveRecord::QueryMethods.build_where to use our PredicateBuilder



270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
 
# File 'lib/ansr/relation/query_methods.rb', line 270

def build_where(opts, other = [])
  case opts
  when String, Array
    #TODO: Remove duplication with: /activerecord/lib/active_record/sanitization.rb:113
    values = Hash === other.first ? other.first.values : other

    values.grep(ActiveRecord::Relation) do |rel|
      self.bind_values += rel.bind_values
    end

    [@klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))]
  when Hash
    attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)

    attributes.values.grep(ActiveRecord::Relation) do |rel|
      self.bind_values += rel.bind_values
    end

    PredicateBuilder.build_from_hash(klass, attributes, table)
  else
    [opts]
  end
end

#collapse_filters(arel, filters) ⇒ Object 



232
233
234
235
236
237
238
239
240
 
# File 'lib/ansr/relation/query_methods.rb', line 232

def collapse_filters(arel, filters)
  predicates = filters.map do |filter|
    next filter if ::Arel::Nodes::Equality === filter
    filter = Arel.sql(filter) if String === filter # SqlLiteral-ize
    ::Arel::Nodes::Grouping.new(filter)
  end

  arel.where(::Arel::Nodes::And.new(predicates)) if predicates.present?
end

#collapse_wheres(arel, wheres) ⇒ Object 



222
223
224
225
226
227
228
229
230
 
# File 'lib/ansr/relation/query_methods.rb', line 222

def collapse_wheres(arel, wheres)
  predicates = wheres.map do |where|
    next where if ::Arel::Nodes::Equality === where
    where = Arel.sql(where) if String === where # SqlLiteral-ize
    ::Arel::Nodes::Grouping.new(where)
  end

  arel.where(::Arel::Nodes::And.new(predicates)) if predicates.present?
end

#facet(expr, opts = {}) ⇒ Object 



79
80
81
 
# File 'lib/ansr/relation/query_methods.rb', line 79

def facet(expr, opts = {})
  spawn.facet!(expr, opts)
end

#facet!(expr, opts = {}) ⇒ Object 



83
84
85
86
 
# File 'lib/ansr/relation/query_methods.rb', line 83

def facet!(expr, opts={})
  self.facet_values+= build_facets(expr, opts)
  self
end

#facet_unscoping(target_value) ⇒ Object 



97
98
 
# File 'lib/ansr/relation/query_methods.rb', line 97

def facet_unscoping(target_value)
end

#facet_values ⇒ Object 



88
89
90
 
# File 'lib/ansr/relation/query_methods.rb', line 88

def facet_values
  @values[:facets] || []
end

#facet_values=(values) ⇒ Object

Raises:

  • (ActiveRecord::ImmutableRelation) 


92
93
94
95
 
# File 'lib/ansr/relation/query_methods.rb', line 92

def facet_values=(values)
  raise ActiveRecord::ImmutableRelation if @loaded
  @values[:facets]=values
end

#field_name(expr) ⇒ Object 



168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/ansr/relation/query_methods.rb', line 168

def field_name(expr)
  if expr.is_a? Array
    return expr.collect{|x| field_name(x)}.compact
  else
    case expr
    when ::Arel::Nodes::Binary
      if expr.left.relation.name != model().table.name
        # oof, this is really hacky
        field_name = "#{expr.left.relation.name}.#{expr.left.name}".to_sym
        field_name = expr.left.name.to_sym
      else
        field_name = expr.left.name.to_sym
      end
    when ::Arel::Attributes::Attribute, Ansr::Arel::ConfiguredField
      if expr.relation.name != model().table.name
        # oof, this is really hacky
        field_name = "#{expr.relation.name}.#{expr.name}".to_sym
        field_name = expr.name.to_sym
      else
        field_name = expr.name.to_sym
      end
    when ::Arel::Nodes::Unary, Ansr::Arel::Nodes::Filter
      if expr.expr.relation.name != model().table.name
        # oof, this is really hacky
        field_name = "#{expr.expr.relation.name}.#{expr.expr.name}".to_sym
        field_name = expr.expr.name.to_sym
      else
        field_name = expr.expr.name.to_sym
      end
    else
      field_name = expr.to_sym
    end
    return field_name
  end
end

#filter(expr) ⇒ Object 



36
37
38
39
 
# File 'lib/ansr/relation/query_methods.rb', line 36

def filter(expr)
  check_if_method_has_arguments!("filter", expr)
  spawn.filter!(expr)
end

#filter!(expr) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/ansr/relation/query_methods.rb', line 41

def filter!(expr)
  return self if expr.empty?

  filter_nodes = build_where(expr)
  return self unless filter_nodes
  filters = []
  filter_nodes.each do |filter_node|
    case filter_node
    when ::Arel::Nodes::In, ::Arel::Nodes::Equality
      filter_node.left = Ansr::Arel::Nodes::Filter.new(filter_node.left)
    when ::Arel::SqlLiteral
      filter_node = Ansr::Arel::Nodes::Filter.new(filter_node)
    when String, Symbol
      filter_node = Ansr::Arel::Nodes::Filter.new(::Arel::SqlLiteral.new(filter_node.to_s))
    else
      raise "unexpected filter node type #{filter_node.class}"
    end
    filters << filter_node
  end
  self.filter_values+= filters 

  self
end

#filter_name(expr) ⇒ Object 



100
101
102
 
# File 'lib/ansr/relation/query_methods.rb', line 100

def filter_name(expr)
  connection.sanitize_filter_name(field_name(expr))
end

#filter_unscoping(target_value) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/ansr/relation/query_methods.rb', line 65

def filter_unscoping(target_value)
  target_value_sym = target_value.to_sym

  filter_values.reject! do |rel|
    case rel
    when ::Arel::Nodes::In, ::Arel::Nodes::Equality
      subrelation = (rel.left.kind_of?(::Arel::Attributes::Attribute) ? rel.left : rel.right)
      subrelation.name.to_sym == target_value_sym
    else
      raise "unscope(filter: #{target_value.inspect}) failed: unscoping #{rel.class} is unimplemented."
    end
  end
end

#filter_values ⇒ Object 



27
28
29
 
# File 'lib/ansr/relation/query_methods.rb', line 27

def filter_values
  @values[:filter] ||= []
end

#filter_values=(values) ⇒ Object

Raises:

  • (ImmutableRelation) 


31
32
33
34
 
# File 'lib/ansr/relation/query_methods.rb', line 31

def filter_values=(values)
  raise ImmutableRelation if @loaded
  @values[:filter] = values
end

#find(id) ⇒ Object 



212
213
214
215
216
217
218
219
220
 
# File 'lib/ansr/relation/query_methods.rb', line 212

def find(id)
  klass = model()
  rel = where(klass.table.primary_key.name => id).limit(1)
  rel.to_a
  unless rel.to_a[0]
    raise 'Bad ID'
  end
  rel.to_a.first
end

#find_by_nosql(arel, bind_values) ⇒ Object 



294
295
296
297
 
# File 'lib/ansr/relation/query_methods.rb', line 294

def find_by_nosql(arel, bind_values)
  @ansr_query = model.connection.to_nosql(arel, bind_values)
  model.connection.execute(@ansr_query)
end

#highlight(expr, opts = {}) ⇒ Object 



126
127
128
 
# File 'lib/ansr/relation/query_methods.rb', line 126

def highlight(expr, opts={})
  spawn.highlight!(expr, opts)
end

#highlight!(expr, opts = {}) ⇒ Object 



130
131
132
 
# File 'lib/ansr/relation/query_methods.rb', line 130

def highlight!(expr, opts = {})
  self.highlight_value= Ansr::Arel::Nodes::Highlight.new(expr, opts)
end

#highlight_unscoping(*args) ⇒ Object 



143
144
145
 
# File 'lib/ansr/relation/query_methods.rb', line 143

def highlight_unscoping(*args)
  @values.delete(:highlight)
end

#highlight_value ⇒ Object 



134
135
136
 
# File 'lib/ansr/relation/query_methods.rb', line 134

def highlight_value
  @values[:highlight]
end

#highlight_value=(val) ⇒ Object

Raises:

  • (ActiveRecord::ImmutableRelation) 


138
139
140
141
 
# File 'lib/ansr/relation/query_methods.rb', line 138

def highlight_value=(val)
  raise ActiveRecord::ImmutableRelation if @loaded
  @values[:highlight] = val
end

#spellcheck(expr, opts = {}) ⇒ Object 



147
148
149
 
# File 'lib/ansr/relation/query_methods.rb', line 147

def spellcheck(expr, opts={})
  spawn.spellcheck!(expr, opts)
end

#spellcheck!(expr, opts = {}) ⇒ Object 



151
152
153
 
# File 'lib/ansr/relation/query_methods.rb', line 151

def spellcheck!(expr, opts = {})
  self.spellcheck_value= Ansr::Arel::Nodes::Spellcheck.new(expr, opts)
end

#spellcheck_unscoping(*args) ⇒ Object 



164
165
166
 
# File 'lib/ansr/relation/query_methods.rb', line 164

def spellcheck_unscoping(*args)
  @values.delete(:spellcheck)
end

#spellcheck_value ⇒ Object 



155
156
157
 
# File 'lib/ansr/relation/query_methods.rb', line 155

def spellcheck_value
  @values[:spellcheck]
end

#spellcheck_value=(val) ⇒ Object

Raises:

  • (ActiveRecord::ImmutableRelation) 


159
160
161
162
 
# File 'lib/ansr/relation/query_methods.rb', line 159

def spellcheck_value=(val)
  raise ActiveRecord::ImmutableRelation if @loaded
  @values[:spellcheck] = val
end