Class: ActiveRedisDB::SortedSet

Inherits:
Base
  • Object
show all
Defined in:
lib/active_redis_db/sorted_set.rb

Class Method Summary collapse

Methods inherited from Base

client, evaluate

Class Method Details

.all(key, opts = {}) ⇒ Object 



86
87
88
89
90
 
# File 'lib/active_redis_db/sorted_set.rb', line 86

def all(key, opts = {})
  value = client.zrange(normalize_key(key), 0, -1, opts)
  value = metatransform(value)
  value
end

.all_reverse(key, opts = {}) ⇒ Object 



92
93
94
95
96
 
# File 'lib/active_redis_db/sorted_set.rb', line 92

def all_reverse(key, opts = {})
  value = client.zrevrange(normalize_key(key), 0, -1, opts)
  value = metatransform(value)
  value
end

.between(key, start, finish, opts = {}) ⇒ Object 



50
51
52
53
54
 
# File 'lib/active_redis_db/sorted_set.rb', line 50

def between(key, start, finish, opts = {})
  value = client.zrange(normalize_key(key), (start - 1), (finish - 1), opts)
  value = metatransform(value)
  value
end

.between_lex(key, min, max, opts = {}) ⇒ Object 



74
75
76
77
78
 
# File 'lib/active_redis_db/sorted_set.rb', line 74

def between_lex(key, min, max, opts = {})
  value = client.zrangebylex(normalize_key(key), min, max, opts)
  value = metatransform(value)
  value
end

.between_lex_reverse(key, min, max, opts = {}) ⇒ Object 



80
81
82
83
84
 
# File 'lib/active_redis_db/sorted_set.rb', line 80

def between_lex_reverse(key, min, max, opts = {})
  value = client.zrevrangebylex(normalize_key(key), min, max, opts)
  value = metatransform(value)
  value
end

.between_reverse(key, start, finish, opts = {}) ⇒ Object 



56
57
58
59
60
 
# File 'lib/active_redis_db/sorted_set.rb', line 56

def between_reverse(key, start, finish, opts = {})
  value = client.zrevrange(normalize_key(key), (start - 1), (finish - 1), opts)
  value = metatransform(value)
  value
end

.between_scores(key, min, max, opts = {}) ⇒ Object 



62
63
64
65
66
 
# File 'lib/active_redis_db/sorted_set.rb', line 62

def between_scores(key, min, max, opts = {})
  value = client.zrangebyscore(normalize_key(key), min, max, opts)
  value = metatransform(value)
  value
end

.between_scores_reverse(key, min, max, opts = {}) ⇒ Object 



68
69
70
71
72
 
# File 'lib/active_redis_db/sorted_set.rb', line 68

def between_scores_reverse(key, min, max, opts = {})
  value = client.zrevrangebyscore(normalize_key(key), min, max, opts)
  value = metatransform(value)
  value
end

.count(key) ⇒ Object 



114
115
116
 
# File 'lib/active_redis_db/sorted_set.rb', line 114

def count(key)
  client.zcard(normalize_key(key))
end

.count_between(key, min, max) ⇒ Object 



118
119
120
 
# File 'lib/active_redis_db/sorted_set.rb', line 118

def count_between(key, min, max)
  client.zcount(normalize_key(key), min, max)
end

.create(key, *args) ⇒ Object 



122
123
124
 
# File 'lib/active_redis_db/sorted_set.rb', line 122

def create(key, *args)
  client.zadd(normalize_key(key), args)
end

.create_combination(key, keys, opts = {}) ⇒ Object 



130
131
132
 
# File 'lib/active_redis_db/sorted_set.rb', line 130

def create_combination(key, keys, opts = {})
  client.zunionstore(normalize_key(key), keys, opts)
end

.create_intersection(key, keys, opts = {}) ⇒ Object 



126
127
128
 
# File 'lib/active_redis_db/sorted_set.rb', line 126

def create_intersection(key, keys, opts = {})
  client.zinterstore(normalize_key(key), keys, opts)
end

.decrement(key, value, count) ⇒ Object 



138
139
140
 
# File 'lib/active_redis_db/sorted_set.rb', line 138

def decrement(key, value, count)
  client.zincrby(normalize_key(key), -(count.abs), value)
end

.destroy(key, at) ⇒ Object 



142
143
144
 
# File 'lib/active_redis_db/sorted_set.rb', line 142

def destroy(key, at)
  client.zrem(normalize_key(key), at)
end

.destroy_between(key, start, finish) ⇒ Object 



146
147
148
 
# File 'lib/active_redis_db/sorted_set.rb', line 146

def destroy_between(key, start, finish)
  client.zremrangebyrank(normalize_key(key), (start - 1), (finish - 1))
end

.destroy_lex(key, min, max, opts = {}) ⇒ Object 



154
155
156
 
# File 'lib/active_redis_db/sorted_set.rb', line 154

def destroy_lex(key, min, max, opts = {})
  client.zrevrangebylex(normalize_key(key), max, min, opts)
end

.destroy_scores(key, min, max) ⇒ Object 



150
151
152
 
# File 'lib/active_redis_db/sorted_set.rb', line 150

def destroy_scores(key, min, max)
  client.zremrangebyscore(normalize_key(key), min, max)
end

.find(key, position, opts = {}) ⇒ Object 



6
7
8
9
10
11
12
13
 
# File 'lib/active_redis_db/sorted_set.rb', line 6

def find(key, position, opts = {})
  position -= 1

  value = client.zrange(normalize_key(key), position, position, opts)
  value = value.first
  value = metamorph(value) if evaluate?
  value
end

.find_score(key, position, opts = {}) ⇒ Object 



15
16
17
18
19
20
 
# File 'lib/active_redis_db/sorted_set.rb', line 15

def find_score(key, position, opts = {})
  value = client.zrangebyscore(normalize_key(key), position, position, opts)
  value = value.first
  value = metamorph(value) if evaluate?
  value
end

.first(key, opts = {}) ⇒ Object 



22
23
24
25
26
27
 
# File 'lib/active_redis_db/sorted_set.rb', line 22

def first(key, opts = {})
  value = client.zrange(normalize_key(key), 0, 0, opts)
  value = value.first
  value = metamorph(value) if evaluate?
  value
end

.first_score(key, opts = {}) ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/active_redis_db/sorted_set.rb', line 29

def first_score(key, opts = {})
  value = client.zrangebyscore(normalize_key(key), 1, 1, opts)
  value = value.first
  value = metamorph(value) if evaluate?
  value
end

.increment(key, value, count) ⇒ Object 



134
135
136
 
# File 'lib/active_redis_db/sorted_set.rb', line 134

def increment(key, value, count)
  client.zincrby(normalize_key(key), count, value)
end

.last(key, opts = {}) ⇒ Object 



36
37
38
39
40
41
 
# File 'lib/active_redis_db/sorted_set.rb', line 36

def last(key, opts = {})
  value = client.zrevrange(normalize_key(key), 0, 0, opts)
  value = value.first
  value = metamorph(value) if evaluate?
  value
end

.last_score(key, opts = {}) ⇒ Object 



43
44
45
46
47
48
 
# File 'lib/active_redis_db/sorted_set.rb', line 43

def last_score(key, opts = {})
  value = client.zrevrangebyscore(normalize_key(key), 1, 1, opts)
  value = value.first
  value = metamorph(value) if evaluate?
  value
end

.position(key, value) ⇒ Object 



98
99
100
101
102
 
# File 'lib/active_redis_db/sorted_set.rb', line 98

def position(key, value)
  value = client.zrank(normalize_key(key), value)
  value += 1 unless value.nil?
  value
end

.position_reverse(key, value) ⇒ Object 



104
105
106
107
108
 
# File 'lib/active_redis_db/sorted_set.rb', line 104

def position_reverse(key, value)
  value = client.zrevrank(normalize_key(key), value)
  value += 1 unless value.nil?
  value
end

.scan(key, cursor, opts = {}) ⇒ Object 



158
159
160
 
# File 'lib/active_redis_db/sorted_set.rb', line 158

def scan(key, cursor, opts = {})
  client.zscan(normalize_key(key), cursor, opts)
end

.score(key, value) ⇒ Object 



110
111
112
 
# File 'lib/active_redis_db/sorted_set.rb', line 110

def score(key, value)
  client.zscore(normalize_key(key), value)
end