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.



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

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



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

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

#add(score, val) ⇒ Object 



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

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

#at(idx) ⇒ Object 



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

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

#collect(&blk) ⇒ Object 



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

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

#collectraw(&blk) ⇒ Object 



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

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

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



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

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

#each(&blk) ⇒ Object 



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

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

#each_with_index(&blk) ⇒ Object 



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

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

#eachraw(&blk) ⇒ Object 



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

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

#eachraw_with_index(&blk) ⇒ Object 



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

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



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

def element_count
  redis.zcard rediskey
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


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

def empty?
  element_count.zero?
end

#first ⇒ Object

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



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

def first
  at(0)
end

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



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

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)



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

def last
  at(-1)
end

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

Returns:

  • (Boolean) 


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

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 



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

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

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



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

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

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



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

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]



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

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 



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

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 



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

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)



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

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)



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

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 



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

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

#remrangebyscore(sscore, escore) ⇒ Object 



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

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

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



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

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

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



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

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

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



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

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]



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

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 



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

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 



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

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)



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

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

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



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

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

#select(&blk) ⇒ Object 



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

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

#selectraw(&blk) ⇒ Object 



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

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