Class: Mongoid::Contexts::Mongo

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Ids

#id_criteria

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)



106
107
108
109
110
111
112
113
 
# File 'lib/mongoid/contexts/mongo.rb', line 106

def initialize(criteria)
  @criteria = criteria
  if klass.hereditary && Mongoid.persist_types
    criteria.in(:_type => criteria.klass._types)
  end
  criteria.enslave if klass.enslaved?
  criteria.cache if klass.cached?
end

Instance Attribute Details

#criteria ⇒ Object (readonly)

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
 
# File 'lib/mongoid/contexts/mongo.rb', line 22

def aggregate
  klass.collection.group(options[:fields], selector, { :count => 0 }, Javascript.aggregate, true)
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:



32
33
34
 
# File 'lib/mongoid/contexts/mongo.rb', line 32

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

#count ⇒ Object

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

Example:

context.count

Returns:

An Integer count of documents.



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

def count
  @count ||= klass.collection.find(selector, process_options).count
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.



63
64
65
66
67
68
69
70
71
 
# File 'lib/mongoid/contexts/mongo.rb', line 63

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.



85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/mongoid/contexts/mongo.rb', line 85

def group
  klass.collection.group(
    options[:fields],
    selector,
    { :group => [] },
    Javascript.group,
    true
  ).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.



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

def grouped(start, field, reduce)
  collection = klass.collection.group(
    nil,
    selector,
    { start => "start" },
    reduce.gsub("[field]", field),
    true
  )
  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 }



121
122
123
124
125
126
 
# File 'lib/mongoid/contexts/mongo.rb', line 121

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.



139
140
141
142
143
144
145
146
 
# File 'lib/mongoid/contexts/mongo.rb', line 139

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.



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

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.



180
181
182
 
# File 'lib/mongoid/contexts/mongo.rb', line 180

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.



193
194
195
196
 
# File 'lib/mongoid/contexts/mongo.rb', line 193

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.



233
234
235
236
237
238
239
240
 
# File 'lib/mongoid/contexts/mongo.rb', line 233

def process_options
  fields = options[:fields]
  if fields && fields.size > 0 && !fields.include?(:_type)
    fields << :_type
    options[:fields] = fields
  end
  options.dup
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.



214
215
216
 
# File 'lib/mongoid/contexts/mongo.rb', line 214

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