Class: ActiveOrm::Redis::SortedSet

Inherits:
ActiveOrm::Redis show all
Defined in:
lib/active_orm/redis/sorted_set.rb

Instance Attribute Summary

Attributes inherited from ActiveOrm::Redis

#client

Attributes inherited from Base

#configuration

Class Method Summary collapse

Methods inherited from ActiveOrm::Redis

client, #initialize

Methods included from Base

#evaluate, #evaluate?

Methods inherited from Base

configuration, configuration=, configure

Constructor Details

This class inherits a constructor from ActiveOrm::Redis

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'.freeze, '+inf'.freeze, opts)
  value = metatransform(value)
  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)
  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)
  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)
  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)
  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)
  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)
  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?
  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?
  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?
  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?
  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?
  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?
  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?
  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?
  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