Method: Redis#sort

Defined in:

lib/redis.rb

#sort(key, options = {}) ⇒ Array<String>, ...

Sort the elements in a list, set or sorted set.

Examples:

Retrieve the first 2 elements from an alphabetically sorted "list"

redis.sort("list", :order => "alpha", :limit => [0, 2])
  # => ["a", "b"]

Store an alphabetically descending list in "target"

redis.sort("list", :order => "desc alpha", :store => "target")
  # => 26

Parameters:

• key (String)
• options (Hash) (defaults to: {}) —
  • :by => String: use external key to sort elements by
  • :limit => [offset, count]: skip offset elements, return a maximum of count elements
  • :get => [String, Array<String>]: single key or array of keys to retrieve per element in the result
  • :order => String: combination of ASC, DESC and optionally ALPHA
  • :store => String: key to store the result at

Returns:

• (Array<String>, Array<Array<String>>, Fixnum) —
  • when :get is not specified, or holds a single element, an array of elements
  • when :get is specified, and holds more than one element, an array of elements where every element is an array with the result for every element specified in :get
  • when :store is specified, the number of elements in the stored result

# File 'lib/redis.rb', line 533

def sort(key, options = {})
  args = []

  by = options[:by]
  args.concat(["BY", by]) if by

  limit = options[:limit]
  args.concat(["LIMIT"] + limit) if limit

  get = Array(options[:get])
  args.concat(["GET"].product(get).flatten) unless get.empty?

  order = options[:order]
  args.concat(order.split(" ")) if order

  store = options[:store]
  args.concat(["STORE", store]) if store

  synchronize do |client|
    client.call([:sort, key] + args) do |reply|
      if get.size > 1 && !store
        if reply
          reply.each_slice(get.size).to_a
        end
      else
        reply
      end
    end
  end
end