github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

RMultimap.get should return RSet or RList interface instead of Set and List. #464

Browse Source
pull/610/head
Nikita 9 years ago
parent 008cd075e9
commit 951c8dd016
9 changed files with 627 additions and 562 deletions
Show Stats Download Patch File Download Diff File

314
redisson/src/main/java/org/redisson/RedissonListMultimap.java
Unescape Escape View File

@ -15,7 +15,6 @@
*/
package org.redisson;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@ -24,8 +23,10 @@ import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RFuture;
import org.redisson.api.RList;
import org.redisson.api.RListMultimap;
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.RedisCommands;
@ -51,6 +52,7 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
super(codec, connectionManager, name);
}
@Override
public RFuture<Integer> sizeAsync() {
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_INTEGER,
"local keys = redis.call('hgetall', KEYS[1]); " +
@ -65,43 +67,35 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
Arrays.<Object>asList(getName()));
}
@Override
public RFuture<Boolean> containsKeyAsync(Object key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, LLEN_VALUE, setName);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, LLEN_VALUE, setName);
}
@Override
public RFuture<Boolean> containsValueAsync(Object value) {
try {
byte[] valueState = codec.getMapValueEncoder().encode(value);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local keys = redis.call('hgetall', KEYS[1]); " +
"for i, v in ipairs(keys) do " +
"if i % 2 == 0 then " +
"local name = '{' .. KEYS[1] .. '}:' .. v; " +
"local items = redis.call('lrange', name, 0, -1) " +
"for i=1,#items do " +
"if items[i] == ARGV[1] then " +
"return 1; " +
"end; " +
byte[] valueState = encodeMapValue(value);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local keys = redis.call('hgetall', KEYS[1]); " +
"for i, v in ipairs(keys) do " +
"if i % 2 == 0 then " +
"local name = '{' .. KEYS[1] .. '}:' .. v; " +
"local items = redis.call('lrange', name, 0, -1) " +
"for i=1,#items do " +
"if items[i] == ARGV[1] then " +
"return 1; " +
"end; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(getName()), valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
"end; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(getName()), valueState);
}
@Override
@ -109,26 +103,23 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
return get(containsEntryAsync(key, value));
}
@Override
public RFuture<Boolean> containsEntryAsync(Object key, Object value) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
byte[] valueState = codec.getMapValueEncoder().encode(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local items = redis.call('lrange', KEYS[1], 0, -1) " +
"for i=1,#items do " +
"if items[i] == ARGV[1] then " +
"return 1; " +
"end; " +
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
byte[] valueState = encodeMapValue(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local items = redis.call('lrange', KEYS[1], 0, -1) " +
"for i=1,#items do " +
"if items[i] == ARGV[1] then " +
"return 1; " +
"end; " +
"return 0; ",
Collections.<Object>singletonList(setName), valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
"end; " +
"return 0; ",
Collections.<Object>singletonList(setName), valueState);
}
@Override
@ -136,76 +127,100 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
return get(putAsync(key, value));
}
@Override
public RFuture<Boolean> putAsync(K key, V value) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
byte[] valueState = codec.getMapValueEncoder().encode(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"redis.call('rpush', KEYS[2], ARGV[3]); " +
"return 1; ",
Arrays.<Object>asList(getName(), setName), keyState, keyHash, valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
byte[] valueState = encodeMapValue(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"redis.call('rpush', KEYS[2], ARGV[3]); " +
"return 1; ",
Arrays.<Object>asList(getName(), setName), keyState, keyHash, valueState);
}
@Override
public RFuture<Boolean> removeAsync(Object key, Object value) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
byte[] valueState = codec.getMapValueEncoder().encode(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local res = redis.call('lrem', KEYS[2], 1, ARGV[2]); "
+ "if res == 1 and redis.call('llen', KEYS[2]) == 0 then "
+ "redis.call('hdel', KEYS[1], ARGV[1]); "
+ "end; "
+ "return res; ",
Arrays.<Object>asList(getName(), setName), keyState, valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
byte[] valueState = encodeMapValue(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local res = redis.call('lrem', KEYS[2], 1, ARGV[2]); "
+ "if res == 1 and redis.call('llen', KEYS[2]) == 0 then "
+ "redis.call('hdel', KEYS[1], ARGV[1]); "
+ "end; "
+ "return res; ",
Arrays.<Object>asList(getName(), setName), keyState, valueState);
}
@Override
public RFuture<Boolean> putAllAsync(K key, Iterable<? extends V> values) {
try {
List<Object> params = new ArrayList<Object>();
byte[] keyState = codec.getMapKeyEncoder().encode(key);
params.add(keyState);
String keyHash = hash(keyState);
params.add(keyHash);
for (Object value : values) {
byte[] valueState = codec.getMapValueEncoder().encode(value);
params.add(valueState);
}
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN_AMOUNT,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"return redis.call('rpush', KEYS[2], unpack(ARGV, 3, #ARGV)); ",
Arrays.<Object>asList(getName(), setName), params.toArray());
} catch (IOException e) {
throw new IllegalArgumentException(e);
List<Object> params = new ArrayList<Object>();
byte[] keyState = encodeMapKey(key);
params.add(keyState);
String keyHash = hash(keyState);
params.add(keyHash);
for (Object value : values) {
byte[] valueState = encodeMapValue(value);
params.add(valueState);
}
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN_AMOUNT,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"return redis.call('rpush', KEYS[2], unpack(ARGV, 3, #ARGV)); ",
Arrays.<Object>asList(getName(), setName), params.toArray());
}
@Override
public List<V> get(K key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return new RedissonList<V>(codec, commandExecutor, setName);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
public RList<V> get(K key) {
final byte[] keyState = encodeMapKey(key);
final String keyHash = hash(keyState);
final String setName = getValuesName(keyHash);
return new RedissonList<V>(codec, commandExecutor, setName) {
@Override
public RFuture<Boolean> deleteAsync() {
return RedissonListMultimap.this.fastRemoveAsync(Arrays.<Object>asList(keyState), Arrays.<Object>asList(setName), RedisCommands.EVAL_BOOLEAN_AMOUNT);
}
@Override
public RFuture<Boolean> clearExpireAsync() {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> expireAsync(long timeToLive, TimeUnit timeUnit) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> expireAtAsync(long timestamp) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Long> remainTimeToLiveAsync() {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Void> renameAsync(String newName) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> renamenxAsync(String newName) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
};
}
@Override
@ -213,16 +228,13 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
return (List<V>) get(getAllAsync(key));
}
@Override
public RFuture<Collection<V>> getAllAsync(K key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, RedisCommands.LRANGE, setName, 0, -1);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, RedisCommands.LRANGE, setName, 0, -1);
}
@Override
@ -230,21 +242,18 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
return (List<V>) get(removeAllAsync(key));
}
@Override
public RFuture<Collection<V>> removeAllAsync(Object key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_LIST,
"redis.call('hdel', KEYS[1], ARGV[1]); " +
"local members = redis.call('lrange', KEYS[2], 0, -1); " +
"redis.call('del', KEYS[2]); " +
"return members; ",
Arrays.<Object>asList(getName(), setName), keyState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_LIST,
"redis.call('hdel', KEYS[1], ARGV[1]); " +
"local members = redis.call('lrange', KEYS[2], 0, -1); " +
"redis.call('del', KEYS[2]); " +
"return members; ",
Arrays.<Object>asList(getName(), setName), keyState);
}
@Override
@ -252,31 +261,29 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
return (List<V>) get(replaceValuesAsync(key, values));
}
@Override
public RFuture<Collection<V>> replaceValuesAsync(K key, Iterable<? extends V> values) {
try {
List<Object> params = new ArrayList<Object>();
byte[] keyState = codec.getMapKeyEncoder().encode(key);
params.add(keyState);
String keyHash = hash(keyState);
params.add(keyHash);
for (Object value : values) {
byte[] valueState = codec.getMapValueEncoder().encode(value);
params.add(valueState);
}
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_LIST,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"local members = redis.call('lrange', KEYS[2], 0, -1); " +
"redis.call('del', KEYS[2]); " +
"redis.call('rpush', KEYS[2], unpack(ARGV, 3, #ARGV)); " +
"return members; ",
Arrays.<Object>asList(getName(), setName), params.toArray());
} catch (Exception e) {
throw new IllegalArgumentException(e);
List<Object> params = new ArrayList<Object>();
byte[] keyState = encodeMapKey(key);
params.add(keyState);
String keyHash = hash(keyState);
params.add(keyHash);
for (Object value : values) {
byte[] valueState = encodeMapValue(value);
params.add(valueState);
}
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_LIST,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"local members = redis.call('lrange', KEYS[2], 0, -1); " +
"redis.call('del', KEYS[2]); " +
"redis.call('rpush', KEYS[2], unpack(ARGV, 3, #ARGV)); " +
"return members; ",
Arrays.<Object>asList(getName(), setName), params.toArray());
}
@Override
Iterator<V> valuesIterator() {
return new RedissonListMultimapIterator<K, V, V>(this, commandExecutor, codec) {
@Override
@ -286,6 +293,7 @@ public class RedissonListMultimap<K, V> extends RedissonMultimap<K, V> implement
};
}
@Override
RedissonMultiMapIterator<K, V, Entry<K, V>> entryIterator() {
return new RedissonListMultimapIterator<K, V, Map.Entry<K, V>>(this, commandExecutor, codec);
}

222
redisson/src/main/java/org/redisson/RedissonListMultimapCache.java
Unescape Escape View File

@ -15,13 +15,12 @@
*/
package org.redisson;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RFuture;
import org.redisson.api.RList;
import org.redisson.api.RListMultimapCache;
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.RedisCommands;
@ -50,31 +49,26 @@ public class RedissonListMultimapCache<K, V> extends RedissonListMultimap<K, V>
}
public RFuture<Boolean> containsKeyAsync(Object key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String valuesName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local value = redis.call('hget', KEYS[1], ARGV[2]); " +
"if value ~= false then " +
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate <= tonumber(ARGV[1]) then "
+ "return 0;"
+ "end; "
+ "return redis.call('llen', ARGV[3]) > 0 and 1 or 0;" +
"end;" +
"return 0; ",
Arrays.<Object>asList(getName(), getTimeoutSetName()), System.currentTimeMillis(), keyState, valuesName);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String valuesName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local value = redis.call('hget', KEYS[1], ARGV[2]); " +
"if value ~= false then " +
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate <= tonumber(ARGV[1]) then "
+ "return 0;"
+ "end; "
+ "return redis.call('llen', ARGV[3]) > 0 and 1 or 0;" +
"end;" +
"return 0; ",
Arrays.<Object>asList(getName(), getTimeoutSetName()), System.currentTimeMillis(), keyState, valuesName);
}
String getTimeoutSetName() {
@ -83,119 +77,97 @@ public class RedissonListMultimapCache<K, V> extends RedissonListMultimap<K, V>
public RFuture<Boolean> containsValueAsync(Object value) {
try {
byte[] valueState = codec.getMapValueEncoder().encode(value);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local keys = redis.call('hgetall', KEYS[1]); " +
"for i, v in ipairs(keys) do " +
"if i % 2 == 0 then " +
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], keys[i-1]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[2]) then " +
"local name = '{' .. KEYS[1] .. '}:' .. v; " +
"local items = redis.call('lrange', name, 0, -1) " +
"for i=1,#items do " +
"if items[i] == ARGV[1] then " +
"return 1; " +
"end; " +
byte[] valueState = encodeMapValue(value);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local keys = redis.call('hgetall', KEYS[1]); " +
"for i, v in ipairs(keys) do " +
"if i % 2 == 0 then " +
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], keys[i-1]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[2]) then " +
"local name = '{' .. KEYS[1] .. '}:' .. v; " +
"local items = redis.call('lrange', name, 0, -1) " +
"for i=1,#items do " +
"if items[i] == ARGV[1] then " +
"return 1; " +
"end; " +
"end; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(getName(), getTimeoutSetName()), valueState, System.currentTimeMillis());
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
"end; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(getName(), getTimeoutSetName()), valueState, System.currentTimeMillis());
}
public RFuture<Boolean> containsEntryAsync(Object key, Object value) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
byte[] valueState = codec.getMapValueEncoder().encode(value);
String valuesName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[1]) then " +
"local items = redis.call('lrange', KEYS[1], 0, -1); " +
"for i = 1, #items do " +
"if items[i] == ARGV[3] then " +
"return 1; " +
"end; " +
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
byte[] valueState = encodeMapValue(value);
String valuesName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[1]) then " +
"local items = redis.call('lrange', KEYS[1], 0, -1); " +
"for i = 1, #items do " +
"if items[i] == ARGV[3] then " +
"return 1; " +
"end; " +
"end; " +
"return 0; ",
Arrays.<Object>asList(valuesName, getTimeoutSetName()), System.currentTimeMillis(), keyState, valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
"end; " +
"end; " +
"return 0; ",
Arrays.<Object>asList(valuesName, getTimeoutSetName()), System.currentTimeMillis(), keyState, valueState);
}
@Override
public List<V> get(K key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String valuesName = getValuesName(keyHash);
return new RedissonListMultimapValues<V>(codec, commandExecutor, valuesName, getTimeoutSetName(), key);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
public RList<V> get(K key) {
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String valuesName = getValuesName(keyHash);
return new RedissonListMultimapValues<V>(codec, commandExecutor, valuesName, getTimeoutSetName(), key);
}
public RFuture<Collection<V>> getAllAsync(K key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String valuesName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_LIST,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[1]) then " +
"return redis.call('lrange', KEYS[1], 0, -1); " +
"end; " +
"return {}; ",
Arrays.<Object>asList(valuesName, getTimeoutSetName()), System.currentTimeMillis(), keyState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String valuesName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_LIST,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[1]) then " +
"return redis.call('lrange', KEYS[1], 0, -1); " +
"end; " +
"return {}; ",
Arrays.<Object>asList(valuesName, getTimeoutSetName()), System.currentTimeMillis(), keyState);
}
public RFuture<Collection<V>> removeAllAsync(Object key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String valuesName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_SET,
"redis.call('hdel', KEYS[1], ARGV[1]); " +
"local members = redis.call('lrange', KEYS[2], 0, -1); " +
"redis.call('del', KEYS[2]); " +
"redis.call('zrem', KEYS[3], ARGV[1]); " +
"return members; ",
Arrays.<Object>asList(getName(), valuesName, getTimeoutSetName()), keyState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String valuesName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_SET,
"redis.call('hdel', KEYS[1], ARGV[1]); " +
"local members = redis.call('lrange', KEYS[2], 0, -1); " +
"redis.call('del', KEYS[2]); " +
"redis.call('zrem', KEYS[3], ARGV[1]); " +
"return members; ",
Arrays.<Object>asList(getName(), valuesName, getTimeoutSetName()), keyState);
}
@Override

49
redisson/src/main/java/org/redisson/RedissonListMultimapValues.java
Unescape Escape View File

@ -30,6 +30,7 @@ import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RFuture;
import org.redisson.api.RList;
@ -71,6 +72,54 @@ public class RedissonListMultimapValues<V> extends RedissonExpirable implements
this.timeoutSetName = timeoutSetName;
this.key = key;
}
@Override
public RFuture<Boolean> clearExpireAsync() {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> expireAsync(long timeToLive, TimeUnit timeUnit) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> expireAtAsync(long timestamp) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Long> remainTimeToLiveAsync() {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Void> renameAsync(String newName) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> renamenxAsync(String newName) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
public RFuture<Boolean> deleteAsync() {
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[1], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate <= tonumber(ARGV[1]) then "
+ "return 0;"
+ "end; " +
"local res = redis.call('zrem', KEYS[1], ARGV[2]); " +
"if res > 0 then " +
"redis.call('del', KEYS[2]); " +
"end; " +
"return res; ",
Arrays.<Object>asList(timeoutSetName, getName()), System.currentTimeMillis(), key);
}
@Override
public int size() {

45
redisson/src/main/java/org/redisson/RedissonMultimap.java
Unescape Escape View File

@ -15,7 +15,6 @@
*/
package org.redisson;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.AbstractCollection;
import java.util.AbstractSet;
@ -35,6 +34,7 @@ import org.redisson.client.codec.Codec;
import org.redisson.client.codec.LongCodec;
import org.redisson.client.codec.ScanCodec;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.client.protocol.decoder.MapScanResult;
import org.redisson.client.protocol.decoder.ScanObjectEntry;
@ -156,28 +156,28 @@ public abstract class RedissonMultimap<K, V> extends RedissonExpirable implement
return newSucceededFuture(0L);
}
try {
List<Object> mapKeys = new ArrayList<Object>(keys.length);
List<Object> listKeys = new ArrayList<Object>(keys.length + 1);
listKeys.add(getName());
for (K key : keys) {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
mapKeys.add(keyState);
String keyHash = hash(keyState);
String name = getValuesName(keyHash);
listKeys.add(name);
}
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_LONG,
"local res = redis.call('hdel', KEYS[1], unpack(ARGV)); " +
"if res > 0 then " +
"redis.call('del', unpack(KEYS, 2, #KEYS)); " +
"end; " +
"return res; ",
listKeys, mapKeys.toArray());
} catch (IOException e) {
throw new RuntimeException(e);
List<Object> mapKeys = new ArrayList<Object>(keys.length);
List<Object> listKeys = new ArrayList<Object>(keys.length + 1);
listKeys.add(getName());
for (K key : keys) {
byte[] keyState = encodeMapKey(key);
mapKeys.add(keyState);
String keyHash = hash(keyState);
String name = getValuesName(keyHash);
listKeys.add(name);
}
return fastRemoveAsync(mapKeys, listKeys, RedisCommands.EVAL_LONG);
}
protected <T> RFuture<T> fastRemoveAsync(List<Object> mapKeys, List<Object> listKeys, RedisCommand<T> evalCommandType) {
return commandExecutor.evalWriteAsync(getName(), codec, evalCommandType,
"local res = redis.call('hdel', KEYS[1], unpack(ARGV)); " +
"if res > 0 then " +
"redis.call('del', unpack(KEYS, 2, #KEYS)); " +
"end; " +
"return res; ",
listKeys, mapKeys.toArray());
}
@Override
@ -242,6 +242,7 @@ public abstract class RedissonMultimap<K, V> extends RedissonExpirable implement
Arrays.<Object>asList(getName()));
}
@Override
public RFuture<Integer> keySizeAsync() {
return commandExecutor.readAsync(getName(), LongCodec.INSTANCE, RedisCommands.HLEN, getName());
}

288
redisson/src/main/java/org/redisson/RedissonSetMultimap.java
Unescape Escape View File

@ -15,7 +15,6 @@
*/
package org.redisson;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@ -24,8 +23,10 @@ import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RFuture;
import org.redisson.api.RSet;
import org.redisson.api.RSetMultimap;
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.RedisCommand;
@ -54,6 +55,7 @@ public class RedissonSetMultimap<K, V> extends RedissonMultimap<K, V> implements
super(codec, connectionManager, name);
}
@Override
public RFuture<Integer> sizeAsync() {
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_INTEGER,
"local keys = redis.call('hgetall', KEYS[1]); " +
@ -68,122 +70,135 @@ public class RedissonSetMultimap<K, V> extends RedissonMultimap<K, V> implements
Arrays.<Object>asList(getName()));
}
@Override
public RFuture<Boolean> containsKeyAsync(Object key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, SCARD_VALUE, setName);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, SCARD_VALUE, setName);
}
@Override
public RFuture<Boolean> containsValueAsync(Object value) {
try {
byte[] valueState = codec.getMapValueEncoder().encode(value);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local keys = redis.call('hgetall', KEYS[1]); " +
"for i, v in ipairs(keys) do " +
"if i % 2 == 0 then " +
"local name = '{' .. KEYS[1] .. '}:' .. v; " +
"if redis.call('sismember', name, ARGV[1]) == 1 then "
+ "return 1; " +
"end;" +
byte[] valueState = encodeMapValue(value);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local keys = redis.call('hgetall', KEYS[1]); " +
"for i, v in ipairs(keys) do " +
"if i % 2 == 0 then " +
"local name = '{' .. KEYS[1] .. '}:' .. v; " +
"if redis.call('sismember', name, ARGV[1]) == 1 then "
+ "return 1; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(getName()), valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(getName()), valueState);
}
@Override
public RFuture<Boolean> containsEntryAsync(Object key, Object value) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
byte[] valueState = codec.getMapValueEncoder().encode(value);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, SISMEMBER_VALUE, setName, valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
byte[] valueState = encodeMapValue(value);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, SISMEMBER_VALUE, setName, valueState);
}
@Override
public RFuture<Boolean> putAsync(K key, V value) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
byte[] valueState = codec.getMapValueEncoder().encode(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"return redis.call('sadd', KEYS[2], ARGV[3]); ",
Arrays.<Object>asList(getName(), setName), keyState, keyHash, valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
byte[] valueState = encodeMapValue(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"return redis.call('sadd', KEYS[2], ARGV[3]); ",
Arrays.<Object>asList(getName(), setName), keyState, keyHash, valueState);
}
@Override
public RFuture<Boolean> removeAsync(Object key, Object value) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
byte[] valueState = codec.getMapValueEncoder().encode(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local res = redis.call('srem', KEYS[2], ARGV[2]); "
+ "if res == 1 and redis.call('scard', KEYS[2]) == 0 then "
+ "redis.call('hdel', KEYS[1], ARGV[1]); "
+ "end; "
+ "return res; ",
Arrays.<Object>asList(getName(), setName), keyState, valueState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
byte[] valueState = encodeMapValue(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local res = redis.call('srem', KEYS[2], ARGV[2]); "
+ "if res == 1 and redis.call('scard', KEYS[2]) == 0 then "
+ "redis.call('hdel', KEYS[1], ARGV[1]); "
+ "end; "
+ "return res; ",
Arrays.<Object>asList(getName(), setName), keyState, valueState);
}
@Override
public RFuture<Boolean> putAllAsync(K key, Iterable<? extends V> values) {
try {
List<Object> params = new ArrayList<Object>();
byte[] keyState = codec.getMapKeyEncoder().encode(key);
params.add(keyState);
String keyHash = hash(keyState);
params.add(keyHash);
for (Object value : values) {
byte[] valueState = codec.getMapValueEncoder().encode(value);
params.add(valueState);
}
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN_AMOUNT,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"return redis.call('sadd', KEYS[2], unpack(ARGV, 3, #ARGV)); ",
Arrays.<Object>asList(getName(), setName), params.toArray());
} catch (IOException e) {
throw new IllegalArgumentException(e);
List<Object> params = new ArrayList<Object>();
byte[] keyState = encodeMapKey(key);
params.add(keyState);
String keyHash = hash(keyState);
params.add(keyHash);
for (Object value : values) {
byte[] valueState = encodeMapValue(value);
params.add(valueState);
}
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN_AMOUNT,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"return redis.call('sadd', KEYS[2], unpack(ARGV, 3, #ARGV)); ",
Arrays.<Object>asList(getName(), setName), params.toArray());
}
@Override
public Set<V> get(K key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return new RedissonSet<V>(codec, commandExecutor, setName);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
public RSet<V> get(K key) {
final byte[] keyState = encodeMapKey(key);
final String keyHash = hash(keyState);
final String setName = getValuesName(keyHash);
return new RedissonSet<V>(codec, commandExecutor, setName) {
@Override
public RFuture<Boolean> deleteAsync() {
return RedissonSetMultimap.this.fastRemoveAsync(Arrays.<Object>asList(keyState), Arrays.<Object>asList(setName), RedisCommands.EVAL_BOOLEAN_AMOUNT);
}
@Override
public RFuture<Boolean> clearExpireAsync() {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> expireAsync(long timeToLive, TimeUnit timeUnit) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> expireAtAsync(long timestamp) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Long> remainTimeToLiveAsync() {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Void> renameAsync(String newName) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> renamenxAsync(String newName) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
};
}
@Override
@ -191,16 +206,13 @@ public class RedissonSetMultimap<K, V> extends RedissonMultimap<K, V> implements
return (Set<V>) super.getAll(key);
}
@Override
public RFuture<Collection<V>> getAllAsync(K key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, RedisCommands.SMEMBERS, setName);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.readAsync(getName(), codec, RedisCommands.SMEMBERS, setName);
}
@Override
@ -208,21 +220,18 @@ public class RedissonSetMultimap<K, V> extends RedissonMultimap<K, V> implements
return (Set<V>) get(removeAllAsync(key));
}
@Override
public RFuture<Collection<V>> removeAllAsync(Object key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_SET,
"redis.call('hdel', KEYS[1], ARGV[1]); " +
"local members = redis.call('smembers', KEYS[2]); " +
"redis.call('del', KEYS[2]); " +
"return members; ",
Arrays.<Object>asList(getName(), setName), keyState);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_SET,
"redis.call('hdel', KEYS[1], ARGV[1]); " +
"local members = redis.call('smembers', KEYS[2]); " +
"redis.call('del', KEYS[2]); " +
"return members; ",
Arrays.<Object>asList(getName(), setName), keyState);
}
@Override
@ -235,6 +244,7 @@ public class RedissonSetMultimap<K, V> extends RedissonMultimap<K, V> implements
return (Set<V>) get(replaceValuesAsync(key, values));
}
@Override
Iterator<V> valuesIterator() {
return new RedissonSetMultimapIterator<K, V, V>(RedissonSetMultimap.this, commandExecutor, codec) {
@Override
@ -244,33 +254,31 @@ public class RedissonSetMultimap<K, V> extends RedissonMultimap<K, V> implements
};
}
@Override
RedissonSetMultimapIterator<K, V, Entry<K, V>> entryIterator() {
return new RedissonSetMultimapIterator<K, V, Map.Entry<K, V>>(RedissonSetMultimap.this, commandExecutor, codec);
}
@Override
public RFuture<Collection<V>> replaceValuesAsync(K key, Iterable<? extends V> values) {
try {
List<Object> params = new ArrayList<Object>();
byte[] keyState = codec.getMapKeyEncoder().encode(key);
params.add(keyState);
String keyHash = hash(keyState);
params.add(keyHash);
for (Object value : values) {
byte[] valueState = codec.getMapValueEncoder().encode(value);
params.add(valueState);
}
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_SET,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"local members = redis.call('smembers', KEYS[2]); " +
"redis.call('del', KEYS[2]); " +
"redis.call('sadd', KEYS[2], unpack(ARGV, 3, #ARGV)); " +
"return members; ",
Arrays.<Object>asList(getName(), setName), params.toArray());
} catch (Exception e) {
throw new IllegalArgumentException(e);
List<Object> params = new ArrayList<Object>();
byte[] keyState = encodeMapKey(key);
params.add(keyState);
String keyHash = hash(keyState);
params.add(keyHash);
for (Object value : values) {
byte[] valueState = encodeMapValue(value);
params.add(valueState);
}
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_SET,
"redis.call('hset', KEYS[1], ARGV[1], ARGV[2]); " +
"local members = redis.call('smembers', KEYS[2]); " +
"redis.call('del', KEYS[2]); " +
"redis.call('sadd', KEYS[2], unpack(ARGV, 3, #ARGV)); " +
"return members; ",
Arrays.<Object>asList(getName(), setName), params.toArray());
}
}

217
redisson/src/main/java/org/redisson/RedissonSetMultimapCache.java
Unescape Escape View File

@ -15,13 +15,12 @@
*/
package org.redisson;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RFuture;
import org.redisson.api.RSet;
import org.redisson.api.RSetMultimapCache;
import org.redisson.client.codec.Codec;
import org.redisson.client.protocol.RedisCommands;
@ -49,32 +48,28 @@ public class RedissonSetMultimapCache<K, V> extends RedissonSetMultimap<K, V> im
baseCache = new RedissonMultimapCache<K>(connectionManager, name, codec, getTimeoutSetName());
}
@Override
public RFuture<Boolean> containsKeyAsync(Object key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local value = redis.call('hget', KEYS[1], ARGV[2]); " +
"if value ~= false then " +
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate <= tonumber(ARGV[1]) then "
+ "return 0;"
+ "end; "
+ "return redis.call('scard', ARGV[3]) > 0 and 1 or 0;" +
"end;" +
"return 0; ",
Arrays.<Object>asList(getName(), getTimeoutSetName()), System.currentTimeMillis(), keyState, setName);
} catch (IOException e) {
throw new RuntimeException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local value = redis.call('hget', KEYS[1], ARGV[2]); " +
"if value ~= false then " +
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate <= tonumber(ARGV[1]) then "
+ "return 0;"
+ "end; "
+ "return redis.call('scard', ARGV[3]) > 0 and 1 or 0;" +
"end;" +
"return 0; ",
Arrays.<Object>asList(getName(), getTimeoutSetName()), System.currentTimeMillis(), keyState, setName);
}
String getTimeoutSetName() {
@ -82,112 +77,94 @@ public class RedissonSetMultimapCache<K, V> extends RedissonSetMultimap<K, V> im
}
@Override
public RFuture<Boolean> containsValueAsync(Object value) {
try {
byte[] valueState = codec.getMapValueEncoder().encode(value);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local keys = redis.call('hgetall', KEYS[1]); " +
"for i, v in ipairs(keys) do " +
"if i % 2 == 0 then " +
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], keys[i-1]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[2]) then " +
"local name = '{' .. KEYS[1] .. '}:' .. v; " +
"if redis.call('sismember', name, ARGV[1]) == 1 then "
+ "return 1; " +
"end;" +
"end; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(getName(), getTimeoutSetName()), valueState, System.currentTimeMillis());
} catch (IOException e) {
throw new RuntimeException(e);
}
byte[] valueState = encodeMapValue(value);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local keys = redis.call('hgetall', KEYS[1]); " +
"for i, v in ipairs(keys) do " +
"if i % 2 == 0 then " +
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], keys[i-1]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[2]) then " +
"local name = '{' .. KEYS[1] .. '}:' .. v; " +
"if redis.call('sismember', name, ARGV[1]) == 1 then "
+ "return 1; " +
"end;" +
"end; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(getName(), getTimeoutSetName()), valueState, System.currentTimeMillis());
}
@Override
public RFuture<Boolean> containsEntryAsync(Object key, Object value) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
byte[] valueState = codec.getMapValueEncoder().encode(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[1]) then " +
"if redis.call('sismember', KEYS[1], ARGV[3]) == 1 then "
+ "return 1; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(setName, getTimeoutSetName()), System.currentTimeMillis(), keyState, valueState);
} catch (IOException e) {
throw new RuntimeException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
byte[] valueState = encodeMapValue(value);
String setName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[1]) then " +
"if redis.call('sismember', KEYS[1], ARGV[3]) == 1 then "
+ "return 1; " +
"end;" +
"end; " +
"return 0; ",
Arrays.<Object>asList(setName, getTimeoutSetName()), System.currentTimeMillis(), keyState, valueState);
}
@Override
public Set<V> get(K key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return new RedissonSetMultimapValues<V>(codec, commandExecutor, setName, getTimeoutSetName(), key);
} catch (Exception e) {
throw new RuntimeException(e);
}
public RSet<V> get(K key) {
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return new RedissonSetMultimapValues<V>(codec, commandExecutor, setName, getTimeoutSetName(), key);
}
@Override
public RFuture<Collection<V>> getAllAsync(K key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_SET,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[1]) then " +
"return redis.call('smembers', KEYS[1]); " +
"end; " +
"return {}; ",
Arrays.<Object>asList(setName, getTimeoutSetName()), System.currentTimeMillis(), keyState);
} catch (IOException e) {
throw new RuntimeException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalReadAsync(getName(), codec, RedisCommands.EVAL_SET,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[2], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate > tonumber(ARGV[1]) then " +
"return redis.call('smembers', KEYS[1]); " +
"end; " +
"return {}; ",
Arrays.<Object>asList(setName, getTimeoutSetName()), System.currentTimeMillis(), keyState);
}
@Override
public RFuture<Collection<V>> removeAllAsync(Object key) {
try {
byte[] keyState = codec.getMapKeyEncoder().encode(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_SET,
"redis.call('hdel', KEYS[1], ARGV[1]); " +
"local members = redis.call('smembers', KEYS[2]); " +
"redis.call('del', KEYS[2]); " +
"redis.call('zrem', KEYS[3], ARGV[1]); " +
"return members; ",
Arrays.<Object>asList(getName(), setName, getTimeoutSetName()), keyState);
} catch (IOException e) {
throw new RuntimeException(e);
}
byte[] keyState = encodeMapKey(key);
String keyHash = hash(keyState);
String setName = getValuesName(keyHash);
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_SET,
"redis.call('hdel', KEYS[1], ARGV[1]); " +
"local members = redis.call('smembers', KEYS[2]); " +
"redis.call('del', KEYS[2]); " +
"redis.call('zrem', KEYS[3], ARGV[1]); " +
"return members; ",
Arrays.<Object>asList(getName(), setName, getTimeoutSetName()), keyState);
}
@Override

50
redisson/src/main/java/org/redisson/RedissonSetMultimapValues.java
Unescape Escape View File

@ -23,6 +23,7 @@ import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.redisson.api.RFuture;
import org.redisson.api.RSet;
@ -67,6 +68,55 @@ public class RedissonSetMultimapValues<V> extends RedissonExpirable implements R
public int size() {
return get(sizeAsync());
}
@Override
public RFuture<Boolean> clearExpireAsync() {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> expireAsync(long timeToLive, TimeUnit timeUnit) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> expireAtAsync(long timestamp) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Long> remainTimeToLiveAsync() {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Void> renameAsync(String newName) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
@Override
public RFuture<Boolean> renamenxAsync(String newName) {
throw new UnsupportedOperationException("This operation is not supported for SetMultimap values Set");
}
public RFuture<Boolean> deleteAsync() {
return commandExecutor.evalWriteAsync(getName(), codec, RedisCommands.EVAL_BOOLEAN,
"local expireDate = 92233720368547758; " +
"local expireDateScore = redis.call('zscore', KEYS[1], ARGV[2]); "
+ "if expireDateScore ~= false then "
+ "expireDate = tonumber(expireDateScore) "
+ "end; "
+ "if expireDate <= tonumber(ARGV[1]) then "
+ "return 0;"
+ "end; " +
"local res = redis.call('zrem', KEYS[1], ARGV[2]); " +
"if res > 0 then " +
"redis.call('del', KEYS[2]); " +
"end; " +
"return res; ",
Arrays.<Object>asList(timeoutSetName, getName()), System.currentTimeMillis(), key);
}
@Override
public RFuture<Integer> sizeAsync() {

2
redisson/src/main/java/org/redisson/api/RListMultimap.java
Unescape Escape View File

@ -35,7 +35,7 @@ public interface RListMultimap<K, V> extends RMultimap<K, V> {
* specified in the {@link RMultimap} interface.
*/
@Override
List<V> get(K key);
RList<V> get(K key);
/**
* {@inheritDoc}

2
redisson/src/main/java/org/redisson/api/RSetMultimap.java
Unescape Escape View File

@ -36,7 +36,7 @@ public interface RSetMultimap<K, V> extends RMultimap<K, V> {
* specified in the {@link RMultimap} interface.
*/
@Override
Set<V> get(K key);
RSet<V> get(K key);
/**
* {@inheritDoc}

Write Preview
Loading…
Cancel
Save