Class: Mongoid::Criteria::Queryable::Key

Inherits:
Object
  • Object
show all
Defined in:
lib/mongoid/criteria/queryable/key.rb

Overview

Key objects represent specifications for building query expressions utilizing MongoDB selectors.

Simple key-value conditions are translated directly into expression hashes by Mongoid without utilizing Key objects. For example, the following condition:

Foo.where(price: 1)

… is translated to the following simple expression:

{price: 1}

More complex conditions would start involving Key objects. For example:

Foo.where(:price.gt => 1)

… causes a Key instance to be created as follows:

Key.new(:price, :__override__, '$gt')

This Key instance utilizes operator but not expanded nor block. The corresponding MongoDB query expression is:

{price: {'$gt' => 1}}

A yet more more complex example is the following condition:

Foo.geo_spatial(:boundary.intersects_point => [1, 10])

Processing this condition will cause a Key instance to be created as follows:

Key.new(:location, :__override__, '$geoIntersects', '$geometry') do |value|
  { "type" => POINT, "coordinates" => value }
end

… eventually producing the following MongoDB query expression:

{

boundary: {
  '$geoIntersects' => {
    '$geometry' => {
      type: "Point" ,
      coordinates: [ 1, 10 ]
    }
  }
}

}

Key instances can be thought of as procs that map a value to the MongoDB query expression required to obtain the key’s condition, given the value.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name, strategy, operator, expanded = nil, &block) ⇒ Key

Instantiate the new key.

Examples:

Instantiate a key.

Key.new("age", :__override__, "$gt")

Instantiate a key for sorting.

Key.new(:field, :__override__, 1)

Parameters:

  • name (String | Symbol) —

    The field name.

  • strategy (Symbol) —

    The name of the merge strategy.

  • operator (String | Integer) —

    The MongoDB operator, or sort direction (1 or -1).

  • expanded (String) (defaults to: nil) —

    The Mongo expanded operator.



113
114
115
116
117
118
119
120
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 113

def initialize(name, strategy, operator, expanded = nil, &block)
  unless operator.is_a?(String) || operator.is_a?(Integer)
    raise ArgumentError, "Operator must be a string or an integer: #{operator.inspect}"
  end

  @name, @strategy, @operator, @expanded, @block =
    name, strategy, operator, expanded, block
end

Instance Attribute Details

#block ⇒ Proc (readonly)

Returns The optional block to transform values.

Returns:

  • (Proc) —

    The optional block to transform values.



76
77
78
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 76

def block
  @block
end

#expanded ⇒ String (readonly)

Returns The MongoDB expanded query operator.

Returns:

  • (String) —

    The MongoDB expanded query operator.



70
71
72
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 70

def expanded
  @expanded
end

#name ⇒ String | Symbol (readonly)

Returns The name of the field.

Returns:

  • (String | Symbol) —

    The name of the field.



64
65
66
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 64

def name
  @name
end

#operator ⇒ String (readonly)

Returns The MongoDB query operator.

Returns:

  • (String) —

    The MongoDB query operator.



67
68
69
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 67

def operator
  @operator
end

#strategy ⇒ Symbol (readonly)

Returns The name of the merge strategy.

Returns:

  • (Symbol) —

    The name of the merge strategy.



73
74
75
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 73

def strategy
  @strategy
end

Instance Method Details

#==(other) ⇒ true | false Also known as: eql?

Does the key equal another object?

Examples:

Is the key equal to another?

key == other
key.eql? other

Parameters:

  • other (Object) —

    The object to compare to.

Returns:

  • (true | false) —

    If the objects are equal.



87
88
89
90
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 87

def ==(other)
  return false unless other.is_a?(Key)
  name == other.name && operator == other.operator && expanded == other.expanded
end

#__expr_part__(object, negating = false) ⇒ Hash

Gets the raw selector that would be passed to Mongo from this key.

Examples:

Specify the raw selector.

key.__expr_part__(50)

Parameters:

  • object (Object) —

    The value to be included.

  • negating (true | false) (defaults to: false) —

    If the selection should be negated.

Returns:

  • (Hash) —

    The raw MongoDB selector.



131
132
133
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 131

def __expr_part__(object, negating = false)
  { name.to_s => transform_value(object, negating) }
end

#__sort_option__ ⇒ Hash Also known as: __sort_pair__

Get the key as raw Mongo sorting options.

Examples:

Get the key as a sort.

key.__sort_option__

Returns:

  • (Hash) —

    The field/direction pair.



170
171
172
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 170

def __sort_option__
  { name => operator }
end

#hash ⇒ Integer

Calculate the hash code for a key.

Returns:

  • (Integer) —

    The hash code for the key.



96
97
98
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 96

def hash
  [name, operator, expanded].hash
end

#to_s ⇒ String

Convert the key to a string.

Examples:

Convert the key to a string.

key.to_s

Returns:

  • (String) —

    The key as a string.



181
182
183
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 181

def to_s
  @name.to_s
end

#transform_value(value, negating = false) ⇒ Hash

Gets the raw selector condition that would be passed to Mongo.

Examples:

Gets the raw selector condition.

key.transform_value(50)

Parameters:

  • value (Object) —

    The value to be included.

  • negating (true | false) (defaults to: false) —

    If the selection should be negated.

Returns:

  • (Hash) —

    The raw MongoDB selector.



144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/mongoid/criteria/queryable/key.rb', line 144

def transform_value(value, negating = false)
  if block
    expr = block[value]
  else
    expr = value
  end

  if expanded
    expr = {expanded => expr}
  end

  expr = {operator => expr}

  if negating && operator != '$not'
    expr = {'$not' => expr}
  end

  expr
end