redis.clients.jedis.params.ZAddParams Java Examples

public Long ehsetnx(final String key, final String field, final String value, final long ttl) {
    final String ehashDataKey = ehashDataKey(key);
    final String ehashMetadataKey = ehashMetadataKey(key);
    final DynoJedisPipeline pipeline = this.pipelined();
    final Response<Long> zResponse = pipeline.zadd(ehashMetadataKey, timeInEpochSeconds(ttl), field,
            ZAddParams.zAddParams().ch());
    final Response<Long> hResponse = pipeline.hsetnx(ehashDataKey, field, value);
    pipeline.sync();

    // If metadata operation failed, remove the data and throw exception
    if (!zResponse.get().equals(hResponse.get())) {
        d_hdel(ehashDataKey, field);
        d_zrem(ehashMetadataKey, field);
        throw new DynoException("Metadata inconsistent with data for expireHash: " + ehashDataKey);
    }
    return hResponse.get();
}
 

@Override
public String ehmset(final String key, final Map<String, Pair<String, Long>> hash) {
    final DynoJedisPipeline pipeline = this.pipelined();
    Map<String, String> fields = new HashMap<>();
    Map<String, Double> metadataFields = new HashMap<>();

    hash.keySet().forEach(f -> {
        fields.put(f, hash.get(f).getLeft());
        metadataFields.put(f, timeInEpochSeconds(hash.get(f).getRight()));
    });

    final Response<Long> zResponse = pipeline.zadd(ehashMetadataKey(key), metadataFields,
            ZAddParams.zAddParams().ch());
    final Response<String> hResponse = pipeline.hmset(ehashDataKey(key), fields);
    pipeline.sync();

    return hResponse.get();
}
 

@Override
public Long zadd(String key, double score, String member, ZAddParams params) {
	
	try {
		
		if(params.getParam("xx") != null) {
			Double existing = redis.zscore(key, member);
			if(existing == null) {
				return 0L;
			}
			return redis.zadd(key, new ZsetPair(member, score));
		}else {
			return redis.zadd(key, new ZsetPair(member, score));
		}
		
	} catch (Exception e) {
		throw new JedisException(e);
	}
}
 

@Override
public Long zadd(String key, double score, String member, ZAddParams params) {
	
	try {
		
		if(params.getParam("xx") != null) {
			Double existing = redis.zscore(key, member);
			if(existing == null) {
				return 0L;
			}
			return redis.zadd(key, new ZsetPair(member, score));
		}else {
			return redis.zadd(key, new ZsetPair(member, score));
		}
		
	} catch (Exception e) {
		throw new JedisException(e);
	}
}
 

public OperationResult<Long> d_zadd(final String key, final double score, final String member,
                                    final ZAddParams params) {

    return connPool.executeWithFailover(new BaseKeyOperation<Long>(key, OpName.ZADD) {

        @Override
        public Long execute(Jedis client, ConnectionContext state) {
            return client.zadd(key, score, member, params);
        }

    });
}
 

@Override
public Long ehset(final String key, final String field, final String value, final long ttl)
        throws UnsupportedOperationException, DynoException {
    final DynoJedisPipeline pipeline = this.pipelined();
    final Response<Long> zResponse = pipeline.zadd(ehashMetadataKey(key), timeInEpochSeconds(ttl), field,
            ZAddParams.zAddParams().ch());
    final Response<Long> hResponse = pipeline.hset(ehashDataKey(key), field, value);
    pipeline.sync();

    return hResponse.get();
}
 

@Override
public Response<Long> zadd(String key, Map<String, Double> members, ZAddParams params) {
    return new PipelineOperation<Long>() {

        @Override
        Response<Long> execute(Pipeline jedisPipeline) throws DynoException {
            return jedisPipeline.zadd(key, members, params);
        }

    }.execute(key, OpName.ZADD);
}
 

@Test
public void testZadd() {
    jedisSentinel.zadd("key", new HashMap<>());
    jedisSentinel.zadd("key", new HashMap<>(), ZAddParams.zAddParams());
    jedisSentinel.zadd("key", 1337, "members");
    jedisSentinel.zadd("key", 1337, "members", ZAddParams.zAddParams());
}
 

@Test
public void testZadd() {
    jedisCluster.zadd("key", new HashMap<>());
    jedisCluster.zadd("key", new HashMap<>(), ZAddParams.zAddParams());
    jedisCluster.zadd("key", 1337, "members");
    jedisCluster.zadd("key", 1337, "members", ZAddParams.zAddParams());
}
 

@Override
public Long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
  Span span = helper.buildSpan("zadd", key);
  span.setTag("scoreMembers", TracingHelper.toString(scoreMembers));
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> wrapped.zadd(key, scoreMembers, params));
}
 

@Override
public Long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
  Span span = helper.buildSpan("zadd", key);
  span.setTag("score", score);
  span.setTag("member", Arrays.toString(member));
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> wrapped.zadd(key, score, member, params));
}
 

@Override
public Long zadd(String key, double score, String member, ZAddParams params) {
  Span span = helper.buildSpan("zadd", key);
  span.setTag("score", score);
  span.setTag("member", member);
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> wrapped.zadd(key, score, member, params));
}
 

@Override
public Long zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
  Span span = helper.buildSpan("zadd", key);
  span.setTag("scoreMembers", TracingHelper.toStringMap2(scoreMembers));
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> super.zadd(key, scoreMembers, params));
}
 

@Override
public Long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
  Span span = helper.buildSpan("zadd", key);
  span.setTag("score", score);
  span.setTag("member", Arrays.toString(member));
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> super.zadd(key, score, member, params));
}
 

@Override
public Long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
  Span span = helper.buildSpan("zadd", key);
  span.setTag("scoreMembers", TracingHelper.toString(scoreMembers));
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> super.zadd(key, scoreMembers, params));
}
 

@Override
public Long zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
  Span span = helper.buildSpan("zadd", key);
  span.setTag("scoreMembers", TracingHelper.toStringMap2(scoreMembers));
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> wrapped.zadd(key, scoreMembers, params));
}
 

@Override
public Long zadd(String key, double score, String member, ZAddParams params) {
  Span span = helper.buildSpan("zadd", key);
  span.setTag("score", score);
  span.setTag("member", member);
  span.setTag("params", TracingHelper.toString(params.getByteParams()));
  return helper.decorate(span, () -> super.zadd(key, score, member, params));
}
 

@Override
public Response<Long> zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
  String command = "zadd";
  return instrumented(command, () -> delegated.zadd(key, scoreMembers, params));
}
 

@Override
public Long zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
  String command = "zadd";
  return instrumented(command, () -> delegated.zadd(key, scoreMembers, params));
}
 

@Override
public Long zadd(byte[] arg0, Map<byte[], Double> arg1, ZAddParams arg2) {
    throw new UnsupportedOperationException("not yet implemented");
}
 

@Override
public Long zadd(byte[] arg0, double arg1, byte[] arg2, ZAddParams arg3) {
    throw new UnsupportedOperationException("not yet implemented");
}
 

@Override
public Long zadd(String arg0, Map<String, Double> arg1, ZAddParams arg2) {
    throw new UnsupportedOperationException("not yet implemented");
}
 

@Override
public Response<Long> zadd(String key, double score, String member, ZAddParams params) {
  String command = "zadd";
  return instrumented(
      command, payloadSize(member), () -> delegated.zadd(key, score, member, params));
}
 

@Override
public Long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
  String command = "zadd";
  return instrumented(command, () -> delegated.zadd(key, score, member, params));
}
 

@Override
public Response<Long> zadd(byte[] key, double score, byte[] member, ZAddParams params) {
  String command = "zadd";
  return instrumented(
      command, payloadSize(member), () -> delegated.zadd(key, score, member, params));
}
 

@Override
public Response<Long> zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
  String command = "zadd";
  return instrumented(command, () -> delegated.zadd(key, scoreMembers, params));
}
 

@Override
public Long zadd(String key, double score, String member, ZAddParams params) {
  String command = "zadd";
  return instrumented(command, () -> delegated.zadd(key, score, member, params));
}
 

@Override
public Long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
  String command = "zadd";
  return instrumented(command, () -> delegated.zadd(key, scoreMembers, params));
}
 

@Override
public Long zadd(String key, double score, String member, ZAddParams params) {
    return d_zadd(key, score, member, params).getResult();
}
 

@Override
public Response<Long> zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
    throw new UnsupportedOperationException("not yet implemented");
}