Class: MongoRecord::Base
Overview
A superclass for database collection instances. The API is very similar to ActiveRecord. See #find for examples.
If you override initialize, make sure to call the superclass version, passing it the database row or hash that it was given.
Example:
class MP3Track < MongoRecord::Base
collection_name :mp3_track
fields :artist, :album, :song, :track
def to_s
"artist: #{self.artist}, album: #{self.album}, song: #{self.song}, track: #{track}"
end
end
track = MP3Track.find_by_song('She Blinded Me With Science')
puts track.to_s
The database connection defaults to the global $db. You can set the connection using MongoRecord::Base.connection= and read it with MongoRecord::Base.connection.
# Set the connection to something besides $db
MongoRecord::Base.connection = connect('my-database')
Direct Known Subclasses
Constant Summary collapse
- @@connection =
nil
Class Method Summary collapse
- .all(*args) ⇒ Object
-
.arrays ⇒ Object
Return the names of all instance variables that hold objects declared using has_many.
-
.belongs_to(name, options = {}) ⇒ Object
Tells Mongo that this object belongs to another.
-
.collection ⇒ Object
The collection object for this class, which will be different for every subclass of MongoRecord::Base.
-
.collection_name(coll_name) ⇒ Object
Call this method to set the Mongo collection name for this class.
-
.connection ⇒ Object
Return the database connection.
-
.connection=(val) ⇒ Object
Set the database connection.
-
.count(options = {}) ⇒ Object
Returns the number of matching records.
-
.create(values_hash) ⇒ Object
Creates, saves, and returns a new database object.
-
.delete(id) ⇒ Object
Deletes the record with the given id from the collection.
-
.delete_all(conditions = nil) ⇒ Object
Deletes all records that match
condition
, which can be a Mongo-style hash or an ActiveRecord-like hash. -
.destroy(id) ⇒ Object
Load the object with
id
and delete it. -
.destroy_all(conditions = nil) ⇒ Object
Destroy all objects that match
conditions
. -
.field(*fields) ⇒ Object
(also: fields)
Creates one or more collection fields.
-
.field_names ⇒ Object
Return the field names.
-
.find(*args) ⇒ Object
Find one or more database objects.
-
.find_by_mql(mql) ⇒ Object
(also: find_by_sql)
Returns all records matching mql.
-
.find_each(*args) ⇒ Object
Yields each record that was found by the find
options
. - .first(*args) ⇒ Object
-
.has_and_belongs_to_many(name, options = {}) ⇒ Object
Tells Mongo that this object has and many belongs to another object.
-
.has_many(name, options = {}) ⇒ Object
Tells Mongo about an array of subobjects (which can be either a MongoRecord::Subobject or MongoRecord::Base instance).
-
.has_one(name, options = {}) ⇒ Object
Tell Mongo about a subobject (which can be either a MongoRecord::Subobject or MongoRecord::Base instance).
-
.index(fields, options = {}) ⇒ Object
Creates an index for this collection.
-
.indexes(*fields) ⇒ Object
Returns list of indexes for model, unless fields are passed.
-
.inherited(subclass) ⇒ Object
Get ready to save information about
subclass
. -
.instantiate(row = {}) ⇒ Object
This method only exists so that MongoRecord::Base and ActiveRecord::Base can live side by side.
- .last(*args) ⇒ Object
-
.method_missing(sym, *args) ⇒ Object
Handles find_* methods such as find_by_name, find_all_by_shoe_size, and find_or_create_by_name.
-
.mongo_ivar_names ⇒ Object
Return the names of all fields, subobjects, and arrays.
-
.remove ⇒ Object
Deletes the record with the given id from the collection.
-
.subobjects ⇒ Object
Return the names of all instance variables that hold objects declared using has_one.
- .sum(column) ⇒ Object
-
.update(id, attrib) ⇒ Object
Finds the record from the passed
id
, instantly saves it with the passedattributes
(if the validation permits it), and returns it. -
.update_all(updates, conditions = nil, options = {}) ⇒ Object
This updates all records matching the specified criteria.
Instance Method Summary collapse
-
#==(comparison_object) ⇒ Object
Return true if the
comparison_object
is the same object, or is of the same type and has the same id. - #[](attr_name) ⇒ Object
- #[]=(attr_name, value) ⇒ Object
- #attributes ⇒ Object
-
#attributes_from_column_definition ⇒ Object
Does nothing.
-
#create ⇒ Object
Save self to the database and set the id.
-
#delete ⇒ Object
(also: #remove)
Remove self from the database and set @_id to nil.
-
#destroy ⇒ Object
Delete and freeze self.
-
#eql?(comparison_object) ⇒ Boolean
Delegate to ==.
-
#hash ⇒ Object
Delegate to id in order to allow two records of the same type and id to work with something like: [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ].
-
#id ⇒ Object
Return this object’s id.
-
#id=(val) ⇒ Object
Set the id of this object.
-
#initialize(row = {}) {|_self| ... } ⇒ Base
constructor
Initialize a new object with either a hash of values or a row returned from the database.
- #method_missing(sym, *args) ⇒ Object
-
#new_record? ⇒ Boolean
Return true if this object is new—that is, does not yet have an id.
-
#save ⇒ Object
Save self and returns true if the save was successful, false if not.
-
#save! ⇒ Object
Save self and returns true if the save was successful and raises RecordNotSaved if not.
-
#set_create_times(t = nil) ⇒ Object
.
-
#to_mongo_value ⇒ Object
Convert this object to a Mongo value suitable for saving to the database.
-
#to_param ⇒ Object
Rails convenience method.
-
#update ⇒ Object
Save self to the database.
-
#update_attribute(name, value) ⇒ Object
Updates a single attribute and saves the record.
-
#update_attributes(attributes) ⇒ Object
Updates all the attributes from the passed-in Hash and saves the record.
-
#update_attributes!(attributes) ⇒ Object
Updates an object just like Base.update_attributes but calls save! instead of save so an exception is raised if the record is invalid.
- #valid? ⇒ Boolean
Constructor Details
#initialize(row = {}) {|_self| ... } ⇒ Base
Initialize a new object with either a hash of values or a row returned from the database.
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 |
# File 'lib/mongo_record/base.rb', line 762 def initialize(row={}) case row when Hash row.each { |k, val| k = '_id' if k == 'id' # Rails helper init_ivar("@#{k}", val) } else row.instance_variables.each { |iv| init_ivar(iv, row.instance_variable_get(iv)) } end # Default values for remaining fields (self.class.field_names + self.class.subobjects.keys).each { |iv| iv = "@#{iv}" instance_variable_set(iv, nil) unless instance_variable_defined?(iv) } self.class.arrays.keys.each { |iv| iv = "@#{iv}" instance_variable_set(iv, []) unless instance_variable_defined?(iv) } # Create accessors for any per-row dynamic fields we got from our schemaless store self.instance_values.keys.each do |key| next if respond_to?(key.to_sym) # exists define_instance_accessors(key) end yield self if block_given? end |
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(sym, *args) ⇒ Object
914 915 916 917 918 919 920 921 |
# File 'lib/mongo_record/base.rb', line 914 def method_missing(sym, *args) if self.instance_variables.include?("@#{sym}") define_instance_accessors(sym) return self.send(sym) else super end end |
Class Method Details
.all(*args) ⇒ Object
338 339 340 341 |
# File 'lib/mongo_record/base.rb', line 338 def all(*args) = (args) find_every() end |
.arrays ⇒ Object
Return the names of all instance variables that hold objects declared using has_many. The names do not start with ‘@’.
174 |
# File 'lib/mongo_record/base.rb', line 174 def arrays; @arrays; end |
.belongs_to(name, options = {}) ⇒ Object
Tells Mongo that this object belongs to another. A no-op.
222 223 |
# File 'lib/mongo_record/base.rb', line 222 def belongs_to(name, ={}) end |
.collection ⇒ Object
The collection object for this class, which will be different for every subclass of MongoRecord::Base.
227 228 229 |
# File 'lib/mongo_record/base.rb', line 227 def collection connection.collection(@coll_name.to_s) end |
.collection_name(coll_name) ⇒ Object
Call this method to set the Mongo collection name for this class. The default value is the class name turned into lower_case_with_underscores.
102 103 104 |
# File 'lib/mongo_record/base.rb', line 102 def collection_name(coll_name) @coll_name = coll_name end |
.connection ⇒ Object
Return the database connection. The default value is # $db
.
71 72 73 74 75 |
# File 'lib/mongo_record/base.rb', line 71 def connection conn = @@connection || $db raise "connection not defined" unless conn conn end |
.connection=(val) ⇒ Object
Set the database connection. If the connection is set to nil
, then $db
will be used.
79 80 81 82 |
# File 'lib/mongo_record/base.rb', line 79 def connection=(val) @@connection = val @@connection.pk_factory = PKFactory.new unless @@connection.pk_factory end |
.count(options = {}) ⇒ Object
Returns the number of matching records.
361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 |
# File 'lib/mongo_record/base.rb', line 361 def count(={}) criteria = criteria_from([:conditions],[:criteria]).merge!(where_func([:where])) begin collection.find(criteria).count() rescue => ex if ex.to_s =~ /Error with count command.*ns missing/ # Return 0 because we will graciously assume that we are being # called from a subclass that has been initialized properly, and # is therefore mentioned in the schema. 0 else raise ex end end end |
.create(values_hash) ⇒ Object
Creates, saves, and returns a new database object.
423 424 425 426 427 |
# File 'lib/mongo_record/base.rb', line 423 def create(values_hash) object = self.new(values_hash) object.save object end |
.delete(id) ⇒ Object
Deletes the record with the given id from the collection.
383 384 385 |
# File 'lib/mongo_record/base.rb', line 383 def delete(id) collection.remove({:_id => id}) end |
.delete_all(conditions = nil) ⇒ Object
Deletes all records that match condition
, which can be a Mongo-style hash or an ActiveRecord-like hash. Examples:
Person.destroy_all "name like '%fred%' # SQL WHERE clause
Person.destroy_all ["name = ?", 'Fred'] # Rails condition
Person.destroy_all {:name => 'Fred'} # Mongo hash
418 419 420 |
# File 'lib/mongo_record/base.rb', line 418 def delete_all(conditions=nil) collection.remove(criteria_from(conditions)) end |
.destroy(id) ⇒ Object
Load the object with id
and delete it.
389 390 391 |
# File 'lib/mongo_record/base.rb', line 389 def destroy(id) id.is_a?(Array) ? id.each { |oid| destroy(oid) } : find(id).destroy end |
.destroy_all(conditions = nil) ⇒ Object
Destroy all objects that match conditions
. Warning: if conditions
is nil
, all records in the collection will be destroyed.
409 410 411 |
# File 'lib/mongo_record/base.rb', line 409 def destroy_all(conditions = nil) all(:conditions => conditions).each { |object| object.destroy } end |
.field(*fields) ⇒ Object Also known as: fields
Creates one or more collection fields. Each field will be saved to and loaded from the database. The fields named “_id” and “_ns” are automatically saved and loaded.
The method “field” is also called “fields”; you can use either one.
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
# File 'lib/mongo_record/base.rb', line 111 def field(*fields) fields.each { |field| field = field.to_sym unless @field_names.include?(field) ivar_name = "@" + field.to_s # this is better than lambda because it's only eval'ed once define_method(field, lambda { instance_variable_get(ivar_name) }) define_method("#{field}=".to_sym, lambda { |val| instance_variable_set(ivar_name, val) }) define_method("#{field}?".to_sym, lambda { val = instance_variable_get(ivar_name) val != nil && (!val.kind_of?(String) || val != '') }) @field_names << field end } end |
.field_names ⇒ Object
Return the field names.
130 |
# File 'lib/mongo_record/base.rb', line 130 def field_names; @field_names; end |
.find(*args) ⇒ Object
Find one or more database objects.
-
Find by id (a single id or an array of ids) returns one record or a Cursor.
-
Find :first returns the first record that matches the options used or nil if not found.
-
Find :all records; returns a Cursor that can iterate over raw records.
Options:
:conditions
- Hash where key is field name and value is field value. Value may be a simple value like a string, number, or regular expression.
:select
- Single field name or list of field names. If not specified, all fields are returned. Names may be symbols or strings. The database always returns _id and _ns fields.
:order
- If a symbol, orders by that field in ascending order. If a string like “field1 asc, field2 desc, field3”, then sorts those fields in the specified order (default is ascending). If an array, each element is either a field name or symbol (which will be sorted in ascending order) or a hash where key =isfield and value is ‘asc’ or ‘desc’ (case-insensitive), 1 or -1, or if any other value then true == 1 and false/nil == -1.
:limit
- Maximum number of records to return.
:offset
- Number of records to skip.
:where
- A string containing a JavaScript expression. This expression is run by the database server against each record found after the :conditions are run.
This expression is run by the database server against each record found after the :conditions are run.
:criteria
- A hash field to pass in MongoDB conditional operators in a hash format. [$gt, $lt, $gte, $lte, $in, ect.]
Examples for find by id:
Person.find("48e5307114f4abdf00dfeb86") # returns the object for this ID
Person.find(["a_hex_id", "another_hex_id"]) # returns a Cursor over these two objects
Person.find(["a_hex_id"]) # returns a Cursor over the object with this ID
Person.find("a_hex_id", :conditions => "admin = 1", :order => "created_on DESC")
Examples for find first:
Person.find(:first) # returns the first object in the collection
Person.find(:first, :conditions => ["user_name = ?", user_name])
Person.find(:first, :order => "created_on DESC", :offset => 5)
Person.find(:first, :order => {:created_on => -1}, :offset => 5) # same as previous example
Examples for find all:
Person.find(:all) # returns a Cursor over all objects in the collection
Person.find(:all, :conditions => ["category = ?, category], :limit => 50)
Person.find(:all, :offset => 10, :limit => 10)
Person.find(:all, :select => :name) # Only returns name (and _id) fields
Find_by_*
Person.find_by_name_and_age("Spongebob", 42)
Person.find_all_by_name("Fred")
Mongo-specific example:
Person.find(:all, :where => "this.address.city == 'New York' || this.age = 42")
Person.find(:all, :criteria => {"followers_count"=>{"$gte"=>410}})
As a side note, the :order, :limit, and :offset options are passed on to the Cursor (after the :order option is rewritten to be a hash). So
Person.find(:all, :offset => 10, :limit => 10, :order => :created_on)
is the same as
Person.find(:all).skip(10).limit(10).sort({:created_on => 1})
305 306 307 308 309 310 311 312 313 314 315 316 317 318 |
# File 'lib/mongo_record/base.rb', line 305 def find(*args) = (args) .symbolize_keys! case args.first when :first find_initial() when :all find_every() when :last find_last() else find_from_ids(args, ) end end |
.find_by_mql(mql) ⇒ Object Also known as: find_by_sql
Returns all records matching mql. Not yet implemented.
355 356 357 |
# File 'lib/mongo_record/base.rb', line 355 def find_by_mql(mql) # :nodoc: raise "not implemented" end |
.find_each(*args) ⇒ Object
Yields each record that was found by the find options
. The find is performed by find.
Example:
Person.find_each(:conditions => "age > 21") do |person|
person.party_all_night!
end
329 330 331 332 333 334 335 336 |
# File 'lib/mongo_record/base.rb', line 329 def find_each(*args) = (args) .symbolize_keys! find_every().each do |record| yield record end self end |
.first(*args) ⇒ Object
343 344 345 346 347 |
# File 'lib/mongo_record/base.rb', line 343 def first(*args) # args = ([:first]<<args).flatten = (args) find_initial() end |
.has_and_belongs_to_many(name, options = {}) ⇒ Object
Tells Mongo that this object has and many belongs to another object. A no-op.
218 219 |
# File 'lib/mongo_record/base.rb', line 218 def has_and_belongs_to_many(name, ={}) end |
.has_many(name, options = {}) ⇒ Object
Tells Mongo about an array of subobjects (which can be either a MongoRecord::Subobject or MongoRecord::Base instance).
Options: :class_name
- Name of the class of the subobject.
204 205 206 207 208 209 210 211 212 213 214 |
# File 'lib/mongo_record/base.rb', line 204 def has_many(name, ={}) name = name.to_sym unless @arrays[name] ivar_name = "@" + name.to_s define_method(name, lambda { instance_variable_get(ivar_name) }) define_method("#{name}=".to_sym, lambda { |val| instance_variable_set(ivar_name, val) }) define_method("#{name}?".to_sym, lambda { !instance_variable_get(ivar_name).empty? }) klass_name = [:class_name] || field_name_to_class_name(name) @arrays[name] = eval(klass_name) end end |
.has_one(name, options = {}) ⇒ Object
Tell Mongo about a subobject (which can be either a MongoRecord::Subobject or MongoRecord::Base instance).
Options: <code>:class_name<code> - Name of the class of the subobject.
184 185 186 187 188 189 190 191 192 193 194 195 196 197 |
# File 'lib/mongo_record/base.rb', line 184 def has_one(name, ={}) name = name.to_sym unless @subobjects[name] ivar_name = "@" + name.to_s define_method(name, lambda { instance_variable_get(ivar_name) }) define_method("#{name}=".to_sym, lambda { |val| instance_variable_set(ivar_name, val) }) define_method("#{name}?".to_sym, lambda { val = instance_variable_get(ivar_name) val != nil && (!val.kind_of?(String) || val != '') }) klass_name = [:class_name] || field_name_to_class_name(name) @subobjects[name] = eval(klass_name) end end |
.index(fields, options = {}) ⇒ Object
Creates an index for this collection. fields
should be either a single field name (:title) or an array of fields ([:title, :author, :date]) or an array of a field name and direction ([:title, :asc] or [:title, :desc]) or an array of field names and directions ([[:title, :asc], [:author, :desc]]) options
Same as options for create index in the ruby driver
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 |
# File 'lib/mongo_record/base.rb', line 138 def index(fields, ={}) fields = Array(fields) if fields.length == 2 && ( fields[1].to_s == 'asc' || fields[1].to_s == 'desc' || fields[1] == Mongo::ASCENDING || fields[1] == Mongo::DESCENDING ) fields = [fields] end fields = fields.map do |field| field = field.is_a?(Array) ? field : [field, :asc] field[1] = (field[1] == :desc) ? Mongo::DESCENDING : Mongo::ASCENDING field end collection.create_index(fields, ) end |
.indexes(*fields) ⇒ Object
Returns list of indexes for model, unless fields are passed. In that case, creates an index.
158 159 160 161 162 163 164 |
# File 'lib/mongo_record/base.rb', line 158 def indexes(*fields) if fields.empty? collection.index_information else index(*fields) end end |
.inherited(subclass) ⇒ Object
Get ready to save information about subclass
.
91 92 93 94 95 96 97 |
# File 'lib/mongo_record/base.rb', line 91 def inherited(subclass) subclass.instance_variable_set("@coll_name", class_name_to_field_name(subclass.name)) # default name subclass.instance_variable_set("@field_names", []) # array of scalars names (symbols) subclass.instance_variable_set("@subobjects", {}) # key = name (symbol), value = class subclass.instance_variable_set("@arrays", {}) # key = name (symbol), value = class subclass.field(:_id, :_ns) end |
.instantiate(row = {}) ⇒ Object
This method only exists so that MongoRecord::Base and ActiveRecord::Base can live side by side.
86 87 88 |
# File 'lib/mongo_record/base.rb', line 86 def instantiate(row={}) new(row) end |
.last(*args) ⇒ Object
349 350 351 352 |
# File 'lib/mongo_record/base.rb', line 349 def last(*args) = (args) find_last() end |
.method_missing(sym, *args) ⇒ Object
Handles find_* methods such as find_by_name, find_all_by_shoe_size, and find_or_create_by_name.
454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 |
# File 'lib/mongo_record/base.rb', line 454 def method_missing(sym, *args) if match = /^find_(all_by|by)_([_a-zA-Z]\w*)$/.match(sym.to_s) find_how_many = ($1 == 'all_by') ? :all : :first field_names = $2.split(/_and_/) super unless all_fields_exist?(field_names) search = search_from_names_and_values(field_names, args) self.find(find_how_many, {:conditions => search}, *args[field_names.length..-1]) elsif match = /^find_or_(initialize|create)_by_([_a-zA-Z]\w*)$/.match(sym.to_s) create = $1 == 'create' field_names = $2.split(/_and_/) super unless all_fields_exist?(field_names) search = search_from_names_and_values(field_names, args) row = self.find(:first, {:conditions => search}) return self.new(row) if row # found obj = self.new(search.merge(args[field_names.length] || {})) # new object using search and remainder of args obj.save if create obj else super end end |
.mongo_ivar_names ⇒ Object
Return the names of all fields, subobjects, and arrays.
177 |
# File 'lib/mongo_record/base.rb', line 177 def mongo_ivar_names; @field_names + @subobjects.keys + @arrays.keys; end |
.remove ⇒ Object
Deletes the record with the given id from the collection.
386 387 388 |
# File 'lib/mongo_record/base.rb', line 386 def delete(id) collection.remove({:_id => id}) end |
.subobjects ⇒ Object
Return the names of all instance variables that hold objects declared using has_one. The names do not start with ‘@’.
These are not necessarily MongoRecord::Subobject subclasses.
170 |
# File 'lib/mongo_record/base.rb', line 170 def subobjects; @subobjects; end |
.sum(column) ⇒ Object
377 378 379 380 |
# File 'lib/mongo_record/base.rb', line 377 def sum(column) x = all(:select => column) x.map {|p1| p1[column.to_sym]}.compact.inject(0) { |s,v| s += v } end |
.update(id, attrib) ⇒ Object
Finds the record from the passed id
, instantly saves it with the passed attributes
(if the validation permits it), and returns it. If the save fails under validations, the unsaved object is still returned.
The arguments may also be given as arrays in which case the update method is called for each pair of id
and attributes
and an array of objects is returned.
>
Example of updating one record:
Person.update(15, {:user_name => 'Samuel', :group => 'expert'})
Example of updating multiple records:
people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy"} }
Person.update(people.keys, people.values)
441 442 443 444 445 446 447 448 449 450 |
# File 'lib/mongo_record/base.rb', line 441 def update(id, attrib) if id.is_a?(Array) i = -1 id.collect { |id| i += 1; update(id, attrib[i]) } else object = find(id) object.update_attributes(attrib) object end end |
.update_all(updates, conditions = nil, options = {}) ⇒ Object
This updates all records matching the specified criteria. It leverages the db.update call from the Mongo core API to guarantee atomicity. You can specify either a hash for simplicity, or full Mongo API operators to the update part of the method call:
Person.update_all(=> ‘Bob’, => ‘Fred’) Person.update_all(=> {:name => ‘Bob’, ‘$inc’ => => 1}, => ‘Fred’)
400 401 402 403 404 |
# File 'lib/mongo_record/base.rb', line 400 def update_all(updates, conditions = nil, = {}) all(:conditions => conditions).each do |row| collection.update(criteria_from(conditions).merge(:_id => row.id.to_oid), update_fields_from(updates), ) end end |
Instance Method Details
#==(comparison_object) ⇒ Object
Return true if the comparison_object
is the same object, or is of the same type and has the same id.
806 807 808 809 810 811 |
# File 'lib/mongo_record/base.rb', line 806 def ==(comparison_object) comparison_object.equal?(self) || (comparison_object.instance_of?(self.class) && comparison_object.id == id && !comparison_object.new_record?) end |
#[](attr_name) ⇒ Object
905 906 907 |
# File 'lib/mongo_record/base.rb', line 905 def [](attr_name) self.send(attr_name) end |
#[]=(attr_name, value) ⇒ Object
909 910 911 912 |
# File 'lib/mongo_record/base.rb', line 909 def []=(attr_name, value) define_instance_accessors(attr_name) self.send(attr_name.to_s + '=', value) end |
#attributes ⇒ Object
794 795 796 |
# File 'lib/mongo_record/base.rb', line 794 def attributes self.instance_values.inject({}){|h,iv| h[iv.first] = iv.last; h} end |
#attributes_from_column_definition ⇒ Object
Does nothing.
959 |
# File 'lib/mongo_record/base.rb', line 959 def attributes_from_column_definition; end |
#create ⇒ Object
Save self to the database and set the id.
869 870 871 872 873 874 875 876 |
# File 'lib/mongo_record/base.rb', line 869 def create create_date = self.instance_variable_defined?("@created_at") ? self.created_at : nil set_create_times(create_date) @_ns = self.class.collection.name value = to_mongo_value @_id = self.class.collection.insert(value) value.merge(:_id => @_id) end |
#delete ⇒ Object Also known as: remove
Remove self from the database and set @_id to nil. If self has no @_id, does nothing.
891 892 893 894 895 896 |
# File 'lib/mongo_record/base.rb', line 891 def delete if @_id self.class.collection.remove({:_id => self._id}) @_id = nil end end |
#destroy ⇒ Object
Delete and freeze self.
900 901 902 903 |
# File 'lib/mongo_record/base.rb', line 900 def destroy delete freeze end |
#eql?(comparison_object) ⇒ Boolean
Delegate to ==
814 815 816 |
# File 'lib/mongo_record/base.rb', line 814 def eql?(comparison_object) self == (comparison_object) end |
#hash ⇒ Object
Delegate to id in order to allow two records of the same type and id to work with something like:
[ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
820 821 822 |
# File 'lib/mongo_record/base.rb', line 820 def hash id.hash end |
#id ⇒ Object
Return this object’s id.
802 |
# File 'lib/mongo_record/base.rb', line 802 def id; @_id ? @_id.to_s : nil; end |
#id=(val) ⇒ Object
Set the id of this object. Normally not called by user code.
799 |
# File 'lib/mongo_record/base.rb', line 799 def id=(val); @_id = (val == '' ? nil : val); end |
#new_record? ⇒ Boolean
Return true if this object is new—that is, does not yet have an id.
841 842 843 |
# File 'lib/mongo_record/base.rb', line 841 def new_record? @_id.nil? || self.class.collection.find_one("_id" => @_id).nil? end |
#save ⇒ Object
Save self and returns true if the save was successful, false if not.
830 831 832 |
# File 'lib/mongo_record/base.rb', line 830 def save create_or_update end |
#save! ⇒ Object
Save self and returns true if the save was successful and raises RecordNotSaved if not.
836 837 838 |
# File 'lib/mongo_record/base.rb', line 836 def save! create_or_update || raise(RecordNotSaved) end |
#set_create_times(t = nil) ⇒ Object
963 964 965 966 967 968 969 970 971 972 |
# File 'lib/mongo_record/base.rb', line 963 def set_create_times(t=nil) t ||= Time.now t = Time.parse(t) if t.is_a?(String) self["created_at"] = t self["created_on"] = Time.local(t.year, t.month, t.day) self.class.subobjects.keys.each { |iv| val = instance_variable_get("@#{iv}") val.send(:set_create_times, t) if val } end |
#to_mongo_value ⇒ Object
Convert this object to a Mongo value suitable for saving to the database.
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 |
# File 'lib/mongo_record/base.rb', line 847 def to_mongo_value h = {} key_names = self.instance_values.keys key_names.each {|key| value = instance_variable_get("@#{key}").to_mongo_value if value.instance_of? Hash and value["_ns"] value = BSON::DBRef.new(value["_ns"], value["_id"]) elsif value.instance_of? Array value = value.map {|v| if v.instance_of? Hash and v["_ns"] BSON::DBRef.new(v["_ns"], v["_id"]) else v end } end h[key] = value } h end |
#to_param ⇒ Object
Rails convenience method. Return this object’s id as a string.
825 826 827 |
# File 'lib/mongo_record/base.rb', line 825 def to_param @_id.to_s end |
#update ⇒ Object
Save self to the database. Return false
if there was an error, self
if all is well.
880 881 882 883 884 885 886 887 |
# File 'lib/mongo_record/base.rb', line 880 def update set_update_times self.class.collection.update({:_id => @_id}, to_mongo_value) if self.class.collection.db.error? return false end self end |
#update_attribute(name, value) ⇒ Object
Updates a single attribute and saves the record. This is especially useful for boolean flags on existing records. Note: This method is overwritten by the Validation module that’ll make sure that updates made with this method doesn’t get subjected to validation checks. Hence, attributes can be updated even if the full object isn’t valid.
934 935 936 937 |
# File 'lib/mongo_record/base.rb', line 934 def update_attribute(name, value) self[name] = value save end |
#update_attributes(attributes) ⇒ Object
Updates all the attributes from the passed-in Hash and saves the record. If the object is invalid, the saving will fail and false will be returned.
942 943 944 945 946 |
# File 'lib/mongo_record/base.rb', line 942 def update_attributes(attributes) attributes.each do |name, value| update_attribute(name, value) end end |
#update_attributes!(attributes) ⇒ Object
Updates an object just like Base.update_attributes but calls save! instead of save so an exception is raised if the record is invalid.
950 951 952 953 |
# File 'lib/mongo_record/base.rb', line 950 def update_attributes!(attributes) self.attributes = attributes save! end |
#valid? ⇒ Boolean
955 |
# File 'lib/mongo_record/base.rb', line 955 def valid?; true; end |