Module: Protocol::Redis::Methods::Strings

Defined in:
lib/protocol/redis/methods/strings.rb

Instance Method Summary collapse

Instance Method Details

#append(key, value) ⇒ Object

Append a value to a key. O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.

Parameters:

  • key (Key)
  • value (String)

See Also:



32
33
34
 
# File 'lib/protocol/redis/methods/strings.rb', line 32

def append(key, value)
  return call('APPEND', key, value)
end

#bitcount(key, *range) ⇒ Object

Count set bits in a string. O(N).

Parameters:

  • key (Key)

See Also:



39
40
41
 
# File 'lib/protocol/redis/methods/strings.rb', line 39

def bitcount(key, *range)
  return call('BITCOUNT', key, *range)
end

#decr(key) ⇒ Object

Decrement the integer value of a key by one. O(1).

Parameters:

  • key (Key)

See Also:



46
47
48
 
# File 'lib/protocol/redis/methods/strings.rb', line 46

def decr(key)
  return call('DECR', key)
end

#decrby(key, decrement) ⇒ Object

Decrement the integer value of a key by the given number. O(1).

Parameters:

  • key (Key)
  • decrement (Integer)

See Also:



54
55
56
 
# File 'lib/protocol/redis/methods/strings.rb', line 54

def decrby(key, decrement)
  return call('DECRBY', key, decrement)
end

#get(key) ⇒ Object

Get the value of a key. O(1).

Parameters:

  • key (Key)

See Also:



61
62
63
 
# File 'lib/protocol/redis/methods/strings.rb', line 61

def get(key)
  return call('GET', key)
end

#getbit(key, offset) ⇒ Object

Returns the bit value at offset in the string value stored at key. O(1).

Parameters:

  • key (Key)
  • offset (Integer)

See Also:



69
70
71
 
# File 'lib/protocol/redis/methods/strings.rb', line 69

def getbit(key, offset)
  return call('GETBIT', key, offset)
end

#getrange(key, start_index, end_index) ⇒ Object

Get a substring of the string stored at a key. O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.

Parameters:

  • key (Key)
  • start (Integer)
  • end (Integer)

See Also:



78
79
80
 
# File 'lib/protocol/redis/methods/strings.rb', line 78

def getrange(key, start_index, end_index)
  return call('GETRANGE', key, start_index, end_index)
end

#getset(key, value) ⇒ Object

Set the string value of a key and return its old value. O(1).

Parameters:

  • key (Key)
  • value (String)

See Also:



86
87
88
 
# File 'lib/protocol/redis/methods/strings.rb', line 86

def getset(key, value)
  return call('GETSET', key, value)
end

#incr(key) ⇒ Object

Increment the integer value of a key by one. O(1).

Parameters:

  • key (Key)

See Also:



93
94
95
 
# File 'lib/protocol/redis/methods/strings.rb', line 93

def incr(key)
  return call('INCR', key)
end

#incrby(key, increment) ⇒ Object

Increment the integer value of a key by the given amount. O(1).

Parameters:

  • key (Key)
  • increment (Integer)

See Also:



101
102
103
 
# File 'lib/protocol/redis/methods/strings.rb', line 101

def incrby(key, increment)
  return call('INCRBY', key, increment)
end

#incrbyfloat(key, increment) ⇒ Object

Increment the float value of a key by the given amount. O(1).

Parameters:

  • key (Key)
  • increment (Double)

See Also:



109
110
111
 
# File 'lib/protocol/redis/methods/strings.rb', line 109

def incrbyfloat(key, increment)
  return call('INCRBYFLOAT', key, increment)
end

#mget(key, *keys) ⇒ Object

Get the values of all the given keys. O(N) where N is the number of keys to retrieve.

Parameters:

  • key (Key)

See Also:



116
117
118
 
# File 'lib/protocol/redis/methods/strings.rb', line 116

def mget(key, *keys)
  return call('MGET', key, *keys)
end

#mset(pairs) ⇒ Object

Set multiple keys to multiple values. O(N) where N is the number of keys to set.

See Also:



122
123
124
125
 
# File 'lib/protocol/redis/methods/strings.rb', line 122

def mset(pairs)
  flattened_pairs = pairs.keys.zip(pairs.values).flatten
  return call('MSET', *flattened_pairs)
end

#msetnx(pairs) ⇒ Object

Set multiple keys to multiple values, only if none of the keys exist. O(N) where N is the number of keys to set.

See Also:



129
130
131
132
 
# File 'lib/protocol/redis/methods/strings.rb', line 129

def msetnx(pairs)
  flattened_pairs = pairs.keys.zip(pairs.values).flatten
  return call('MSETNX', *flattened_pairs)
end

#psetex(key, milliseconds, value) ⇒ Object

Set the value and expiration in milliseconds of a key. O(1).

Parameters:

  • key (Key)
  • milliseconds (Integer)
  • value (String)

See Also:



139
140
141
 
# File 'lib/protocol/redis/methods/strings.rb', line 139

def psetex(key, milliseconds, value)
  call('PSETEX', key, milliseconds, value)
end

#set(key, value, update: nil, seconds: nil, milliseconds: nil) ⇒ Object

Set the string value of a key. O(1).

Parameters:

  • key (Key)
  • value (String)
  • expiration (Enum)
  • update (Boolean, nil) (defaults to: nil) —

    If true, only update elements that already exist (never add elements). If false, don’t update existing elements (only add new elements).

See Also:



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/protocol/redis/methods/strings.rb', line 149

def set(key, value, update: nil, seconds: nil, milliseconds: nil)
  arguments = []

  if seconds
    arguments << 'EX' << seconds
  end

  if milliseconds
    arguments << 'PX' << milliseconds
  end

  if update == true
    arguments << "XX"
  elsif update == false
    arguments << "NX"
  end

  call('SET', key, value, *arguments)
end

#setbit(key, offset, value) ⇒ Object

Sets or clears the bit at offset in the string value stored at key. O(1).

Parameters:

  • key (Key)
  • offset (Integer)
  • value (Integer)

See Also:



174
175
176
 
# File 'lib/protocol/redis/methods/strings.rb', line 174

def setbit(key, offset, value)
  call('SETBIT', key, offset, value)
end

#setex(key, seconds, value) ⇒ Object

Set the value and expiration of a key. O(1).

Parameters:

  • key (Key)
  • seconds (Integer)
  • value (String)

See Also:



183
184
185
 
# File 'lib/protocol/redis/methods/strings.rb', line 183

def setex(key, seconds, value)
  call('SETEX', key, seconds, value)
end

#setnx(key, value) ⇒ Object

Set the value of a key, only if the key does not exist. O(1).

Parameters:

  • key (Key)
  • value (String)

See Also:



191
192
193
 
# File 'lib/protocol/redis/methods/strings.rb', line 191

def setnx(key, value)
  call('SETNX', key, value)
end

#setrange(key, offset, value) ⇒ Object

Overwrite part of a string at key starting at the specified offset. O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.

Parameters:

  • key (Key)
  • offset (Integer)
  • value (String)

See Also:



200
201
202
 
# File 'lib/protocol/redis/methods/strings.rb', line 200

def setrange(key, offset, value)
  call('SETRANGE', key, offset, value)
end

#strlen(key) ⇒ Object

Get the length of the value stored in a key. O(1).

Parameters:

  • key (Key)

See Also:



207
208
209
 
# File 'lib/protocol/redis/methods/strings.rb', line 207

def strlen(key)
  call('STRLEN', key)
end