Class: Sohm::Model
- Inherits:
-
Object
- Object
- Sohm::Model
- Defined in:
- lib/sohm.rb,
lib/sohm/json.rb
Overview
The base class for all your models. In order to better understand it, here is a semi-realtime explanation of the details involved when creating a User instance.
Example:
class User < Sohm::Model
attribute :name
index :name
attribute :email
unique :email
counter :points
set :posts, :Post
end
u = User.create(:name => "John", :email => "[email protected]")
u.incr :points
u.posts.add(Post.create)
Instance Attribute Summary collapse
-
#cas_token ⇒ Object
Returns the value of attribute cas_token.
-
#id ⇒ Object
Access the ID used to store this model.
Class Method Summary collapse
-
.[](id) ⇒ Object
Retrieve a record by ID.
-
.attribute(name, cast = nil) ⇒ Object
The bread and butter macro of all models.
-
.collection(name, model, reference = to_reference) ⇒ Object
A macro for defining a method which basically does a find.
-
.counter(name) ⇒ Object
Declare a counter.
-
.create(atts = {}) ⇒ Object
Create a new model, notice that under Sohm’s circumstances, this is no longer a syntactic sugar for Model.new(atts).save.
-
.exists?(id) ⇒ Boolean
Check if the ID exists within <Model>:all.
-
.fetch(ids) ⇒ Object
Retrieve a set of models given an array of IDs.
-
.find(dict) ⇒ Object
Find values in indexed fields.
-
.index(attribute) ⇒ Object
Index any method on your model.
-
.key ⇒ Object
Returns the namespace for all the keys generated using this model.
-
.list(name, model) ⇒ Object
Declare an Sohm::List with the given name.
- .mutex ⇒ Object
- .redis ⇒ Object
- .redis=(redis) ⇒ Object
-
.reference(name, model) ⇒ Object
A macro for defining an attribute, an index, and an accessor for a given model.
- .refresh_indices_inline ⇒ Object
- .refresh_indices_inline=(refresh_indices_inline) ⇒ Object
-
.serial_attribute(name, cast = nil) ⇒ Object
Attributes that require CAS property.
-
.set(name, model) ⇒ Object
Declare an Sohm::Set with the given name.
- .synchronize(&block) ⇒ Object
-
.to_proc ⇒ Object
Retrieve a set of models given an array of IDs.
-
.track(name) ⇒ Object
Keep track of ‘key` and remove when deleting the object.
Instance Method Summary collapse
-
#==(other) ⇒ Object
(also: #eql?)
Check for equality by doing the following assertions:.
-
#attributes ⇒ Object
Returns a hash of the attributes with their names as keys and the values of the attributes as values.
- #counters ⇒ Object
-
#decr(att, count = 1) ⇒ Object
Decrement a counter atomically.
-
#delete ⇒ Object
Delete the model, including all the following keys:.
-
#hash ⇒ Object
Return a value that allows the use of models as hash keys.
-
#incr(att, count = 1) ⇒ Object
Increment a counter atomically.
-
#initialize(atts = {}) ⇒ Model
constructor
Initialize a model using a dictionary of attributes.
-
#key ⇒ Object
Returns the namespace for the keys generated using this model.
-
#load! ⇒ Object
Preload all the attributes of this model from Redis.
-
#new? ⇒ Boolean
Returns
true
if the model is not persisted. -
#refresh_indices ⇒ Object
Refresh model indices.
-
#save ⇒ Object
Persist the model attributes and update indices and unique indices.
-
#script(file, *args) ⇒ Object
Run lua scripts and cache the sha in order to improve successive calls.
- #serial_attributes ⇒ Object
-
#to_hash ⇒ Object
Export the ID of the model.
-
#to_json(*args) ⇒ Object
Export a JSON representation of the model by encoding ‘to_hash`.
-
#update(attributes) ⇒ Object
Update the model attributes and call save.
-
#update_attributes(atts) ⇒ Object
Write the dictionary of key-value pairs to the model.
Constructor Details
#initialize(atts = {}) ⇒ Model
Initialize a model using a dictionary of attributes.
Example:
u = User.new(:name => "John")
916 917 918 919 920 921 |
# File 'lib/sohm.rb', line 916 def initialize(atts = {}) @attributes = {} @serial_attributes = {} @serial_attributes_changed = false update_attributes(atts) end |
Instance Attribute Details
#cas_token ⇒ Object
Returns the value of attribute cas_token.
935 936 937 |
# File 'lib/sohm.rb', line 935 def cas_token @cas_token end |
#id ⇒ Object
Access the ID used to store this model. The ID is used together with the name of the class in order to form the Redis key.
Different from ohm, id must be provided by the user in sohm, if you want to use auto-generated id, you can include Sohm::AutoId module.
929 930 931 932 |
# File 'lib/sohm.rb', line 929 def id raise MissingID if not defined?(@id) @id end |
Class Method Details
.[](id) ⇒ Object
Retrieve a record by ID.
Example:
u = User.create
u == User[u.id]
# => true
553 554 555 |
# File 'lib/sohm.rb', line 553 def self.[](id) new(:id => id).load! if id && exists?(id) end |
.attribute(name, cast = nil) ⇒ Object
The bread and butter macro of all models. Basically declares persisted attributes. All attributes are stored on the Redis hash.
class User < Sohm::Model
attribute :name
end
user = User.new(name: "John")
user.name
# => "John"
user.name = "Jane"
user.name
# => "Jane"
A lambda
can be passed as a second parameter to add typecasting support to the attribute.
class User < Sohm::Model
attribute :age, ->(x) { x.to_i }
end
user = User.new(age: 100)
user.age
# => 100
user.age.kind_of?(Integer)
# => true
Check rubydoc.info/github/cyx/ohm-contrib#Ohm__DataTypes to see more examples about the typecasting feature.
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 |
# File 'lib/sohm.rb', line 811 def self.attribute(name, cast = nil) if serial_attributes.include?(name) raise ArgumentError, "#{name} is already used as a serial attribute." end attributes << name unless attributes.include?(name) if cast define_method(name) do cast[@attributes[name]] end else define_method(name) do @attributes[name] end end define_method(:"#{name}=") do |value| @attributes[name] = value end end |
.collection(name, model, reference = to_reference) ⇒ Object
716 717 718 719 720 721 |
# File 'lib/sohm.rb', line 716 def self.collection(name, model, reference = to_reference) define_method name do model = Utils.const(self.class, model) model.find(:"#{reference}_id" => id) end end |
.counter(name) ⇒ Object
Declare a counter. All the counters are internally stored in a different Redis hash, independent from the one that stores the model attributes. Counters are updated with the ‘incr` and `decr` methods, which interact directly with Redis. Their value can’t be assigned as with regular attributes.
Example:
class User < Sohm::Model
counter :points
end
u = User.create
u.incr :points
u.points
# => 1
Note: You can’t use counters until you save the model. If you try to do it, you’ll receive an Sohm::MissingID error.
883 884 885 886 887 888 889 890 891 |
# File 'lib/sohm.rb', line 883 def self.counter(name) counters << name unless counters.include?(name) define_method(name) do return 0 if new? redis.call("HGET", key[:_counters], name).to_i end end |
.create(atts = {}) ⇒ Object
Create a new model, notice that under Sohm’s circumstances, this is no longer a syntactic sugar for Model.new(atts).save
900 901 902 |
# File 'lib/sohm.rb', line 900 def self.create(atts = {}) new(atts).save end |
.exists?(id) ⇒ Boolean
Check if the ID exists within <Model>:all.
574 575 576 |
# File 'lib/sohm.rb', line 574 def self.exists?(id) redis.call("EXISTS", key[id]) == 1 end |
.fetch(ids) ⇒ Object
Retrieve a set of models given an array of IDs.
Example:
User.fetch([1, 2, 3])
632 633 634 |
# File 'lib/sohm.rb', line 632 def self.fetch(ids) all.fetch(ids) end |
.find(dict) ⇒ Object
Find values in indexed fields.
Example:
class User < Sohm::Model
attribute :email
attribute :name
index :name
attribute :status
index :status
index :provider
index :tag
def provider
email[/@(.*?).com/, 1]
end
def tag
["ruby", "python"]
end
end
u = User.create(name: "John", status: "pending", email: "[email protected]")
User.find(provider: "me", name: "John", status: "pending").include?(u)
# => true
User.find(:tag => "ruby").include?(u)
# => true
User.find(:tag => "python").include?(u)
# => true
Due to restrictions in Codis, we only support single-index query. If you want to query based on multiple fields, you can make an index based on all the fields.
616 617 618 619 620 621 622 623 624 |
# File 'lib/sohm.rb', line 616 def self.find(dict) keys = filters(dict) if keys.size == 1 Sohm::Set.new(keys.first, key, self) else raise NotSupported end end |
.index(attribute) ⇒ Object
Index any method on your model. Once you index a method, you can use it in ‘find` statements.
638 639 640 |
# File 'lib/sohm.rb', line 638 def self.index(attribute) indices << attribute unless indices.include?(attribute) end |
.key ⇒ Object
541 542 543 |
# File 'lib/sohm.rb', line 541 def self.key Nido.new(self.name) end |
.list(name, model) ⇒ Object
Declare an Sohm::List with the given name.
Example:
class Comment < Sohm::Model
end
class Post < Sohm::Model
list :comments, :Comment
end
p = Post.create
p.comments.push(Comment.create)
p.comments.unshift(Comment.create)
p.comments.size == 2
# => true
Note: You can’t use the list until you save the model. If you try to do it, you’ll receive an Sohm::MissingID error.
687 688 689 690 691 692 693 694 695 |
# File 'lib/sohm.rb', line 687 def self.list(name, model) track(name) define_method name do model = Utils.const(self.class, model) Sohm::List.new(key[name], model.key, model) end end |
.redis ⇒ Object
502 503 504 |
# File 'lib/sohm.rb', line 502 def self.redis defined?(@redis) ? @redis : Sohm.redis end |
.redis=(redis) ⇒ Object
498 499 500 |
# File 'lib/sohm.rb', line 498 def self.redis=(redis) @redis = redis end |
.reference(name, model) ⇒ Object
A macro for defining an attribute, an index, and an accessor for a given model.
Example:
class Post < Sohm::Model
reference :user, :User
end
# It's the same as:
class Post < Sohm::Model
attribute :user_id
index :user_id
def user
User[user_id]
end
def user=(user)
self.user_id = user.id
end
def user_id=(user_id)
self.user_id = user_id
end
end
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 |
# File 'lib/sohm.rb', line 751 def self.reference(name, model) reader = :"#{name}_id" writer = :"#{name}_id=" attributes << reader unless attributes.include?(reader) index reader define_method(reader) do @attributes[reader] end define_method(writer) do |value| @attributes[reader] = value end define_method(:"#{name}=") do |value| send(writer, value ? value.id : nil) end define_method(name) do model = Utils.const(self.class, model) model[send(reader)] end end |
.refresh_indices_inline ⇒ Object
510 511 512 513 514 |
# File 'lib/sohm.rb', line 510 def self.refresh_indices_inline defined?(@refresh_indices_inline) ? @refresh_indices_inline : Sohm.refresh_indices_inline end |
.refresh_indices_inline=(refresh_indices_inline) ⇒ Object
506 507 508 |
# File 'lib/sohm.rb', line 506 def self.refresh_indices_inline=(refresh_indices_inline) @refresh_indices_inline = refresh_indices_inline end |
.serial_attribute(name, cast = nil) ⇒ Object
Attributes that require CAS property
834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 |
# File 'lib/sohm.rb', line 834 def self.serial_attribute(name, cast = nil) if attributes.include?(name) raise ArgumentError, "#{name} is already used as a normal attribute." end serial_attributes << name unless serial_attributes.include?(name) if cast define_method(name) do # NOTE: This is a temporary solution, since we might use # composite objects (such as arrays), which won't always # do a reset @serial_attributes_changed = true cast[@serial_attributes[name]] end else define_method(name) do @serial_attributes_changed = true @serial_attributes[name] end end define_method(:"#{name}=") do |value| @serial_attributes_changed = true @serial_attributes[name] = value end end |
.set(name, model) ⇒ Object
657 658 659 660 661 662 663 664 665 |
# File 'lib/sohm.rb', line 657 def self.set(name, model) track(name) define_method name do model = Utils.const(self.class, model) Sohm::MutableSet.new(key[name], model.key, model) end end |
.synchronize(&block) ⇒ Object
520 521 522 |
# File 'lib/sohm.rb', line 520 def self.synchronize(&block) mutex.synchronize(&block) end |
.to_proc ⇒ Object
Retrieve a set of models given an array of IDs.
Example:
ids = [1, 2, 3]
ids.map(&User)
Note: The use of this should be a last resort for your actual application runtime, or for simply debugging in your console. If you care about performance, you should pipeline your reads. For more information checkout the implementation of Sohm::List#fetch.
569 570 571 |
# File 'lib/sohm.rb', line 569 def self.to_proc lambda { |id| self[id] } end |
.track(name) ⇒ Object
Keep track of ‘key` and remove when deleting the object.
894 895 896 |
# File 'lib/sohm.rb', line 894 def self.track(name) tracked << name unless tracked.include?(name) end |
Instance Method Details
#==(other) ⇒ Object Also known as: eql?
Check for equality by doing the following assertions:
-
That the passed model is of the same type.
-
That they represent the same Redis key.
942 943 944 945 946 |
# File 'lib/sohm.rb', line 942 def ==(other) other.kind_of?(model) && other.key == key rescue MissingID false end |
#attributes ⇒ Object
1016 1017 1018 |
# File 'lib/sohm.rb', line 1016 def attributes @attributes end |
#counters ⇒ Object
1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 |
# File 'lib/sohm.rb', line 1024 def counters hash = {} self.class.counters.each do |name| hash[name] = 0 end return hash if new? redis.call("HGETALL", key[:_counters]).each_slice(2).each do |pair| hash[pair[0].to_sym] = pair[1].to_i end hash end |
#decr(att, count = 1) ⇒ Object
Decrement a counter atomically. Internally uses HINCRBY.
981 982 983 |
# File 'lib/sohm.rb', line 981 def decr(att, count = 1) incr(att, -count) end |
#delete ⇒ Object
Delete the model, including all the following keys:
-
<Model>:<id>
-
<Model>:<id>:_counters
-
<Model>:<id>:<set name>
If the model has uniques or indices, they’re also cleaned up.
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 |
# File 'lib/sohm.rb', line 1166 def delete memo_key = key["_indices"] commands = [["DEL", key], ["DEL", memo_key], ["DEL", key["_counters"]]] index_list = redis.call("SMEMBERS", memo_key) index_list.each do |index_key| commands << ["SREM", index_key, id] end model.tracked.each do |tracked_key| commands << ["DEL", key[tracked_key]] end model.synchronize do commands.each do |command| redis.queue(*command) end redis.commit end return self end |
#hash ⇒ Object
Return a value that allows the use of models as hash keys.
Example:
h = {}
u = User.new
h[:u] = u
h[:u] == u
# => true
997 998 999 |
# File 'lib/sohm.rb', line 997 def hash new? ? super : key.hash end |
#incr(att, count = 1) ⇒ Object
Increment a counter atomically. Internally uses HINCRBY.
976 977 978 |
# File 'lib/sohm.rb', line 976 def incr(att, count = 1) redis.call("HINCRBY", key[:_counters], att, count) end |
#key ⇒ Object
Returns the namespace for the keys generated using this model. Check ‘Sohm::Model.key` documentation for more details.
906 907 908 |
# File 'lib/sohm.rb', line 906 def key model.key[id] end |
#load! ⇒ Object
Preload all the attributes of this model from Redis. Used internally by ‘Model::[]`.
950 951 952 953 954 |
# File 'lib/sohm.rb', line 950 def load! update_attributes(Utils.dict(redis.call("HGETALL", key))) if id @serial_attributes_changed = false return self end |
#new? ⇒ Boolean
971 972 973 |
# File 'lib/sohm.rb', line 971 def new? !(defined?(@id) && model.exists?(id)) end |
#refresh_indices ⇒ Object
Refresh model indices
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 |
# File 'lib/sohm.rb', line 1115 def refresh_indices memo_key = key["_indices"] # Add new indices first commands = fetch_indices.each_pair.map do |field, vals| vals.map do |val| index_key = model.key["_indices"][field][val] [["SADD", memo_key, index_key], ["SADD", index_key, id]] end end.flatten(2) model.synchronize do commands.each do |command| redis.queue(*command) end redis.commit end # Remove old indices index_set = ::Set.new(redis.call("SMEMBERS", memo_key)) # Here we are fetching the latest model to avoid concurrency issue valid_list = model[id].send(:fetch_indices).each_pair.map do |field, vals| vals.map do |val| model.key["_indices"][field][val] end end.flatten(1) valid_set = ::Set.new(valid_list) diff_set = index_set - valid_set if diff_set.size > 0 diff_list = diff_set.to_a commands = diff_list.map do |key| ["SREM", key, id] end + [["SREM", memo_key] + diff_list] model.synchronize do commands.each do |command| redis.queue(*command) end redis.commit end end true end |
#save ⇒ Object
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 |
# File 'lib/sohm.rb', line 1085 def save if serial_attributes_changed response = script(LUA_SAVE, 1, key, sanitize_attributes(serial_attributes).to_msgpack, cas_token, sanitize_attributes(attributes).to_msgpack) if response.is_a?(RuntimeError) if response. =~ /cas_error/ raise CasViolation else raise response end end @cas_token = response @serial_attributes_changed = false else redis.call("HSET", key, "_ndata", sanitize_attributes(attributes).to_msgpack) end if model.refresh_indices_inline refresh_indices end return self end |
#script(file, *args) ⇒ Object
Run lua scripts and cache the sha in order to improve successive calls.
1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 |
# File 'lib/sohm.rb', line 1189 def script(file, *args) response = nil if Sohm.enable_evalsha response = redis.call("EVALSHA", LUA_SAVE_DIGEST, *args) if response.is_a?(RuntimeError) if response. =~ /NOSCRIPT/ response = nil end end end response ? response : redis.call("EVAL", LUA_SAVE, *args) end |
#serial_attributes ⇒ Object
1020 1021 1022 |
# File 'lib/sohm.rb', line 1020 def serial_attributes @serial_attributes end |
#to_hash ⇒ Object
Export the ID of the model. The approach of Ohm is to whitelist public attributes, as opposed to exporting each (possibly sensitive) attribute.
Example:
class User < Sohm::Model
attribute :name
end
u = User.create(:name => "John")
u.to_hash
# => { :id => "1" }
In order to add additional attributes, you can override ‘to_hash`:
class User < Sohm::Model
attribute :name
def to_hash
super.merge(:name => name)
end
end
u = User.create(:name => "John")
u.to_hash
# => { :id => "1", :name => "John" }
1064 1065 1066 1067 1068 1069 |
# File 'lib/sohm.rb', line 1064 def to_hash attrs = {} attrs[:id] = id unless new? return attrs end |
#to_json(*args) ⇒ Object
Export a JSON representation of the model by encoding ‘to_hash`.
6 7 8 |
# File 'lib/sohm/json.rb', line 6 def to_json(*args) to_hash.to_json(*args) end |
#update(attributes) ⇒ Object
Update the model attributes and call save.
Example:
User[1].update(:name => "John")
# It's the same as:
u = User[1]
u.update_attributes(:name => "John")
u.save
1216 1217 1218 1219 |
# File 'lib/sohm.rb', line 1216 def update(attributes) update_attributes(attributes) save end |
#update_attributes(atts) ⇒ Object
Write the dictionary of key-value pairs to the model.
1222 1223 1224 |
# File 'lib/sohm.rb', line 1222 def update_attributes(atts) unpack_attrs(atts).each { |att, val| send(:"#{att}=", val) } end |