Module: Redis::Commands::Sets

Included in:
Redis::Commands
Defined in:
lib/redis/commands/sets.rb

Instance Method Summary collapse

Instance Method Details

#sadd(key, member) ⇒ Boolean, Integer

Add one or more members to a set.

Parameters:

  • key (String)
  • member (String, Array<String>)

    one member, or array of members

Returns:

  • (Boolean, Integer)

    Boolean when a single member is specified, holding whether or not adding the member succeeded, or Integer when an array of members is specified, holding the number of members that were successfully added


22
23
24
25
26
27
28
29
30
31
32
# File 'lib/redis/commands/sets.rb', line 22

def sadd(key, member)
  send_command([:sadd, key, member]) do |reply|
    if member.is_a? Array
      # Variadic: return integer
      reply
    else
      # Single argument: return boolean
      Boolify.call(reply)
    end
  end
end

#scard(key) ⇒ Integer

Get the number of members in a set.

Parameters:

  • key (String)

Returns:

  • (Integer)

10
11
12
# File 'lib/redis/commands/sets.rb', line 10

def scard(key)
  send_command([:scard, key])
end

#sdiff(*keys) ⇒ Array<String>

Subtract multiple sets.

Parameters:

  • keys (String, Array<String>)

    keys pointing to sets to subtract

Returns:

  • (Array<String>)

    members in the difference


122
123
124
# File 'lib/redis/commands/sets.rb', line 122

def sdiff(*keys)
  send_command([:sdiff, *keys])
end

#sdiffstore(destination, *keys) ⇒ Integer

Subtract multiple sets and store the resulting set in a key.

Parameters:

  • destination (String)

    destination key

  • keys (String, Array<String>)

    keys pointing to sets to subtract

Returns:

  • (Integer)

    number of elements in the resulting set


131
132
133
# File 'lib/redis/commands/sets.rb', line 131

def sdiffstore(destination, *keys)
  send_command([:sdiffstore, destination, *keys])
end

#sinter(*keys) ⇒ Array<String>

Intersect multiple sets.

Parameters:

  • keys (String, Array<String>)

    keys pointing to sets to intersect

Returns:

  • (Array<String>)

    members in the intersection


139
140
141
# File 'lib/redis/commands/sets.rb', line 139

def sinter(*keys)
  send_command([:sinter, *keys])
end

#sinterstore(destination, *keys) ⇒ Integer

Intersect multiple sets and store the resulting set in a key.

Parameters:

  • destination (String)

    destination key

  • keys (String, Array<String>)

    keys pointing to sets to intersect

Returns:

  • (Integer)

    number of elements in the resulting set


148
149
150
# File 'lib/redis/commands/sets.rb', line 148

def sinterstore(destination, *keys)
  send_command([:sinterstore, destination, *keys])
end

#sismember(key, member) ⇒ Boolean

Determine if a given value is a member of a set.

Parameters:

  • key (String)
  • member (String)

Returns:

  • (Boolean)

95
96
97
# File 'lib/redis/commands/sets.rb', line 95

def sismember(key, member)
  send_command([:sismember, key, member], &Boolify)
end

#smembers(key) ⇒ Array<String>

Get all the members in a set.

Parameters:

  • key (String)

Returns:

  • (Array<String>)

114
115
116
# File 'lib/redis/commands/sets.rb', line 114

def smembers(key)
  send_command([:smembers, key])
end

#smismember(key, *members) ⇒ Array<Boolean>

Determine if multiple values are members of a set.

Parameters:

  • key (String)
  • members (String, Array<String>)

Returns:

  • (Array<Boolean>)

104
105
106
107
108
# File 'lib/redis/commands/sets.rb', line 104

def smismember(key, *members)
  send_command([:smismember, key, *members]) do |reply|
    reply.map(&Boolify)
  end
end

#smove(source, destination, member) ⇒ Boolean

Move a member from one set to another.

Parameters:

  • source (String)

    source key

  • destination (String)

    destination key

  • member (String)

    member to move from source to destination

Returns:

  • (Boolean)

86
87
88
# File 'lib/redis/commands/sets.rb', line 86

def smove(source, destination, member)
  send_command([:smove, source, destination, member], &Boolify)
end

#spop(key, count = nil) ⇒ String

Remove and return one or more random member from a set.

Parameters:

  • key (String)
  • count (Integer) (defaults to: nil)

Returns:

  • (String)

59
60
61
62
63
64
65
# File 'lib/redis/commands/sets.rb', line 59

def spop(key, count = nil)
  if count.nil?
    send_command([:spop, key])
  else
    send_command([:spop, key, count])
  end
end

#srandmember(key, count = nil) ⇒ String

Get one or more random members from a set.

Parameters:

  • key (String)
  • count (Integer) (defaults to: nil)

Returns:

  • (String)

72
73
74
75
76
77
78
# File 'lib/redis/commands/sets.rb', line 72

def srandmember(key, count = nil)
  if count.nil?
    send_command([:srandmember, key])
  else
    send_command([:srandmember, key, count])
  end
end

#srem(key, member) ⇒ Boolean, Integer

Remove one or more members from a set.

Parameters:

  • key (String)
  • member (String, Array<String>)

    one member, or array of members

Returns:

  • (Boolean, Integer)

    Boolean when a single member is specified, holding whether or not removing the member succeeded, or Integer when an array of members is specified, holding the number of members that were successfully removed


42
43
44
45
46
47
48
49
50
51
52
# File 'lib/redis/commands/sets.rb', line 42

def srem(key, member)
  send_command([:srem, key, member]) do |reply|
    if member.is_a? Array
      # Variadic: return integer
      reply
    else
      # Single argument: return boolean
      Boolify.call(reply)
    end
  end
end

#sscan(key, cursor, **options) ⇒ String+

Scan a set

Examples:

Retrieve the first batch of keys in a set

redis.sscan("set", 0)

Parameters:

  • cursor (String, Integer)

    the cursor of the iteration

  • options (Hash)
    • :match => String: only return keys matching the pattern
    • :count => Integer: return count keys at most per iteration

Returns:

  • (String, Array<String>)

    the next cursor and all found members


180
181
182
# File 'lib/redis/commands/sets.rb', line 180

def sscan(key, cursor, **options)
  _scan(:sscan, cursor, [key], **options)
end

#sscan_each(key, **options, &block) ⇒ Enumerator

Scan a set

Examples:

Retrieve all of the keys in a set

redis.sscan_each("set").to_a
# => ["key1", "key2", "key3"]

Parameters:

  • options (Hash)
    • :match => String: only return keys matching the pattern
    • :count => Integer: return count keys at most per iteration

Returns:

  • (Enumerator)

    an enumerator for all keys in the set


195
196
197
198
199
200
201
202
203
204
# File 'lib/redis/commands/sets.rb', line 195

def sscan_each(key, **options, &block)
  return to_enum(:sscan_each, key, **options) unless block_given?

  cursor = 0
  loop do
    cursor, keys = sscan(key, cursor, **options)
    keys.each(&block)
    break if cursor == "0"
  end
end

#sunion(*keys) ⇒ Array<String>

Add multiple sets.

Parameters:

  • keys (String, Array<String>)

    keys pointing to sets to unify

Returns:

  • (Array<String>)

    members in the union


156
157
158
# File 'lib/redis/commands/sets.rb', line 156

def sunion(*keys)
  send_command([:sunion, *keys])
end

#sunionstore(destination, *keys) ⇒ Integer

Add multiple sets and store the resulting set in a key.

Parameters:

  • destination (String)

    destination key

  • keys (String, Array<String>)

    keys pointing to sets to unify

Returns:

  • (Integer)

    number of elements in the resulting set


165
166
167
# File 'lib/redis/commands/sets.rb', line 165

def sunionstore(destination, *keys)
  send_command([:sunionstore, destination, *keys])
end