Class: ActiveOrm::Redis::SortedSet
Instance Attribute Summary
#client
Attributes inherited from Base
#configuration
Class Method Summary
collapse
-
.all(key, opts = {}) ⇒ Object
-
.between(key, start, finish, opts = {}) ⇒ Object
-
.between_lex(key, min, max, opts = {}) ⇒ Object
-
.between_lex_reverse(key, min, max, opts = {}) ⇒ Object
-
.between_reverse(key, start, finish, opts = {}) ⇒ Object
-
.between_scores(key, min, max, opts = {}) ⇒ Object
-
.between_scores_reverse(key, min, max, opts = {}) ⇒ Object
-
.count(key) ⇒ Object
-
.count_between(key, min, max) ⇒ Object
-
.create(key, *args) ⇒ Object
-
.create_combination(key, keys, opts = {}) ⇒ Object
-
.create_intersection(key, keys, opts = {}) ⇒ Object
-
.destroy(key, at) ⇒ Object
-
.destroy_between(key, start, finish) ⇒ Object
-
.destroy_lex(key, min, max, opts = {}) ⇒ Object
-
.destroy_scores(key, min, max) ⇒ Object
-
.find(key, position, opts = {}) ⇒ Object
-
.find_score(key, position, opts = {}) ⇒ Object
-
.first(key, opts = {}) ⇒ Object
-
.first_score(key, opts = {}) ⇒ Object
-
.increment(key, value, count) ⇒ Object
-
.last(key, opts = {}) ⇒ Object
-
.last_score(key, opts = {}) ⇒ Object
-
.position(key, value) ⇒ Object
-
.position_reverse(key, value) ⇒ Object
-
.scan(key, cursor, opts = {}) ⇒ Object
-
.score(key, value) ⇒ Object
client, #initialize
Methods included from Base
#evaluate, #evaluate?
Methods inherited from Base
configuration, configuration=, configure
Class Method Details
.all(key, opts = {}) ⇒ Object
81
82
83
84
85
|
# File 'lib/active_orm/redis/sorted_set.rb', line 81
def self.all(key, opts={})
value = client.zrange(normalize_key(key), "-inf", "+inf", opts)
value = metatransform(value)
return(value)
end
|
.between(key, start, finish, opts = {}) ⇒ Object
45
46
47
48
49
|
# File 'lib/active_orm/redis/sorted_set.rb', line 45
def self.between(key, start, finish, opts={})
value = client.zrange(normalize_key(key), (start - 1), (finish - 1), opts)
value = metatransform(value)
return(value)
end
|
.between_lex(key, min, max, opts = {}) ⇒ Object
69
70
71
72
73
|
# File 'lib/active_orm/redis/sorted_set.rb', line 69
def self.between_lex(key, min, max, opts={})
value = client.zrangebylex(normalize_key(key), min, max, opts)
value = metatransform(value)
return(value)
end
|
.between_lex_reverse(key, min, max, opts = {}) ⇒ Object
75
76
77
78
79
|
# File 'lib/active_orm/redis/sorted_set.rb', line 75
def self.between_lex_reverse(key, min, max, opts={})
value = client.zrevrangebylex(normalize_key(key), min, max, opts)
value = metatransform(value)
return(value)
end
|
.between_reverse(key, start, finish, opts = {}) ⇒ Object
51
52
53
54
55
|
# File 'lib/active_orm/redis/sorted_set.rb', line 51
def self.between_reverse(key, start, finish, opts={})
value = client.zrevrange(normalize_key(key), (start - 1), (finish - 1), opts)
value = metatransform(value)
return(value)
end
|
.between_scores(key, min, max, opts = {}) ⇒ Object
57
58
59
60
61
|
# File 'lib/active_orm/redis/sorted_set.rb', line 57
def self.between_scores(key, min, max, opts={})
value = client.zrangebyscore(normalize_key(key), min, max, opts)
value = metatransform(value)
return(value)
end
|
.between_scores_reverse(key, min, max, opts = {}) ⇒ Object
63
64
65
66
67
|
# File 'lib/active_orm/redis/sorted_set.rb', line 63
def self.between_scores_reverse(key, min, max, opts={})
value = client.zrevrangebyscore(normalize_key(key), min, max, opts)
value = metatransform(value)
return(value)
end
|
.count(key) ⇒ Object
103
104
105
|
# File 'lib/active_orm/redis/sorted_set.rb', line 103
def self.count(key)
client.zcard(normalize_key(key))
end
|
.count_between(key, min, max) ⇒ Object
107
108
109
|
# File 'lib/active_orm/redis/sorted_set.rb', line 107
def self.count_between(key, min, max)
client.zcount(normalize_key(key), min, max)
end
|
.create(key, *args) ⇒ Object
111
112
113
|
# File 'lib/active_orm/redis/sorted_set.rb', line 111
def self.create(key, *args)
client.zadd(normalize_key(key), args)
end
|
.create_combination(key, keys, opts = {}) ⇒ Object
119
120
121
|
# File 'lib/active_orm/redis/sorted_set.rb', line 119
def self.create_combination(key, keys, opts={})
client.zunionstore(normalize_key(key), keys, opts)
end
|
.create_intersection(key, keys, opts = {}) ⇒ Object
115
116
117
|
# File 'lib/active_orm/redis/sorted_set.rb', line 115
def self.create_intersection(key, keys, opts={})
client.zinterstore(normalize_key(key), keys, opts)
end
|
.destroy(key, at) ⇒ Object
127
128
129
|
# File 'lib/active_orm/redis/sorted_set.rb', line 127
def self.destroy(key, at)
client.zrem(normalize_key(key), at)
end
|
.destroy_between(key, start, finish) ⇒ Object
131
132
133
|
# File 'lib/active_orm/redis/sorted_set.rb', line 131
def self.destroy_between(key, start, finish)
client.zremrangebyrank(normalize_key(key), (start - 1), (finish - 1))
end
|
.destroy_lex(key, min, max, opts = {}) ⇒ Object
139
140
141
|
# File 'lib/active_orm/redis/sorted_set.rb', line 139
def self.destroy_lex(key, min, max, opts={})
client.zrevrangebylex(normalize_key(key), max, min, opts)
end
|
.destroy_scores(key, min, max) ⇒ Object
135
136
137
|
# File 'lib/active_orm/redis/sorted_set.rb', line 135
def self.destroy_scores(key, min, max)
client.zremrangebyscore(normalize_key(key), min, max)
end
|
.find(key, position, opts = {}) ⇒ Object
3
4
5
6
7
8
|
# File 'lib/active_orm/redis/sorted_set.rb', line 3
def self.find(key, position, opts={})
value = client.zrange(normalize_key(key), (position - 1), (position - 1), opts)
value = value.first
value = metamorph(value) if evaluate?
return(value)
end
|
.find_score(key, position, opts = {}) ⇒ Object
10
11
12
13
14
15
|
# File 'lib/active_orm/redis/sorted_set.rb', line 10
def self.find_score(key, position, opts={})
value = client.zrangebyscore(normalize_key(key), position, position, opts)
value = value.first
value = metamorph(value) if evaluate?
return(value)
end
|
.first(key, opts = {}) ⇒ Object
17
18
19
20
21
22
|
# File 'lib/active_orm/redis/sorted_set.rb', line 17
def self.first(key, opts={})
value = client.zrange(normalize_key(key), 0, 0, opts)
value = value.first
value = metamorph(value) if evaluate?
return(value)
end
|
.first_score(key, opts = {}) ⇒ Object
24
25
26
27
28
29
|
# File 'lib/active_orm/redis/sorted_set.rb', line 24
def self.first_score(key, opts={})
value = client.zrangebyscore(normalize_key(key), 1, 1, opts)
value = value.first
value = metamorph(value) if evaluate?
return(value)
end
|
.increment(key, value, count) ⇒ Object
123
124
125
|
# File 'lib/active_orm/redis/sorted_set.rb', line 123
def self.increment(key, value, count)
client.zincrby(normalize_key(key), count, value)
end
|
.last(key, opts = {}) ⇒ Object
31
32
33
34
35
36
|
# File 'lib/active_orm/redis/sorted_set.rb', line 31
def self.last(key, opts={})
value = client.zrevrange(normalize_key(key), 0, 0, opts)
value = value.first
value = metamorph(value) if evaluate?
return(value)
end
|
.last_score(key, opts = {}) ⇒ Object
38
39
40
41
42
43
|
# File 'lib/active_orm/redis/sorted_set.rb', line 38
def self.last_score(key, opts={})
value = client.zrevrangebyscore(normalize_key(key), 1, 1, opts)
value = value.first
value = metamorph(value) if evaluate?
return(value)
end
|
.position(key, value) ⇒ Object
87
88
89
90
91
|
# File 'lib/active_orm/redis/sorted_set.rb', line 87
def self.position(key, value)
value = client.zrank(normalize_key(key), value)
value = value + 1 unless value.nil?
return(value)
end
|
.position_reverse(key, value) ⇒ Object
93
94
95
96
97
|
# File 'lib/active_orm/redis/sorted_set.rb', line 93
def self.position_reverse(key, value)
value = client.zrevrank(normalize_key(key), value)
value = value + 1 unless value.nil?
return(value)
end
|
.scan(key, cursor, opts = {}) ⇒ Object
143
144
145
|
# File 'lib/active_orm/redis/sorted_set.rb', line 143
def self.scan(key, cursor, opts={})
client.zscan(normalize_key(key), cursor, opts)
end
|
.score(key, value) ⇒ Object
99
100
101
|
# File 'lib/active_orm/redis/sorted_set.rb', line 99
def self.score(key, value)
client.zscore(normalize_key(key), value)
end
|