Class: Mongoid::Contexts::Mongo

Inherits:
Object
  • Object
show all
Includes:
Paging
Defined in:
lib/mongoid/contexts/mongo.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Paging

#page, #paginate, #per_page

Constructor Details

#initialize(criteria) ⇒ Mongo

Create the new mongo context. This will execute the queries given the selector and options against the database.

Example:

Mongoid::Contexts::Mongo.new(criteria)



167
168
169
170
171
172
173
174
 
# File 'lib/mongoid/contexts/mongo.rb', line 167

def initialize(criteria)
  @criteria = criteria
  if klass.hereditary? && !criteria.selector.keys.include?(:_type)
    @criteria = criteria.in(:_type => criteria.klass._types)
  end
  @criteria.enslave if klass.enslaved?
  @criteria.cache if klass.cached?
end

Instance Attribute Details

#criteria ⇒ Object

Returns the value of attribute criteria.



6
7
8
 
# File 'lib/mongoid/contexts/mongo.rb', line 6

def criteria
  @criteria
end

Instance Method Details

#aggregate ⇒ Object

Aggregate the context. This will take the internally built selector and options and pass them on to the Ruby driver’s group() method on the collection. The collection itself will be retrieved from the class provided, and once the query has returned it will provided a grouping of keys with counts.

Example:

context.aggregate

Returns:

A Hash with field values as keys, counts as values



22
23
24
25
26
27
28
29
 
# File 'lib/mongoid/contexts/mongo.rb', line 22

def aggregate
  klass.collection.group(
    :key => field_list,
    :cond => selector,
    :initial => { :count => 0 },
    :reduce => Javascript.aggregate
  )
end

#avg(field) ⇒ Object

Get the average value for the supplied field.

This will take the internally built selector and options and pass them on to the Ruby driver’s group() method on the collection. The collection itself will be retrieved from the class provided, and once the query has returned it will provided a grouping of keys with averages.

Example:

context.avg(:age)

Returns:

A numeric value that is the average.



45
46
47
48
 
# File 'lib/mongoid/contexts/mongo.rb', line 45

def avg(field)
  total = sum(field)
  total ? (total / count) : nil
end

#blank? ⇒ Boolean Also known as: empty?

Determine if the context is empty or blank given the criteria. Will perform a quick has_one asking only for the id.

Example:

context.blank?

Returns:



56
57
58
 
# File 'lib/mongoid/contexts/mongo.rb', line 56

def blank?
  klass.collection.find_one(selector, { :fields => [ :_id ] }).nil?
end

#count(extras = false) ⇒ Integer

Get the count of matching documents in the database for the context.

Examples:

Get the count without skip and limit taken into consideration.

context.count

Get the count with skip and limit applied.

context.count(true)

Parameters:

  • extras (Boolean) (defaults to: false) —

    True to inclued previous skip/limit statements in the count; false to ignore them. Defaults to ‘false`.

Returns:

  • (Integer) —

    The count of documents.



73
74
75
 
# File 'lib/mongoid/contexts/mongo.rb', line 73

def count(extras = false)
  @count ||= klass.collection.find(selector, process_options).count(extras)
end

#delete_all ⇒ Integer Also known as: delete

Delete all the documents in the database matching the selector.

Examples:

Delete the documents.

context.delete_all

Returns:

  • (Integer) —

    The number of documents deleted.

Since:

  • 2.0.0.rc.1



85
86
87
 
# File 'lib/mongoid/contexts/mongo.rb', line 85

def delete_all
  klass.delete_all(:conditions => selector)
end

#destroy_all ⇒ Integer Also known as: destroy

Destroy all the documents in the database matching the selector.

Examples:

Destroy the documents.

context.destroy_all

Returns:

  • (Integer) —

    The number of documents destroyed.

Since:

  • 2.0.0.rc.1



98
99
100
 
# File 'lib/mongoid/contexts/mongo.rb', line 98

def destroy_all
  klass.destroy_all(:conditions => selector)
end

#distinct(field) ⇒ Object

Gets an array of distinct values for the supplied field across the entire collection or the susbset given the criteria.

Example:

context.distinct(:title)



109
110
111
 
# File 'lib/mongoid/contexts/mongo.rb', line 109

def distinct(field)
  klass.collection.distinct(field, selector)
end

#execute(paginating = false) ⇒ Object

Execute the context. This will take the selector and options and pass them on to the Ruby driver’s find() method on the collection. The collection itself will be retrieved from the class provided, and once the query has returned new documents of the type of class provided will be instantiated.

Example:

context.execute

Returns:

An enumerable Cursor.



125
126
127
128
129
130
131
132
133
 
# File 'lib/mongoid/contexts/mongo.rb', line 125

def execute(paginating = false)
  cursor = klass.collection.find(selector, process_options)
  if cursor
    @count = cursor.count if paginating
    cursor
  else
    []
  end
end

#group ⇒ Object

Groups the context. This will take the internally built selector and options and pass them on to the Ruby driver’s group() method on the collection. The collection itself will be retrieved from the class provided, and once the query has returned it will provided a grouping of keys with objects.

Example:

context.group

Returns:

A Hash with field values as keys, arrays of documents as values.



147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/mongoid/contexts/mongo.rb', line 147

def group
  klass.collection.group(
    :key => field_list,
    :cond => selector,
    :initial => { :group => [] },
    :reduce => Javascript.group
  ).collect do |docs|
    docs["group"] = docs["group"].collect do |attrs|
      Mongoid::Factory.build(klass, attrs)
    end
    docs
  end
end

#grouped(start, field, reduce) ⇒ Object

Common functionality for grouping operations. Currently used by min, max and sum. Will gsub the field name in the supplied reduce function.



293
294
295
296
297
298
299
300
 
# File 'lib/mongoid/contexts/mongo.rb', line 293

def grouped(start, field, reduce)
  collection = klass.collection.group(
    :cond => selector,
    :initial => { start => "start" },
    :reduce => reduce.gsub("[field]", field)
  )
  collection.empty? ? nil : collection.first[start.to_s]
end

#iterate(&block) ⇒ Object

Iterate over each Document in the results. This can take an optional block to pass to each argument in the results.

Example:

context.iterate { |doc| p doc }



182
183
184
185
186
187
 
# File 'lib/mongoid/contexts/mongo.rb', line 182

def iterate(&block)
  return caching(&block) if criteria.cached?
  if block_given?
    execute.each { |doc| yield doc }
  end
end

#last ⇒ Object

Return the last result for the Context. Essentially does a find_one on the collection with the sorting reversed. If no sorting parameters have been provided it will default to ids.

Example:

context.last

Returns:

The last document in the collection.



200
201
202
203
204
205
206
207
 
# File 'lib/mongoid/contexts/mongo.rb', line 200

def last
  opts = process_options
  sorting = opts[:sort]
  sorting = [[:_id, :asc]] unless sorting
  opts[:sort] = sorting.collect { |option| [ option[0], option[1].invert ] }
  attributes = klass.collection.find_one(selector, opts)
  attributes ? Mongoid::Factory.build(klass, attributes) : nil
end

#max(field) ⇒ Object

Return the max value for a field.

This will take the internally built selector and options and pass them on to the Ruby driver’s group() method on the collection. The collection itself will be retrieved from the class provided, and once the query has returned it will provided a grouping of keys with sums.

Example:

context.max(:age)

Returns:

A numeric max value.



223
224
225
 
# File 'lib/mongoid/contexts/mongo.rb', line 223

def max(field)
  grouped(:max, field.to_s, Javascript.max)
end

#min(field) ⇒ Object

Return the min value for a field.

This will take the internally built selector and options and pass them on to the Ruby driver’s group() method on the collection. The collection itself will be retrieved from the class provided, and once the query has returned it will provided a grouping of keys with sums.

Example:

context.min(:age)

Returns:

A numeric minimum value.



241
242
243
 
# File 'lib/mongoid/contexts/mongo.rb', line 241

def min(field)
  grouped(:min, field.to_s, Javascript.min)
end

#one ⇒ Object Also known as: first

Return the first result for the Context.

Example:

context.one

Return:

The first document in the collection.



254
255
256
257
 
# File 'lib/mongoid/contexts/mongo.rb', line 254

def one
  attributes = klass.collection.find_one(selector, process_options)
  attributes ? Mongoid::Factory.build(klass, attributes) : nil
end

#process_options ⇒ Object

Filters the field list. If no fields have been supplied, then it will be empty. If fields have been defined then _type will be included as well.



304
305
306
307
308
309
310
311
312
313
314
315
 
# File 'lib/mongoid/contexts/mongo.rb', line 304

def process_options
  fields = options[:fields]
  if fields && fields.size > 0 && !fields.include?(:_type)
    if fields.kind_of?(Hash)
      fields[:_type] = 1 if fields.first.last != 0 # Not excluding
    else
      fields << :type
    end
    options[:fields] = fields
  end
  options.dup
end

#shift ⇒ Object

Return the first result for the Context and skip it for successive calls.

Returns:

The first document in the collection.



267
268
269
270
271
 
# File 'lib/mongoid/contexts/mongo.rb', line 267

def shift
  document = first
  criteria.skip((options[:skip] || 0) + 1)
  document
end

#sum(field) ⇒ Object

Sum the context.

This will take the internally built selector and options and pass them on to the Ruby driver’s group() method on the collection. The collection itself will be retrieved from the class provided, and once the query has returned it will provided a grouping of keys with sums.

Example:

context.sum(:age)

Returns:

A numeric value that is the sum.



287
288
289
 
# File 'lib/mongoid/contexts/mongo.rb', line 287

def sum(field)
  grouped(:sum, field.to_s, Javascript.sum)
end

#update_all(attributes = {}) ⇒ Object Also known as: update

Very basic update that will perform a simple atomic $set of the attributes provided in the hash. Can be expanded to later for more robust functionality.

Examples:

Update all matching documents.

context.update_all(:title => "Sir")

Parameters:

  • attributes (Hash) (defaults to: {}) —

    The sets to perform.

Since:

  • 2.0.0.rc.4



327
328
329
330
331
332
333
334
 
# File 'lib/mongoid/contexts/mongo.rb', line 327

def update_all(attributes = {})
  klass.collection.update(
    selector,
    { "$set" => attributes },
    :multi => true,
    :safe => Mongoid.persist_in_safe_mode
  )
end