Class: Mongoid::Contexts::Mongo

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(criteria) ⇒ Mongo

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

Examples:

Create a new context.

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

Parameters:

  • criteria (Criteria) —

    The criteria to create with.



196
197
198
199
200
201
202
 
# File 'lib/mongoid/contexts/mongo.rb', line 196

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

Instance Attribute Details

#criteria ⇒ Object

Returns the value of attribute criteria.



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

def criteria
  @criteria
end

Instance Method Details

#add_to_set(field, value) ⇒ Object

Perform an add to set on the matching documents.

Examples:

Add to set on all matching.

Person.where(:name => "Alex").add_to_set(:aliases, "value")

Parameters:

  • field (String) —

    The field to add to.

  • value (Object) —

    The value to add.

Returns:

  • (Object) —

    The update value.

Since:

  • 2.1.0



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

def add_to_set(field, value)
  klass.collection.update(
    selector,
    { "$addToSet" => { field => value } },
    :multi => true
  )
end

#aggregate ⇒ Hash

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.

Examples:

Aggreate the context.

context.aggregate

Returns:

  • (Hash) —

    A Hash with field values as keys, counts as values



38
39
40
41
42
43
44
45
 
# File 'lib/mongoid/contexts/mongo.rb', line 38

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

#avg(field) ⇒ Numeric

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.

Examples:

Get the average for a field.

context.avg(:age)

Parameters:

  • field (Symbol) —

    The field to get the average for.

Returns:

  • (Numeric) —

    A numeric value that is the average.



60
61
62
63
 
# File 'lib/mongoid/contexts/mongo.rb', line 60

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

#blank? ⇒ true, false 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.

Examples:

Is the context empty?

context.blank?a

Returns:

  • (true, false) —

    True if blank.



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

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

#count(extras = false) ⇒ Integer Also known as: size, length

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.



89
90
91
92
93
94
95
 
# File 'lib/mongoid/contexts/mongo.rb', line 89

def count(extras = false)
  if cached?
    @count ||= collection.find(selector, process_options).count(extras)
  else
    collection.find(selector, process_options).count(extras)
  end
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



107
108
109
 
# File 'lib/mongoid/contexts/mongo.rb', line 107

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



120
121
122
 
# File 'lib/mongoid/contexts/mongo.rb', line 120

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

#distinct(field) ⇒ Array<Object>

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

Examples:

Get the distinct values.

context.distinct(:title)

Parameters:

  • field (Symbol) —

    The field to get the values for.

Returns:

  • (Array<Object>) —

    The distinct values for the field.



134
135
136
 
# File 'lib/mongoid/contexts/mongo.rb', line 134

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

#execute ⇒ Cursor

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.

Examples:

Execute the criteria on the context.

context.execute

Returns:

  • (Cursor) —

    An enumerable Cursor of results.



147
148
149
150
151
152
 
# File 'lib/mongoid/contexts/mongo.rb', line 147

def execute
  criteria.inclusions.reject! do |metadata|
    metadata.eager_load(criteria)
  end
  klass.collection.find(selector, process_options) || []
end

#first ⇒ Document Also known as: one

Return the first result for the Context.

Examples:

Get the first document.

context.one

Returns:

  • (Document) —

    The first document in the collection.



160
161
162
163
 
# File 'lib/mongoid/contexts/mongo.rb', line 160

def first
  attributes = klass.collection.find_one(selector, options_with_default_sorting)
  attributes ? Mongoid::Factory.from_db(klass, attributes) : nil
end

#group ⇒ Hash

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.

Examples:

Get the criteria as a group.

context.group

Returns:

  • (Hash) —

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



175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'lib/mongoid/contexts/mongo.rb', line 175

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.from_db(klass, attrs)
    end
    docs
  end
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.

Examples:

Iterate over the results.

context.iterate { |doc| p doc }


209
210
211
212
213
214
 
# File 'lib/mongoid/contexts/mongo.rb', line 209

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

#last ⇒ Document

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.

Examples:

Get the last document.

context.last

Returns:

  • (Document) —

    The last document in the collection.



224
225
226
227
228
229
 
# File 'lib/mongoid/contexts/mongo.rb', line 224

def last
  opts = options_with_default_sorting
  opts[:sort] = opts[:sort].map{ |option| [ option[0], option[1].invert ] }.uniq
  attributes = klass.collection.find_one(selector, opts)
  attributes ? Mongoid::Factory.from_db(klass, attributes) : nil
end

#max(field) ⇒ Numeric

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.

Examples:

Get the max value.

context.max(:age)

Parameters:

  • field (Symbol) —

    The field to get the max for.

Returns:

  • (Numeric) —

    A numeric max value.



244
245
246
 
# File 'lib/mongoid/contexts/mongo.rb', line 244

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

#min(field) ⇒ Numeric

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.

Examples:

Get the min value.

context.min(:age)

Parameters:

  • field (Symbol) —

    The field to get the min for.

Returns:

  • (Numeric) —

    A numeric minimum value.



261
262
263
 
# File 'lib/mongoid/contexts/mongo.rb', line 261

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

#pull(field, value) ⇒ Object

Perform a pull on the matching documents.

Examples:

Pull on all matching.

Person.where(:name => "Alex").pull(:aliases, "value")

Parameters:

  • field (String) —

    The field to pull from.

  • value (Object) —

    The value to pull.

Returns:

  • (Object) —

    The update value.

Since:

  • 2.1.0



276
277
278
279
280
281
282
 
# File 'lib/mongoid/contexts/mongo.rb', line 276

def pull(field, value)
  klass.collection.update(
    selector,
    { "$pull" => { field => value } },
    :multi => true
  )
end

#shift ⇒ Document

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

Examples:

Get the first document and shift.

context.shift

Returns:

  • (Document) —

    The first document in the collection.



291
292
293
 
# File 'lib/mongoid/contexts/mongo.rb', line 291

def shift
  first.tap { criteria.skip((options[:skip] || 0) + 1) }
end

#sum(field) ⇒ Numeric

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.

Examples:

Get the sum for a field.

context.sum(:age)

Parameters:

  • field (Symbol) —

    The field who’s values to sum.

Returns:

  • (Numeric) —

    A numeric value that is the sum.



308
309
310
 
# File 'lib/mongoid/contexts/mongo.rb', line 308

def sum(field)
  grouped(:sum, field.to_s, Javascript.sum, Javascript.sum_finalize)
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



322
323
324
325
326
327
328
329
330
 
# File 'lib/mongoid/contexts/mongo.rb', line 322

def update_all(attributes = {})
  klass.collection.update(
    selector,
    { "$set" => attributes },
    Safety.merge_safety_options(:multi => true)
  ).tap do
    Threaded.clear_options!
  end
end