Class: ActiveOrm::Redis::SortedSet

Inherits:
Base
  • Object
show all
Defined in:
lib/active_orm/redis/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_orm/redis/sorted_set.rb', line 86

def all(key, opts = {})
  value = client.zrange(normalize_key(key), '-inf', '+inf', opts)
  value = metatransform(value)
  value
end

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



50
51
52
53
54
 
# File 'lib/active_orm/redis/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_orm/redis/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_orm/redis/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_orm/redis/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_orm/redis/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_orm/redis/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 



108
109
110
 
# File 'lib/active_orm/redis/sorted_set.rb', line 108

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

.count_between(key, min, max) ⇒ Object 



112
113
114
 
# File 'lib/active_orm/redis/sorted_set.rb', line 112

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

.create(key, *args) ⇒ Object 



116
117
118
 
# File 'lib/active_orm/redis/sorted_set.rb', line 116

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

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



124
125
126
 
# File 'lib/active_orm/redis/sorted_set.rb', line 124

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

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



120
121
122
 
# File 'lib/active_orm/redis/sorted_set.rb', line 120

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

.destroy(key, at) ⇒ Object 



132
133
134
 
# File 'lib/active_orm/redis/sorted_set.rb', line 132

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

.destroy_between(key, start, finish) ⇒ Object 



136
137
138
 
# File 'lib/active_orm/redis/sorted_set.rb', line 136

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

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



144
145
146
 
# File 'lib/active_orm/redis/sorted_set.rb', line 144

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

.destroy_scores(key, min, max) ⇒ Object 



140
141
142
 
# File 'lib/active_orm/redis/sorted_set.rb', line 140

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_orm/redis/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_orm/redis/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_orm/redis/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_orm/redis/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 



128
129
130
 
# File 'lib/active_orm/redis/sorted_set.rb', line 128

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_orm/redis/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_orm/redis/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 



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

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

.position_reverse(key, value) ⇒ Object 



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

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

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



148
149
150
 
# File 'lib/active_orm/redis/sorted_set.rb', line 148

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

.score(key, value) ⇒ Object 



104
105
106
 
# File 'lib/active_orm/redis/sorted_set.rb', line 104

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