ohm 1.4.0 → 2.0.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8fb32b51fcb6f8e322f0cdf25638936febbe980
-  data.tar.gz: 37875da64dde8f61fef65909900a9889cbf5a3c9
+  metadata.gz: 8e636620601ef7b7ea32c20094a7e4752f438d95
+  data.tar.gz: 09eabd0899085d76c4d0ddb5fc037459f2b424da
 SHA512:
-  metadata.gz: 94ad5d4c99d9f85212f0902627aa27836bcd23a61f22cef7bcd40b6e8b855656dfcb68dc274128825a04b4f4b46a6b0c6bc4dd9d678326374f18acc51d9e5f10
-  data.tar.gz: 6a8007f49f2e2fac0c06d22323659b9b7ec987c6a5c87fda67e77b6e181f5160f4d78db0d5ebf6b1fa38c8cd34a9833b1f9ae0ec21063e05cb8b87b37bf85e96
+  metadata.gz: 2f5caab8eb261e8381c1c3ea8b9c36da0cc2adb0785bcd70dc2d6d128032d783e0c50e607888fe3f99ab89c097fe0056c11f911637755a10961ac3e19d156994
+  data.tar.gz: 71f3247c75a69a7bc5f4452ab9bf4b70824110f6d4d439d5e1510ad7565bfd64f81ac5dd7d7354dbf136bb983e7919657e93f3b1810a8ed8ad9731941c19ab67

data/.gems

@@ -1,4 +1,4 @@
-nest -v 1.1.1
-scrivener -v 0.0.3
-redis -v 3.0.1
-cutest -v 1.2.0.rc2
+nido -v 0.0.1
+cutest -v 1.2.0
+msgpack -v 0.5.4
+redic -v 0.0.5

data/CHANGELOG

@@ -1,11 +1,3 @@
-1.3.2
-
-- Fetching a batch of objects is now done in batches of 1000 objects at
-  a time. If you are iterating over large collections, this change should
-  provide a significant performance boost both in used memory and total
-  execution time.
-- MutableSet#<< is now an alias for #add.
-
 1.3.1
 
 - Improve memory consumption when indexing persisted attributes.

data/README.md

@@ -443,7 +443,8 @@ lookups.
 In the `Event` example, the index on the name attribute will
 allow for searches like `Event.find(:name => "some value")`.
 
-Note that the methods {Ohm::Model::Set#find find} and
+Note that the {Ohm::Model::Validations#assert_unique assert_unique}
+validation and the methods {Ohm::Model::Set#find find} and
 {Ohm::Model::Set#except except} need a corresponding index in order to work.
 
 ### Finding records
@@ -461,11 +462,8 @@ User.find(:username => "Albert")
 # Find all users from Argentina
 User.find(:country => "Argentina")
 
-# Find all active users from Argentina
-User.find(:country => "Argentina", :status => "active")
-
-# Find all active users from Argentina and Uruguay
-User.find(status: "active").combine(country: ["Argentina", "Uruguay"])
+# Find all activated users from Argentina
+User.find(:country => "Argentina", :status => "activated")
 
 # Find all users from Argentina, except those with a suspended account.
 User.find(:country => "Argentina").except(:status => "suspended")

data/examples/chaining.rb

@@ -21,7 +21,7 @@ require "ohm"
 #     end
 #
 class User < Ohm::Model
-  collection :orders, :Order
+  collection :orders, Order
 end
 
 # The product for our purposes will only contain a name.
@@ -41,8 +41,8 @@ class Order < Ohm::Model
   attribute :state
   index :state
 
-  reference :user, :User
-  reference :product, :Product
+  reference :user, User
+  reference :product, Product
 end
 
 ##### Testing what we have so far.
@@ -58,26 +58,15 @@ prepare { Ohm.flush }
 setup do
   @user = User.create
 
-  @ipod = Product.create(name: "iPod")
-  @ipad = Product.create(name: "iPad")
+  @ipod = Product.create(:name => "iPod")
+  @ipad = Product.create(:name => "iPad")
 
-  @pending = Order.create(
-    user: @user,
-    state: "pending",
-    product: @ipod
-  )
-
-  @authorized = Order.create(
-    user: @user,
-    state: "authorized",
-    product:  @ipad
-  )
-
-  @captured = Order.create(
-    user: @user,
-    state: "captured",
-    product:  @ipad
-  )
+  @pending =    Order.create(:user => @user, :state => "pending",
+                             :product => @ipod)
+  @authorized = Order.create(:user => @user, :state => "authorized",
+                             :product => @ipad)
+  @captured =   Order.create(:user => @user, :state => "captured",
+                             :product => @ipad)
 end
 
 # Now let's try and grab all pending orders, and also pending
@@ -85,23 +74,31 @@ end
 test "finding pending orders" do
   assert @user.orders.find(state: "pending").include?(@pending)
 
-  assert @user.orders.find(state: "pending",
-                           product_id: @ipod.id).include?(@pending)
+  assert @user.orders.find(:state => "pending",
+                           :product_id => @ipod.id).include?(@pending)
 
-  assert @user.orders.find(state: "pending", product_id: @ipad.id).empty?
+  assert @user.orders.find(:state => "pending",
+                           :product_id => @ipad.id).empty?
 end
 
-# Now we try and find captured and authorized orders.
-# Since now `Ohm` supports unions in its finder syntax,
-# it's really easy to do so.
+# Now we try and find captured and authorized orders. The tricky part
+# is trying to find an order that is either *captured* or *authorized*,
+# since `Ohm` as of this writing doesn't support unions in its
+# finder syntax.
 test "finding authorized and/or captured orders" do
-  assert @user.orders.find(state: "authorized").include?(@authorized)
-  assert @user.orders.find(state: "captured").include?(@captured)
+  assert @user.orders.find(:state => "authorized").include?(@authorized)
+  assert @user.orders.find(:state => "captured").include?(@captured)
 
-  auth_or_capt =  @user.orders.find(state: "authorized").union(state: "captured")
+  assert @user.orders.find(:state => ["authorized", "captured"]).empty?
 
-  assert auth_or_capt.include?(@authorized)
-  assert auth_or_capt.include?(@captured)
+  auth_or_capt = @user.orders.key.volatile[:auth_or_capt]
+  auth_or_capt.sunionstore(
+    @user.orders.find(:state => "authorized").key,
+    @user.orders.find(:state => "captured").key
+  )
+
+  assert auth_or_capt.smembers.include?(@authorized.id)
+  assert auth_or_capt.smembers.include?(@captured.id)
 end
 
 #### Creating shortcuts
@@ -109,11 +106,11 @@ end
 # You can of course define methods to make that code more readable.
 class User < Ohm::Model
   def authorized_orders
-    orders.find(state: "authorized")
+    orders.find(:state => "authorized")
   end
 
   def captured_orders
-    orders.find(state: "captured")
+    orders.find(:state => "captured")
   end
 end
 
@@ -128,33 +125,29 @@ end
 
 #### Chaining Kung-Fu
 
-# The `Ohm::Set` takes a *Redis* key, a *namespace* and
-# an *Ohm model* for its arguments.
+# The `Ohm::Model::Set` takes a *Redis* key and a *class monad*
+# for its arguments.
 #
-# We can simply subclass it and define the arguments
-# so we don't have to manually set them everytime.
-class UserOrders < Ohm::Set
-  attr :model
-
+# We can simply subclass it and define the monad to always be an
+# `Order` so we don't have to manually set it everytime.
+class UserOrders < Ohm::Model::Set
   def initialize(key)
-    @model = Order
-
-    super(key, key, @model)
+    super key, Ohm::Model::Wrapper.wrap(Order)
   end
 
   # Here is the crux of the chaining pattern. Instead of
-  # just doing a straight up `find(state: "pending")`, we return
+  # just doing a straight up `find(:state => "pending")`, we return
   # `UserOrders` again.
   def pending
-    self.class.new(model.key[:indices][:state]["pending"])
+    self.class.new(model.index_key_for(:state, "pending"))
   end
 
   def authorized
-    self.class.new(model.key[:indices][:state]["authorized"])
+    self.class.new(model.index_key_for(:state, "authorized"))
   end
 
   def captured
-    self.class.new(model.key[:indices][:state]["captured"])
+    self.class.new(model.index_key_for(:state, "captured"))
   end
 
   # Now we wrap the implementation of doing an `SUNIONSTORE` and also
@@ -163,24 +156,27 @@ class UserOrders < Ohm::Set
   # NOTE: `volatile` just returns the key prepended with a `~:`, so in
   # this case it would be `~:Order:accepted`.
   def accepted
-    Ohm::MultiSet.new(key, @model, Ohm::Command[:sunionstore, authorized.key, captured.key])
+    model.key.volatile[:accepted].sunionstore(
+      authorized.key, captured.key
+    )
+
+    self.class.new(model.key.volatile[:accepted])
   end
 end
 
 # Now let's re-open the `User` class and add a customized `orders` method.
 class User < Ohm::Model
   def orders
-    UserOrders.new(Order.key[:indices][:user_id][id])
+    UserOrders.new(Order.index_key_for(:user_id, id))
   end
 end
 
 # Ok! Let's put all of that chaining code to good use.
 test "finding pending orders using a chainable style" do
   assert @user.orders.pending.include?(@pending)
+  assert @user.orders.pending.find(:product_id => @ipod.id).include?(@pending)
 
-  assert @user.orders.pending.find(product_id: @ipod.id).include?(@pending)
-
-  assert @user.orders.pending.find(product_id: @ipad.id).empty?
+  assert @user.orders.pending.find(:product_id => @ipad.id).empty?
 end
 
 test "finding authorized and/or captured orders using a chainable style" do
@@ -192,8 +188,8 @@ test "finding authorized and/or captured orders using a chainable style" do
 
   accepted = @user.orders.accepted
 
-  assert accepted.find(product_id: @ipad.id).include?(@authorized)
-  assert accepted.find(product_id: @ipad.id).include?(@captured)
+  assert accepted.find(:product_id => @ipad.id).include?(@authorized)
+  assert accepted.find(:product_id => @ipad.id).include?(@captured)
 end
 
 #### Conclusion

data/lib/ohm.rb

@@ -1,13 +1,15 @@
 # encoding: UTF-8
 
-require "nest"
-require "redis"
+require "msgpack"
+require "nido"
+require "redic"
 require "securerandom"
-require "scrivener"
-require "ohm/transaction"
 require "ohm/command"
 
 module Ohm
+  LUA_CACHE   = Hash.new { |h, k| h[k] = Hash.new }
+  LUA_SAVE    = File.expand_path("../ohm/lua/save.lua",   __FILE__)
+  LUA_DELETE  = File.expand_path("../ohm/lua/delete.lua", __FILE__)
 
   # All of the known errors in Ohm can be traced back to one of these
   # exceptions.
@@ -68,76 +70,42 @@ module Ohm
       end
     end
 
-    if Redis::VERSION >= "3.0.0"
-      def self.dict(dict)
-        dict
-      end
-    else
-      def self.dict(arr)
-        Hash[*arr]
-      end
-    end
-  end
-
-  class Connection
-    attr_accessor :context
-    attr_accessor :options
-
-    def initialize(context = :main, options = {})
-      @context = context
-      @options = options
-    end
-
-    def reset!
-      threaded[context] = nil
+    def self.dict(arr)
+      Hash[*arr]
     end
 
-    def start(options = {})
-      self.options = options
-      self.reset!
-    end
+    def self.sort(redis, key, options)
+      args = []
 
-    def redis
-      threaded[context] ||= Redis.connect(options)
-    end
+      args.concat(["BY", options[:by]]) if options[:by]
+      args.concat(["GET", options[:get]]) if options[:get]
+      args.concat(["LIMIT"] + options[:limit]) if options[:limit]
+      args.concat(options[:order].split(" ")) if options[:order]
+      args.concat(["STORE", options[:store]]) if options[:store]
 
-    def threaded
-      Thread.current[:ohm] ||= {}
+      redis.call("SORT", key, *args)
     end
   end
 
-  def self.conn
-    @conn ||= Connection.new
-  end
-
-  # Stores the connection options for the Redis instance.
-  #
-  # Examples:
-  #
-  #   Ohm.connect(:port => 6380, :db => 1, :host => "10.0.1.1")
-  #   Ohm.connect(:url => "redis://10.0.1.1:6380/1")
-  #
-  # All of the options are simply passed on to `Redis.connect`.
-  #
-  def self.connect(options = {})
-    conn.start(options)
-  end
-
   # Use this if you want to do quick ad hoc redis commands against the
   # defined Ohm connection.
   #
   # Examples:
   #
-  #   Ohm.redis.keys("User:*")
-  #   Ohm.redis.set("foo", "bar")
+  #   Ohm.redis.call("SET", "foo", "bar")
+  #   Ohm.redis.call("FLUSH")
   #
   def self.redis
-    conn.redis
+    @redis ||= Redic.new
   end
 
-  # Wrapper for Ohm.redis.flushdb.
+  def self.redis=(redis)
+    @redis = redis
+  end
+
+  # Wrapper for Ohm.redis.call("FLUSHDB").
   def self.flush
-    redis.flushdb
+    redis.call("FLUSHDB")
   end
 
   module Collection
@@ -164,19 +132,19 @@ module Ohm
 
     # Wraps the whole pipelining functionality.
     def fetch(ids)
-      arr = db.pipelined do
-        ids.each { |id| db.hgetall(namespace[id]) }
+      ids.each do |id|
+        redis.queue("HGETALL", namespace[id])
       end
 
-      res = []
+      data = redis.commit
 
-      return res if arr.nil?
+      return [] if data.nil?
 
-      arr.each_with_index do |atts, idx|
-        res << model.new(Utils.dict(atts).update(:id => ids[idx]))
+      [].tap do |result|
+        data.each_with_index do |atts, idx|
+          result << model.new(Utils.dict(atts).update(:id => ids[idx]))
+        end
       end
-
-      res
     end
   end
 
@@ -195,18 +163,18 @@ module Ohm
 
     # Returns the total size of the list using LLEN.
     def size
-      db.llen(key)
+      redis.call("LLEN", key)
     end
     alias :count :size
 
     # Returns the first element of the list using LINDEX.
     def first
-      model[db.lindex(key, 0)]
+      model[redis.call("LINDEX", key, 0)]
     end
 
     # Returns the last element of the list using LINDEX.
     def last
-      model[db.lindex(key, -1)]
+      model[redis.call("LINDEX", key, -1)]
     end
 
     # Checks if the model is part of this List.
@@ -239,20 +207,21 @@ module Ohm
     def replace(models)
       ids = models.map { |model| model.id }
 
-      model.db.multi do
-        db.del(key)
-        ids.each { |id| db.rpush(key, id) }
-      end
+      redis.queue("MULTI")
+      redis.queue("DEL", key)
+      ids.each { |id| redis.queue("RPUSH", key, id) }
+      redis.queue("EXEC")
+      redis.commit
     end
 
     # Pushes the model to the _end_ of the list using RPUSH.
     def push(model)
-      db.rpush(key, model.id)
+      redis.call("RPUSH", key, model.id)
     end
 
     # Pushes the model to the _beginning_ of the list using LPUSH.
     def unshift(model)
-      db.lpush(key, model.id)
+      redis.call("LPUSH", key, model.id)
     end
 
     # Delete a model from the list.
@@ -283,16 +252,16 @@ module Ohm
     def delete(model)
       # LREM key 0 <id> means remove all elements matching <id>
       # @see http://redis.io/commands/lrem
-      db.lrem(key, 0, model.id)
+      redis.call("LREM", key, 0, model.id)
     end
 
   private
     def ids
-      db.lrange(key, 0, -1)
+      redis.call("LRANGE", key, 0, -1)
     end
 
-    def db
-      model.db
+    def redis
+      model.redis
     end
   end
 
@@ -346,10 +315,10 @@ module Ohm
     def sort(options = {})
       if options.has_key?(:get)
         options[:get] = to_key(options[:get])
-        return execute { |key| db.sort(key, options) }
+        return execute { |key| Utils.sort(redis, key, options) }
       end
 
-      fetch(execute { |key| db.sort(key, options) })
+      fetch(execute { |key| Utils.sort(redis, key, options) })
     end
 
     # Check if a model is included in this set.
@@ -370,7 +339,7 @@ module Ohm
 
     # Returns the total size of the set using SCARD.
     def size
-      execute { |key| db.scard(key) }
+      execute { |key| redis.call("SCARD", key) }
     end
     alias :count :size
 
@@ -398,7 +367,7 @@ module Ohm
 
     # Grab all the elements of this set using SMEMBERS.
     def ids
-      execute { |key| db.smembers(key) }
+      execute { |key| redis.call("SMEMBERS", key) }
     end
 
     # Retrieve a specific element using an ID from this set.
@@ -417,7 +386,7 @@ module Ohm
 
   private
     def exists?(id)
-      execute { |key| db.sismember(key, id) }
+      execute { |key| redis.call("SISMEMBER", key, id) == 1 }
     end
 
     def to_key(att)
@@ -467,20 +436,6 @@ module Ohm
       MultiSet.new(namespace, model, key).except(dict)
     end
 
-    # Perform an intersection between the existent set and
-    # the new set created by the union of the passed filters.
-    #
-    # Example:
-    #
-    #   set = User.find(:status => "active")
-    #   set.combine(:name => ["John", "Jane"])
-    #   
-    #   # The result will include all users with active status
-    #   # and with names "John" or "Jane".
-    def combine(dict)
-      MultiSet.new(namespace, model, key).combine(dict)
-    end
-
     # Do a union to the existing set using any number of filters.
     #
     # Example:
@@ -500,8 +455,8 @@ module Ohm
       yield key
     end
 
-    def db
-      model.db
+    def redis
+      model.redis
     end
   end
 
@@ -516,7 +471,7 @@ module Ohm
     #   user.posts.add(post)
     #
     def add(model)
-      db.sadd(key, model.id)
+      redis.call("SADD", key, model.id)
     end
 
     alias_method :<<, :add
@@ -531,7 +486,7 @@ module Ohm
     #   user.posts.delete(post)
     #
     def delete(model)
-      db.srem(key, model.id)
+      redis.call("SREM", key, model.id)
     end
 
     # Replace all the existing elements of a set with a different
@@ -553,10 +508,11 @@ module Ohm
     def replace(models)
       ids = models.map { |model| model.id }
 
-      key.redis.multi do
-        db.del(key)
-        ids.each { |id| db.sadd(key, id) }
-      end
+      redis.queue("MULTI")
+      redis.queue("DEL", key)
+      ids.each { |id| redis.queue("SADD", key, id) }
+      redis.queue("EXEC")
+      redis.commit
     end
   end
 
@@ -612,23 +568,7 @@ module Ohm
     #
     def except(dict)
       MultiSet.new(
-        namespace, model, Command[:sdiffstore, command, unioned(dict)]
-      )
-    end
-
-    # Perform an intersection between the existent set and
-    # the new set created by the union of the passed filters.
-    #
-    # Example:
-    #
-    #   set = User.find(:status => "active")
-    #   set.combine(:name => ["John", "Jane"])
-    #   
-    #   # The result will include all users with active status
-    #   # and with names "John" or "Jane".
-    def combine(dict)
-      MultiSet.new(
-        namespace, model, Command[:sinterstore, command, unioned(dict)]
+        namespace, model, Command[:sdiffstore, command, intersected(dict)]
       )
     end
 
@@ -649,30 +589,25 @@ module Ohm
     end
 
   private
-    def db
-      model.db
+    def redis
+      model.redis
     end
 
     def intersected(dict)
       Command[:sinterstore, *model.filters(dict)]
     end
 
-
-    def unioned(dict)
-      Command[:sunionstore, *model.filters(dict)]
-    end
-
     def execute
       # namespace[:tmp] is where all the temp keys should be stored in.
-      # db will be where all the commands are executed against.
-      res = command.call(namespace[:tmp], db)
+      # redis will be where all the commands are executed against.
+      response = command.call(namespace[:tmp], redis)
 
       begin
 
         # At this point, we have the final aggregated set, which we yield
         # to the caller. the caller can do all the normal set operations,
         # i.e. SCARD, SMEMBERS, etc.
-        yield res
+        yield response
 
       ensure
 
@@ -733,24 +668,12 @@ module Ohm
   #   SADD User:1:posts 1
   #
   class Model
-    include Scrivener::Validations
-
-    def self.conn
-      @conn ||= Connection.new(name, Ohm.conn.options)
-    end
-
-    def self.connect(options)
-      @key = nil
-      @lua = nil
-      conn.start(options)
-    end
-
-    def self.db
-      conn.redis
+    def self.redis=(redis)
+      @redis = redis
     end
 
-    def self.lua
-      @lua ||= Lua.new(File.join(Dir.pwd, "lua"), db)
+    def self.redis
+      @redis ||= Redic.new(Ohm.redis.url)
     end
 
     # The namespace for all the keys generated using this model.
@@ -763,14 +686,14 @@ module Ohm
     #   User.key.kind_of?(String)
     #   # => true
     #
-    #   User.key.kind_of?(Nest)
+    #   User.key.kind_of?(Nido)
     #   # => true
     #
-    # To find out more about Nest, see:
-    #   http://github.com/soveran/nest
+    # To find out more about Nido, see:
+    #   http://github.com/soveran/nido
     #
     def self.key
-      @key ||= Nest.new(self.name, db)
+      @key ||= Nido.new(self.name)
     end
 
     # Retrieve a record by ID.
@@ -803,7 +726,7 @@ module Ohm
 
     # Check if the ID exists within <Model>:all.
     def self.exists?(id)
-      db.sismember(key[:all], id)
+      redis.call("SISMEMBER", key[:all], id) == 1
     end
 
     # Find values in `unique` indices.
@@ -821,7 +744,7 @@ module Ohm
     def self.with(att, val)
       raise IndexNotFound unless uniques.include?(att)
 
-      id = db.hget(key[:uniques][att], val)
+      id = redis.call("HGET", key[:uniques][att], val)
       new(:id => id).load! if id
     end
 
@@ -1104,7 +1027,7 @@ module Ohm
       define_method(name) do
         return 0 if new?
 
-        db.hget(key[:counters], name).to_i
+        redis.call("HGET", key[:counters], name).to_i
       end
     end
 
@@ -1182,7 +1105,7 @@ module Ohm
     # Preload all the attributes of this model from Redis. Used
     # internally by `Model::[]`.
     def load!
-      update_attributes(db.hgetall(key)) unless new?
+      update_attributes(Utils.dict(redis.call("HGETALL", key))) unless new?
       return self
     end
 
@@ -1203,7 +1126,7 @@ module Ohm
     #                 |    u.get(:name) == "B"
     #
     def get(att)
-      @attributes[att] = db.hget(key, att)
+      @attributes[att] = redis.call("HGET", key, att)
     end
 
     # Update an attribute value atomically. The best usecase for this
@@ -1213,7 +1136,12 @@ module Ohm
     # and uniques. Use it wisely. The safe equivalent is `update`.
     #
     def set(att, val)
-      val.to_s.empty? ? db.hdel(key, att) : db.hset(key, att, val)
+      if val.to_s.empty?
+        redis.call("HDEL", key, att)
+      else
+        redis.call("HSET", key, att, val)
+      end
+
       @attributes[att] = val
     end
 
@@ -1223,7 +1151,7 @@ module Ohm
 
     # Increment a counter atomically. Internally uses HINCRBY.
     def incr(att, count = 1)
-      db.hincrby(key[:counters], att, count)
+      redis.call("HINCRBY", key[:counters], att, count)
     end
 
     # Decrement a counter atomically. Internally uses HINCRBY.
@@ -1252,8 +1180,8 @@ module Ohm
       @attributes
     end
 
-    # Export the ID and the errors of the model. The approach of Ohm
-    # is to whitelist public attributes, as opposed to exporting each
+    # Export the ID of the model. The approach of Ohm is to
+    # whitelist public attributes, as opposed to exporting each
     # (possibly sensitive) attribute.
     #
     # Example:
@@ -1283,91 +1211,56 @@ module Ohm
     def to_hash
       attrs = {}
       attrs[:id] = id unless new?
-      attrs[:errors] = errors if errors.any?
 
       return attrs
     end
 
+
     # Persist the model attributes and update indices and unique
     # indices. The `counter`s and `set`s are not touched during save.
     #
-    # If the model is not valid, nil is returned. Otherwise, the
-    # persisted model is returned.
-    #
     # Example:
     #
     #   class User < Ohm::Model
     #     attribute :name
-    #
-    #     def validate
-    #       assert_present :name
-    #     end
     #   end
     #
-    #   User.new(:name => nil).save
-    #   # => nil
-    #
     #   u = User.new(:name => "John").save
     #   u.kind_of?(User)
     #   # => true
     #
-    def save(&block)
-      return if not valid?
-      save!(&block)
-    end
-
-    # Saves the model without checking for validity. Refer to
-    # `Model#save` for more details.
-    def save!
-      t = __save__
-      yield t if block_given?
-      t.commit(db)
+    def save
+      indices = {}
+      model.indices.each { |field| indices[field] = Array(send(field)) }
 
-      return self
-    end
+      uniques = {}
+      model.uniques.each { |field| uniques[field] = send(field) }
 
-    def __save__
-      Transaction.new do |t|
-        t.watch(*_unique_keys)
-
-        if not new?
-          t.watch(key)
-          t.watch(key[:_indices]) if model.indices.any?
-          t.watch(key[:_uniques]) if model.uniques.any?
-        end
+      _initialize_id if new?
 
-        t.before do
-          _initialize_id if new?
-        end
+      attrs = attributes.delete_if do |k, v|
+        v.nil?
+      end
 
-        _uniques = nil
-        uniques  = nil
-        _indices = nil
-        indices  = nil
-        existing_indices = nil
-        existing_uniques = nil
-
-        t.read do
-          _verify_uniques
-          existing_indices = _read_attributes(model.indices) if model.indices.any?
-          existing_uniques = _read_attributes(model.uniques) if model.uniques.any?
-          _uniques = db.hgetall(key[:_uniques])
-          _indices = db.smembers(key[:_indices])
-          uniques  = _read_index_type(:uniques)
-          indices  = _read_index_type(:indices)
-        end
+      response = script(LUA_SAVE, 0,
+        { "name" => model.name,
+          "id" => id,
+          "key" => key
+        }.to_msgpack,
+        attrs.flatten.to_msgpack,
+        indices.to_msgpack,
+        uniques.to_msgpack
+      )
 
-        t.write do
-          db.sadd(model.key[:all], id)
-          _delete_existing_indices(existing_indices)
-          _delete_existing_uniques(existing_uniques)
-          _delete_indices(_indices)
-          _delete_uniques(_uniques)
-          _save
-          _save_indices(indices)
-          _save_uniques(uniques)
+      if response.is_a?(RuntimeError)
+        if response.message =~ /(UniqueIndexViolation: (\w+))/
+          raise UniqueIndexViolation, $1
+        else
+          raise response
         end
       end
+
+      return self
     end
 
     # Delete the model, including all the following keys:
@@ -1379,38 +1272,36 @@ module Ohm
     # If the model has uniques or indices, they're also cleaned up.
     #
     def delete
-      transaction do |t|
-        _uniques = nil
-        _indices = nil
-        existing_indices = nil
-        existing_uniques = nil
-
-        t.watch(*_unique_keys)
-
-        t.watch(key)
-        t.watch(key[:_indices]) if model.indices.any?
-        t.watch(key[:_uniques]) if model.uniques.any?
-
-        t.read do
-          existing_indices = _read_attributes(model.indices) if model.indices.any?
-          existing_uniques = _read_attributes(model.uniques) if model.uniques.any?
-          _uniques = db.hgetall(key[:_uniques])
-          _indices = db.smembers(key[:_indices])
-        end
+      uniques = {}
+      model.uniques.each { |field| uniques[field] = send(field) }
+
+      script(LUA_DELETE, 0,
+        { "name" => model.name,
+          "id" => id,
+          "key" => key
+        }.to_msgpack,
+        uniques.to_msgpack,
+        model.collections.to_msgpack
+      )
 
-        t.write do
-          _delete_uniques(_uniques)
-          _delete_indices(_indices)
-          _delete_existing_uniques(existing_uniques)
-          _delete_existing_indices(existing_indices)
-          model.collections.each { |e| db.del(key[e]) }
-          db.srem(model.key[:all], id)
-          db.del(key[:counters])
-          db.del(key)
-        end
+      return self
+    end
+
+    # Run lua scripts and cache the sha in order to improve
+    # successive calls.
+    def script(file, *args)
+      cache = LUA_CACHE[redis.url]
 
-        yield t if block_given?
+      if cache.key?(file)
+        sha = cache[file]
+      else
+        src = File.read(file)
+        sha = redis.call("SCRIPT", "LOAD", src)
+
+        cache[file] = sha
       end
+
+      redis.call("EVALSHA", sha, *args)
     end
 
     # Update the model attributes and call save.
@@ -1484,125 +1375,21 @@ module Ohm
     end
 
     def self.new_id
-      db.incr(key[:id])
+      redis.call("INCR", key[:id])
     end
 
     attr_writer :id
 
-    def transaction
-      txn = Transaction.new { |t| yield t }
-      txn.commit(db)
-    end
-
     def model
       self.class
     end
 
-    def db
-      model.db
+    def redis
+      model.redis
     end
 
     def _initialize_id
       @id = model.new_id.to_s
     end
-
-    def _skip_empty(atts)
-      {}.tap do |ret|
-        atts.each do |att, val|
-          ret[att] = send(att).to_s unless val.to_s.empty?
-        end
-
-        throw :empty if ret.empty?
-      end
-    end
-
-    def _unique_keys
-      model.uniques.map { |att| model.key[:uniques][att] }
-    end
-
-    def _save
-      catch :empty do
-        db.del(key)
-        db.hmset(key, *_skip_empty(attributes).to_a.flatten)
-      end
-    end
-
-    def _verify_uniques
-      if att = _detect_duplicate
-        raise UniqueIndexViolation, "#{att} is not unique."
-      end
-    end
-
-    def _detect_duplicate
-      model.uniques.detect do |att|
-        id = db.hget(model.key[:uniques][att], send(att))
-        id && id != self.id.to_s
-      end
-    end
-
-    def _read_index_type(type)
-      {}.tap do |ret|
-        model.send(type).each do |att|
-          ret[att] = send(att)
-        end
-      end
-    end
-
-    def _save_uniques(uniques)
-      attrs = model.attributes
-
-      uniques.each do |att, val|
-        unique = model.key[:uniques][att]
-
-        db.hset(unique, val, id)
-        db.hset(key[:_uniques], unique, val) unless attrs.include?(att)
-      end
-    end
-
-    def _delete_uniques(uniques)
-      uniques.each do |unique, val|
-        db.hdel(unique, val)
-        db.hdel(key[:_uniques], unique)
-      end
-    end
-
-    def _delete_existing_indices(existing)
-      return unless existing
-
-      existing = existing.map { |key, value| model.to_indices(key, value) }
-      existing.flatten!(1)
-
-      _delete_indices(existing)
-    end
-
-    def _delete_existing_uniques(existing)
-      return unless existing
-
-      _delete_uniques(existing.map { |key, value|
-        [model.key[:uniques][key], value]
-      })
-    end
-
-    def _delete_indices(indices)
-      indices.each do |index|
-        db.srem(index, id)
-        db.srem(key[:_indices], index)
-      end
-    end
-
-    def _save_indices(indices)
-      attrs = model.attributes
-
-      indices.each do |att, val|
-        model.to_indices(att, val).each do |index|
-          db.sadd(index, id)
-          db.sadd(key[:_indices], index) unless attrs.include?(att)
-        end
-      end
-    end
-
-    def _read_attributes(attrs)
-      Hash[attrs.zip(db.hmget(key, *attrs))]
-    end
   end
 end