Gray Soft / Tags / Redis

17
SEP
2009
Where Redis is a Good Fit

Like any system, Redis has strengths and weaknesses. Some of the biggest positives with Redis are:
- It's wicked fast. In fact, it may just be the fastest key-value store.
- The collection types and the atomic operations that work on them allow you to model some moderately complex data scenarios. This makes Redis fit some higher order problems where a simple key-value store wouldn't quite be enough.
- The snapshot data dumping model can be an asset. You get persistence with Redis, but you pay a minimal penalty for it.
Of course, there are always some minuses. These are the two I consider the most important:
- Redis is an in-memory data store, first and foremost. That means your entire dataset must fit completely in RAM and leave enough breathing room for anything else the server must do.
- Snapshot backups are not perfect. If Redis fails between snapshots, you can lose data. You need to make sure that's acceptable for any application you use it in.
It may seem weird to call snapshots both a pro and a con, but it does work for you in some ways and against you in others. You have to decide where the trade-off is worth it.
Read more…
In: Key-Value Stores | Tags: Redis | 6 Comments

16

SEP
2009

Lists and Sets in Redis

[Update: though all of the techniques I show here still apply, many methods of the Redis gem have changed names to match the actual Redis commands they call. There are also easier and more powerful ways to do some of what I show in here, thanks to additions to Redis.]

Redis adds one huge twist to traditional key-value storage: collections. Supporting both lists and sets through some very powerful atomic operations allows for advanced key-value usage.

Lists

Redis allows a single key to hold a list of values. This is your typical ordered list with the operations you would expect: appending, indexed access, and access to a range of values.

This has many potential uses. I'll cover two that I think will be very common. First, if you are going to use Redis as a full database, you store things that are naturally a list of items, like comments, in a real list. Let's look at some code:

#!/usr/bin/env ruby -wKU

require "redis"

CLEAR = `clear`

# create an article to comment on
db                = Redis.new
article_id        = db.incr("global:next_article_id")
article           = "article:#{article_id}"
class << article
  def method_missing(field, *args, &blk)
    return super unless field.to_s !~ /[!?=]\z/ && args.empty? && blk.nil?
    "#{self}:#{field}"
  end
end
db[article.title] = "My Favorite Language"
db[article.body]  = "I love Ruby!"
# initialize some session details
comments_per_page = 2
comment_page      = 1
login             = ARGV.shift || "JEG2"

loop do
  # show article
  print CLEAR
  puts "#{db[article.title]}:"
  puts "  #{db[article.body]}"

  # paginate comments
  start      =  comments_per_page * (comment_page - 1)
  finish     =  start + comments_per_page - 1
  comments   =  db.list_range(article.comments, start, finish)
  pagination =  Array(start.zero? ? nil : "(p)revious")
  pagination << "(n)ext" if db.list_length(article.comments) - 1 > finish
  # show comments
  comments.each do |comment|
    posted, user, body = comment.split("|", 3)
    puts "----"
    puts "  #{body}"
    puts "  posted by #{user} on #{posted}"
  end

  # handle commands
  puts
  print "Command? [#{(%w[(c)omment (q)uit] + pagination).join(', ')}]  "
  case (command = gets)
  when /\Ac(?:omment)?\Z/i  # add a comment
    print "Your comment?  "
    comment = gets or break
    posted  = Time.now.strftime('%m/%d/%Y at %H:%M:%S')
    db.push_tail(article.comments, "#{posted}|#{login}|#{comment.strip}")
  when /\Ap(?:revious)?\Z/i  # view previous page of comments
    if pagination.first =~ /\A\(p\)/
      comment_page -= 1
    else
      puts "You are on the first page of comments."
      gets or break
    end
  when /\An(?:ext)?\Z/i  # view next page of comments
    if pagination.last =~ /\A\(n\)/
      comment_page += 1
    else
      puts "You are on the last page of comments."
      gets or break
    end
  when /\Aq(?:uit)?\Z/i, nil  # exit program
    break
  end
end