Module: Mongoid::Criterion::Optional

Included in:
Mongoid::Criteria
Defined in:
lib/mongoid/criterion/optional.rb

Instance Method Summary collapse

Instance Method Details

#ascending(*fields) ⇒ Object Also known as: asc

Adds fields to be sorted in ascending order. Will add them in the order they were passed into the method.

Example:

criteria.ascending(:title, :dob)



12
13
14
15
16
17
 
# File 'lib/mongoid/criterion/optional.rb', line 12

def ascending(*fields)
  clone.tap do |crit|
    crit.options[:sort] = [] unless options[:sort] || fields.first.nil?
    fields.flatten.each { |field| crit.options[:sort] << [ field, :asc ] }
  end
end

#cache ⇒ Object

Tells the criteria that the cursor that gets returned needs to be cached. This is so multiple iterations don’t hit the database multiple times, however this is not advisable when working with large data sets as the entire results will get stored in memory.

Example:

criteria.cache



28
29
30
 
# File 'lib/mongoid/criterion/optional.rb', line 28

def cache
  clone.tap { |crit| crit.options.merge!(:cache => true) }
end

#cached? ⇒ Boolean

Will return true if the cache option has been set.

Example:

criteria.cached?

Returns:



37
38
39
 
# File 'lib/mongoid/criterion/optional.rb', line 37

def cached?
  options[:cache] == true
end

#descending(*fields) ⇒ Object Also known as: desc

Adds fields to be sorted in descending order. Will add them in the order they were passed into the method.

Example:

criteria.descending(:title, :dob)



47
48
49
50
51
52
 
# File 'lib/mongoid/criterion/optional.rb', line 47

def descending(*fields)
  clone.tap do |crit|
    crit.options[:sort] = [] unless options[:sort] || fields.first.nil?
    fields.flatten.each { |field| crit.options[:sort] << [ field, :desc ] }
  end
end

#enslave ⇒ Object

Flags the criteria to execute against a read-only slave in the pool instead of master.

Example:

criteria.enslave



61
62
63
 
# File 'lib/mongoid/criterion/optional.rb', line 61

def enslave
  clone.tap { |crit| crit.options.merge!(:enslave => true) }
end

#enslaved? ⇒ Boolean

Will return true if the criteria is enslaved.

Example:

criteria.enslaved?

Returns:



70
71
72
 
# File 'lib/mongoid/criterion/optional.rb', line 70

def enslaved?
  options[:enslave] == true
end

#extras(extras) ⇒ Object

Adds a criterion to the Criteria that specifies additional options to be passed to the Ruby driver, in the exact format for the driver.

Options:

extras: A Hash that gets set to the driver options.

Example:

criteria.extras(:limit => 20, :skip => 40)

Returns: self



86
87
88
89
90
91
 
# File 'lib/mongoid/criterion/optional.rb', line 86

def extras(extras)
  clone.tap do |crit|
    crit.options.merge!(extras)
    crit.filter_options
  end
end

#for_ids(*ids) ⇒ Object

Adds a criterion to the Criteria that specifies an id that must be matched.

Options:

object_id: A single id or an array of ids in String or BSON::ObjectId format

Example:

criteria.for_ids("4ab2bc4b8ad548971900005c") criteria.for_ids(["4ab2bc4b8ad548971900005c", "4c454e7ebf4b98032d000001"])

Returns: self



105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/mongoid/criterion/optional.rb', line 105

def for_ids(*ids)
  ids.flatten!
  if ids.size > 1
    any_in(
      :_id => ::BSON::ObjectId.convert(klass, ids)
    )
  else
    clone.tap do |crit|
      crit.selector[:_id] =
        ::BSON::ObjectId.convert(klass, ids.first)
    end
  end
end

#limit(value = 20) ⇒ Object

Adds a criterion to the Criteria that specifies the maximum number of results to return. This is mostly used in conjunction with skip() to handle paginated results.

Options:

value: An Integer specifying the max number of results. Defaults to 20.

Example:

criteria.limit(100)

Returns: self



132
133
134
 
# File 'lib/mongoid/criterion/optional.rb', line 132

def limit(value = 20)
  clone.tap { |crit| crit.options[:limit] = value }
end

#offset(*args) ⇒ Object

Returns the offset option. If a per_page option is in the list then it will replace it with a skip parameter and return the same value. Defaults to 20 if nothing was provided.



139
140
141
 
# File 'lib/mongoid/criterion/optional.rb', line 139

def offset(*args)
  args.size > 0 ? skip(args.first) : options[:skip]
end

#order_by(*args) ⇒ Object Also known as: order

Adds a criterion to the Criteria that specifies the sort order of the returned documents in the database. Similar to a SQL “ORDER BY”.

Options:

params: An Array of [field, direction] sorting pairs.

Example:

criteria.order_by([[:field1, :asc], [:field2, :desc]])

Returns: self



155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/mongoid/criterion/optional.rb', line 155

def order_by(*args)
  clone.tap do |crit|
    crit.options[:sort] = [] unless options[:sort] || args.first.nil?
    arguments = args.first
    case arguments
    when Hash
      arguments.each do |field, direction|
        crit.options[:sort] << [ field, direction ]
      end
    when Array
      crit.options[:sort].concat(arguments)
    when Complex
      args.flatten.each do |complex|
        crit.options[:sort] << [ complex.key, complex.operator.to_sym ]
      end
    end
  end
end

#skip(value = 0) ⇒ Object

Adds a criterion to the Criteria that specifies how many results to skip when returning Documents. This is mostly used in conjunction with limit() to handle paginated results, and is similar to the traditional “offset” parameter.

Options:

value: An Integer specifying the number of results to skip. Defaults to 0.

Example:

criteria.skip(20)

Returns: self



189
190
191
 
# File 'lib/mongoid/criterion/optional.rb', line 189

def skip(value = 0)
  clone.tap { |crit| crit.options[:skip] = value }
end

#type(types) ⇒ Object

Adds a criterion to the Criteria that specifies a type or an Array of type that must be matched.

Options:

types : An Array of types of a String representing the Type of you search

Example:

criteria.type('Browser') criteria.type(['Firefox', 'Browser'])

Returns: self



206
207
208
209
 
# File 'lib/mongoid/criterion/optional.rb', line 206

def type(types)
  types = [types] unless types.is_a?(Array)
  any_in(:_type => types)
end