module ActiveRecord::Locking::Optimistic

def destroy_row
  affected_rows = super
  if locking_enabled? && affected_rows != 1
    raise ActiveRecord::StaleObjectError.new(self, "destroy")
  end
  affected_rows
end

def increment_lock
  lock_col = self.class.locking_column
  previous_lock_value = send(lock_col).to_i
  send(lock_col + '=', previous_lock_value + 1)
end

def locking_enabled? #:nodoc:
  self.class.locking_enabled?
end

def relation_for_destroy
  relation = super
  if locking_enabled?
    column_name = self.class.locking_column
    column      = self.class.columns_hash[column_name]
    substitute  = self.class.connection.substitute_at(column, relation.bind_values.length)
    relation = relation.where(self.class.arel_table[column_name].eq(substitute))
    relation.bind_values << [column, self[column_name].to_i]
  end
  relation
end

def update_record(attribute_names = @attributes.keys) #:nodoc:
  return super unless locking_enabled?
  return 0 if attribute_names.empty?
  lock_col = self.class.locking_column
  previous_lock_value = send(lock_col).to_i
  increment_lock
  attribute_names += [lock_col]
  attribute_names.uniq!
  begin
    relation = self.class.unscoped
    stmt = relation.where(
      relation.table[self.class.primary_key].eq(id).and(
        relation.table[lock_col].eq(self.class.quote_value(previous_lock_value, column_for_attribute(lock_col)))
      )
    ).arel.compile_update(arel_attributes_with_values_for_update(attribute_names))
    affected_rows = self.class.connection.update stmt
    unless affected_rows == 1
      raise ActiveRecord::StaleObjectError.new(self, "update")
    end
    affected_rows
  # If something went wrong, revert the version.
  rescue Exception
    send(lock_col + '=', previous_lock_value)
    raise
  end
end