Class: Familia::SortedSet

Inherits:
RedisType show all
Defined in:
lib/familia/redistype/types/sorted_set.rb

Instance Attribute Summary

Attributes inherited from RedisType

#dump_method, #keystring, #load_method, #opts, #parent

Attributes included from Features

#features_enabled

Instance Method Summary collapse

Methods inherited from RedisType

#class?, #db, #initialize, #parent?, #parent_class?, #parent_instance?, #redis, #rediskey, #uri

Methods included from Features

#feature

Methods included from RedisType::ClassMethods

#db, #has_relations?, #inherited, #register, #uri, #valid_keys_only

Methods included from RedisType::Serialization

#deserialize_value, #deserialize_values, #deserialize_values_with_nil, #serialize_value

Methods included from RedisType::Commands

#delete!, #echo, #exists?, #expire, #expireat, #move, #persist, #realttl, #rename, #renamenx, #type

Methods included from Base

add_feature, #generate_id, #update_expiration, #uuid

Constructor Details

This class inherits a constructor from Familia::RedisType

Instance Method Details

#<<(val) ⇒ Integer

Note:

This is a non-standard operation for sorted sets as it doesn’t allow specifying a custom score. Use ‘add` or `[]=` for more control.

Adds a new element to the sorted set with the current timestamp as the score.

This method provides a convenient way to add elements to the sorted set without explicitly specifying a score. It uses the current Unix timestamp as the score, which effectively sorts elements by their insertion time.

Examples:

sorted_set << "new_element"

Parameters:

  • val (Object) —

    The value to be added to the sorted set.

Returns:

  • (Integer) —

    Returns 1 if the element is new and added, 0 if the element already existed and the score was updated.



34
35
36
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 34

def <<(val)
  add(Time.now.to_i, val)
end

#[]=(val, score) ⇒ Object

NOTE: The argument order is the reverse of #add. We do this to more naturally align with how the [] and []= methods are used.

e.g.

obj.metrics[VALUE] = SCORE
obj.metrics[VALUE]  # => SCORE



45
46
47
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 45

def []=(val, score)
  add score, val
end

#add(score, val) ⇒ Object 



49
50
51
52
53
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 49

def add(score, val)
  ret = redis.zadd rediskey, score, serialize_value(val)
  update_expiration
  ret
end

#at(idx) ⇒ Object 



221
222
223
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 221

def at(idx)
  range(idx, idx).first
end

#collect(&blk) ⇒ Object 



111
112
113
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 111

def collect(&blk)
  members.collect(&blk)
end

#collectraw(&blk) ⇒ Object 



127
128
129
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 127

def collectraw(&blk)
  membersraw.collect(&blk)
end

#decrement(val, by = 1) ⇒ Object Also known as: decr, decrby 



201
202
203
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 201

def decrement(val, by = 1)
  increment val, -by
end

#each(&blk) ⇒ Object 



103
104
105
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 103

def each(&blk)
  members.each(&blk)
end

#each_with_index(&blk) ⇒ Object 



107
108
109
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 107

def each_with_index(&blk)
  members.each_with_index(&blk)
end

#eachraw(&blk) ⇒ Object 



119
120
121
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 119

def eachraw(&blk)
  membersraw.each(&blk)
end

#eachraw_with_index(&blk) ⇒ Object 



123
124
125
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 123

def eachraw_with_index(&blk)
  membersraw.each_with_index(&blk)
end

#element_count ⇒ Integer Also known as: size

Returns the number of elements in the sorted set

Returns:

  • (Integer) —

    number of elements



8
9
10
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 8

def element_count
  redis.zcard rediskey
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


13
14
15
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 13

def empty?
  element_count.zero?
end

#first ⇒ Object

Return the first element in the list. Redis: ZRANGE(0)



226
227
228
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 226

def first
  at(0)
end

#increment(val, by = 1) ⇒ Object Also known as: incr, incrby 



195
196
197
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 195

def increment(val, by = 1)
  redis.zincrby(rediskey, by, val).to_i
end

#last ⇒ Object

Return the last element in the list. Redis: ZRANGE(-1)



231
232
233
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 231

def last
  at(-1)
end

#member?(val) ⇒ Boolean Also known as: include?

Returns:

  • (Boolean) 


61
62
63
64
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 61

def member?(val)
  Familia.trace :MEMBER, redis, "#{val}<#{val.class}>", caller(1..1) if Familia.debug?
  !rank(val).nil?
end

#members(count = -1,, opts = {}) ⇒ Object Also known as: to_a, all 



79
80
81
82
83
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 79

def members(count = -1, opts = {})
  count -= 1 if count.positive?
  elements = membersraw count, opts
  deserialize_values(*elements)
end

#membersraw(count = -1,, opts = {}) ⇒ Object 



87
88
89
90
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 87

def membersraw(count = -1, opts = {})
  count -= 1 if count.positive?
  rangeraw 0, count, opts
end

#range(sidx, eidx, opts = {}) ⇒ Object 



135
136
137
138
139
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 135

def range(sidx, eidx, opts = {})
  echo :range, caller(1..1).first if Familia.debug
  elements = rangeraw(sidx, eidx, opts)
  deserialize_values(*elements)
end

#rangebyscore(sscore, escore, opts = {}) ⇒ Object

e.g. obj.metrics.rangebyscore (now-12.hours), now, :limit => [0, 10]



163
164
165
166
167
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 163

def rangebyscore(sscore, escore, opts = {})
  echo :rangebyscore, caller(1..1).first if Familia.debug
  elements = rangebyscoreraw(sscore, escore, opts)
  deserialize_values(*elements)
end

#rangebyscoreraw(sscore, escore, opts = {}) ⇒ Object 



169
170
171
172
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 169

def rangebyscoreraw(sscore, escore, opts = {})
  echo :rangebyscoreraw, caller(1..1).first if Familia.debug
  redis.zrangebyscore(rediskey, sscore, escore, **opts)
end

#rangeraw(sidx, eidx, opts = {}) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 141

def rangeraw(sidx, eidx, opts = {})
  # NOTE: :withscores (no underscore) is the correct naming for the
  # redis-4.x gem. We pass :withscores through explicitly b/c
  # redis.zrange et al only accept that one optional argument.
  # Passing `opts`` through leads to an ArgumentError:
  #
  #   sorted_sets.rb:374:in `zrevrange': wrong number of arguments (given 4, expected 3) (ArgumentError)
  #
  redis.zrange(rediskey, sidx, eidx, **opts)
end

#rank(v) ⇒ Object

rank of member v when ordered lowest to highest (starts at 0)



68
69
70
71
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 68

def rank(v)
  ret = redis.zrank rediskey, serialize_value(v, strict_values: false)
  ret&.to_i
end

#remove_element(value) ⇒ Integer Also known as: remove

Removes a member from the sorted set

Parameters:

  • value —

    The value to remove from the sorted set

Returns:

  • (Integer) —

    The number of members that were removed (0 or 1)



210
211
212
213
214
215
216
217
218
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 210

def remove_element(value)
  Familia.trace :REMOVE_ELEMENT, redis, "#{value}<#{value.class}>", caller(1..1) if Familia.debug?
  # We use `strict_values: false` here to allow for the deletion of values
  # that are in the sorted set. If it's a horreum object, the value is
  # the identifier and not a serialized version of the object. So either
  # the value exists in the sorted set or it doesn't -- we don't need to
  # raise an error if it's not found.
  redis.zrem rediskey, serialize_value(value, strict_values: false)
end

#remrangebyrank(srank, erank) ⇒ Object 



187
188
189
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 187

def remrangebyrank(srank, erank)
  redis.zremrangebyrank rediskey, srank, erank
end

#remrangebyscore(sscore, escore) ⇒ Object 



191
192
193
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 191

def remrangebyscore(sscore, escore)
  redis.zremrangebyscore rediskey, sscore, escore
end

#revmembers(count = -1,, opts = {}) ⇒ Object 



92
93
94
95
96
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 92

def revmembers(count = -1, opts = {})
  count -= 1 if count.positive?
  elements = revmembersraw count, opts
  deserialize_values(*elements)
end

#revmembersraw(count = -1,, opts = {}) ⇒ Object 



98
99
100
101
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 98

def revmembersraw(count = -1, opts = {})
  count -= 1 if count.positive?
  revrangeraw 0, count, opts
end

#revrange(sidx, eidx, opts = {}) ⇒ Object 



152
153
154
155
156
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 152

def revrange(sidx, eidx, opts = {})
  echo :revrange, caller(1..1).first if Familia.debug
  elements = revrangeraw(sidx, eidx, opts)
  deserialize_values(*elements)
end

#revrangebyscore(sscore, escore, opts = {}) ⇒ Object

e.g. obj.metrics.revrangebyscore (now-12.hours), now, :limit => [0, 10]



175
176
177
178
179
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 175

def revrangebyscore(sscore, escore, opts = {})
  echo :revrangebyscore, caller(1..1).first if Familia.debug
  elements = revrangebyscoreraw(sscore, escore, opts)
  deserialize_values(*elements)
end

#revrangebyscoreraw(sscore, escore, opts = {}) ⇒ Object 



181
182
183
184
185
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 181

def revrangebyscoreraw(sscore, escore, opts = {})
  echo :revrangebyscoreraw, caller(1..1).first if Familia.debug
  opts[:with_scores] = true if opts[:withscores]
  redis.zrevrangebyscore(rediskey, sscore, escore, opts)
end

#revrangeraw(sidx, eidx, opts = {}) ⇒ Object 



158
159
160
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 158

def revrangeraw(sidx, eidx, opts = {})
  redis.zrevrange(rediskey, sidx, eidx, **opts)
end

#revrank(v) ⇒ Object

rank of member v when ordered highest to lowest (starts at 0)



74
75
76
77
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 74

def revrank(v)
  ret = redis.zrevrank rediskey, serialize_value(v, strict_values: false)
  ret&.to_i
end

#score(val) ⇒ Object Also known as: [] 



55
56
57
58
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 55

def score(val)
  ret = redis.zscore rediskey, serialize_value(val, strict_values: false)
  ret&.to_f
end

#select(&blk) ⇒ Object 



115
116
117
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 115

def select(&blk)
  members.select(&blk)
end

#selectraw(&blk) ⇒ Object 



131
132
133
 
# File 'lib/familia/redistype/types/sorted_set.rb', line 131

def selectraw(&blk)
  membersraw.select(&blk)
end