Clients

Lettuce ZSets

Redis 開発者教育 Redis Developer Course	Redis 定期点検/技術支援 Redis Technical Support	Redis エンタープライズサーバ Redis Enterprise Server

ZSets

Class 변수로 선언

String key = "myzset";
long idx = 1;

ZADD

// ZADD key [NX|XX] [CH] [INCR] score member [score member ...] -> return long or double
// add된 member 개수 리턴
protected void zadd() {
	try {
		Redis.syncCmd.del(key);
		long count = Redis.syncCmd.zadd(key, 60d, "경기");
		System.out.println("zadd "+key+" 60 경기 -> "+count);
		long count2 = Redis.syncCmd.zadd(key, 20d, "서울", 40d, "부산");
		System.out.println("zadd "+key+" 20 서울 40 부산 -> "+count2);
		ScoredValue<String> sv = new ScoredValue<String>(100d, "대전");
		long count3 = Redis.syncCmd.zadd(key, sv);
		System.out.println("zadd "+key+" 100 대전 -> "+count3+" (ScoredValue)");
		// NX, XX, CH 있음. INCR은 별도 명령으로 있음. 왜냐하면 return data type이 다르기 때문.
		// CH : score를 변경했을 경우 1을 리턴
		ZAddArgs args = new ZAddArgs().nx();
		long count4 = Redis.syncCmd.zadd(key, args, 80d, "전라");
		System.out.println("zadd "+key+" NX 80 전라 -> "+count4);
		// INCR : return double, 변경된 score
		double score = Redis.syncCmd.zaddincr(key, 20d, "대전");
		System.out.println("zadd "+key+" incr 30 대전 -> "+score);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREM

// ZREM key member [member] -> return long
protected void zrem() {
	try {
		long count = Redis.syncCmd.zrem(key, "서울");
		System.out.println("zrem "+key+" 서울 -> "+count);
		long count2 = Redis.syncCmd.zrem(key, "경기", "부산");
		System.out.println("zrem "+key+" 경기 부산 -> "+count2);
		String list[] = new String[2];
		list[0] = "전라";
		list[1] = "대전";
		long count3 = Redis.syncCmd.zrem(key, list);
		System.out.println("zrem "+key+" 전라 대전 -> "+count3+" (Array)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGE

// ZRANGE key start stop [withscores] -> return List<String> or List<ScoredValue<String>> or long
protected void zrange() {
	try {
		List<String> list = Redis.syncCmd.zrange(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 -> "+list.toString());
		// WithScores
		List<ScoredValue<String>> list2 = Redis.syncCmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores");
		for (ScoredValue<String> sv: list2) {
			System.out.println(sv.score+" "+sv.value);
		}
		// ValueStreamingChannel
		long count = Redis.syncCmd.zrange(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String member) {
				System.out.println("zrange (ValueStreamingChannel) -> " +member);
			}
		}, key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 -> return: "+count);
		// ScoredValueStreamingChannel
		long count2 = Redis.syncCmd.zrangeWithScores(new ScoredValueStreamingChannel<String>() {
			@Override
			public void onValue(ScoredValue<String> member) {
				System.out.println("zrange (ValueStreamingChannel) -> " +member.score+" "+member.value);
			}
		}, key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> return: "+count2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZCARD

// ZCARD key -> return long
protected void zcard() {
	try {
		Long count = Redis.syncCmd.zcard(key);
		System.out.println("zcard "+key+" -> "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGEBYSCORE

// ZRANGEBYSCORE key min max [withscores] [limit offset count] -> return List<String> or List<ScoredValue<String>>
protected void zrangebyscore() {
	try {
		List<String> list = Redis.syncCmd.zrangebyscore(key, 0, 200);	// deprecated
		System.out.println("zrangebyscore "+key+" 0 200 -> "+list.toString()+" (deprecated)");
		List<String> list2 = Redis.syncCmd.zrangebyscore(key, "-inf", "+inf");	// deprecated
		System.out.println("zrangebyscore "+key+" -inf +inf -> "+list2.toString()+" (deprecated)");
		List<String> list3 = Redis.syncCmd.zrangebyscore(key, "(20", "(120");	// deprecated
		System.out.println("zrangebyscore "+key+" (20 (120 -> "+list3.toString()+" (deprecated)");
		// Range
		Range<Double> range = Range.create(0d, 200d);
		List<String> list4 = Redis.syncCmd.zrangebyscore(key, range);
		System.out.println("zrangebyscore "+key+" 0 200 -> "+list4.toString()+" (Range)");
		// Range -inf +inf -> INFINITY value
		Range<Double> range2 = Range.create(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
		List<String> list5 = Redis.syncCmd.zrangebyscore(key, range2);
		System.out.println("zrangebyscore "+key+" -inf +inf -> "+list5.toString()+" (Range INFINITY value)");
		// Range -inf +inf -> unbounded()
		Range<Double> rangeUnbound = Range.unbounded();
		List<String> list6 = Redis.syncCmd.zrangebyscore(key, rangeUnbound);
		System.out.println("zrangebyscore "+key+" Range.unbounded() -> "+list6.toString()+" (Range unbounded)");
		// Range excluding/including
		Range<Double> range4 = Range.from(Boundary.excluding(20d), Boundary.excluding(120d));
		List<String> list7 = Redis.syncCmd.zrangebyscore(key, range4);
		System.out.println("zrangebyscore "+key+" Range.excluding() -> "+list7.toString()+" (Range excluding/including)");
		// Limit
		Limit limit = Limit.create(1, 3);
		List<String> list8 = Redis.syncCmd.zrangebyscore(key, rangeUnbound, limit);
		System.out.println("zrangebyscore "+key+" Limit 1 3 -> "+list8.toString()+" (Range Limit)");
		// withscores
		List<ScoredValue<String>> list9 = Redis.syncCmd.zrangebyscoreWithScores(key, rangeUnbound);
		for (ScoredValue<String> sv: list9) {
			System.out.println("zrangebyscore "+key+" withscores -> "+sv.score+" "+sv.value);
		}			
		// ValueStreamingChannel
		long count = Redis.syncCmd.zrangebyscore(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String member) {
				System.out.println("zrange (ValueStreamingChannel) -> "+member);
			}
		}, key, rangeUnbound);
		System.out.println("zrange (ValueStreamingChannel) -> "+count+" (count)");
		// ScoredValueStreamingChannel
		long count2 = Redis.syncCmd.zrangebyscoreWithScores(new ScoredValueStreamingChannel<String>() {
			@Override
			public void onValue(ScoredValue<String> member) {
				System.out.println("zrange (ScoredValueStreamingChannel) -> " +member.score+" "+member.value);
			}
		}, key, rangeUnbound);
		System.out.println("zrange (ScoredValueStreamingChannel) -> "+count2+" (count)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGEBYLEX

// ZRANGEBYLEX key min max [limit offset count] -> return List<String>
protected void zrangebylex() {
	try {
		Redis.syncCmd.del(key);
		long count = Redis.syncCmd.zadd(key, 0d, "경기", 0d, "서울", 0d, "부산", 0d, "대전", 0d, "전라");
		System.out.println("zadd "+key+" -> "+count);
		// including
		Range<String> range = Range.from(Boundary.including("경기"), Boundary.including("전라"));
		List<String> list = Redis.syncCmd.zrangebylex(key, range);
		System.out.println("zrangebylex "+key+" [경기 [전라 -> "+list.toString());
		// excluding
		Range<String> range2 = Range.from(Boundary.excluding("경기"), Boundary.excluding("전라"));
		List<String> list2 = Redis.syncCmd.zrangebylex(key, range2);
		System.out.println("zrangebylex "+key+" (경기 (전라 -> "+list2.toString());
		// Limit offset count
		Limit limit = Limit.create(0, 1);
		List<String> list3 = Redis.syncCmd.zrangebylex(key, range2, limit);
		System.out.println("zrangebylex "+key+" (경기 (전라 limit 0 1 -> "+list3.toString());
		// No withscores
		// No ValueStreamingChannel
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYRANK

// ZREMRANGEBYRANK key start stop -> return long
protected void zremrangebyrank() {
	try {
		// del
		Redis.syncCmd.del(key);
		// zadd
		long count = Redis.syncCmd.zadd(key, 20d, "서울", 40d, "부산", 60d, "경기", 80d, "전라", 100d, "대전");
		System.out.println("zadd "+key+" -> "+count);
		// zrange
		List<ScoredValue<String>> list = Redis.syncCmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+list.size());
		for (ScoredValue<String> sv: list) {
			System.out.println(sv.score+" "+sv.value);
		}
		// zremrangebyrank
		long count2 = Redis.syncCmd.zremrangebyrank(key, 1, 3);
		System.out.println("zremrangebyrank "+key+" 1 3 -> "+count2);
		// zrange
		List<ScoredValue<String>> list2 = Redis.syncCmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+list2.size());
		for (ScoredValue<String> sv: list2) {
			System.out.println(sv.score+" "+sv.value);
		}
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYSCORE

// ZREMRANGEBYSCORE key min max -> return long
protected void zremrangebyscore() {
	try {
		// del
		Redis.syncCmd.del(key);
		// zadd
		long count = Redis.syncCmd.zadd(key, 20d, "서울", 40d, "부산", 60d, "경기", 80d, "전라", 100d, "대전");
		System.out.println("zadd "+key+" -> "+count);
		// zrange : before
		List<ScoredValue<String>> list = Redis.syncCmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+list.size());
		for (ScoredValue<String> sv: list) {
			System.out.println(sv.score+" "+sv.value);
		}
		// zremrangebyscore
		Range<Double> range = Range.from(Boundary.including(40d), Boundary.including(80d));
		Long count2 = Redis.syncCmd.zremrangebyscore(key, range);
		System.out.println("zremrangebyscore "+key+" 40 80 -> "+count2+" (including)");
		// zrange : after
		List<ScoredValue<String>> list2 = Redis.syncCmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+list2.size());
		for (ScoredValue<String> sv: list2) {
			System.out.println(sv.score+" "+sv.value);
		}
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYLEX

// ZREMRANGEBYLEX key min max -> return long
protected void zremrangebylex() {
	try {
		// del
		Redis.syncCmd.del(key);
		// zadd
		long count = Redis.syncCmd.zadd(key, 0d, "서울", 0d, "부산", 0d, "경기", 0d, "전라", 0d, "대전");
		System.out.println("zadd "+key+" -> "+count);
		// zrange : before
		List<ScoredValue<String>> list = Redis.syncCmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+list.size());
		for (ScoredValue<String> sv: list) {
			System.out.println(sv.score+" "+sv.value);
		}
		// zremrangebylex
		Range<String> range = Range.from(Boundary.including("대전"), Boundary.including("서울"));
		Long count2 = Redis.syncCmd.zremrangebylex(key, range);
		System.out.println("zremrangebylex "+key+" 대전 서울 -> "+count2+" (including)");
		// zrange : after
		List<ScoredValue<String>> list2 = Redis.syncCmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+list2.size());
		for (ScoredValue<String> sv: list2) {
			System.out.println(sv.score+" "+sv.value);
		}
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGE

// ZREVRANGE key start stop [withscores] -> return List<String> or List<ScoredValue<String>>
protected void zrevrange() {
	try {
		// del
		Redis.syncCmd.del(key);
		// zadd
		long count = Redis.syncCmd.zadd(key, 20d, "서울", 40d, "부산", 60d, "경기", 80d, "전라", 100d, "대전");
		System.out.println("zadd "+key+" -> "+count);
		// zrevrange
		List<ScoredValue<String>> list = Redis.syncCmd.zrevrangeWithScores(key, 0, -1);
		System.out.println("zrevrange "+key+" 0 -1 withscores -> "+list.size());
		for (ScoredValue<String> sv: list) {
			System.out.println(sv.score+" "+sv.value);
		}
		// ScoredValueStreamingChannel
		long count2 = Redis.syncCmd.zrevrangeWithScores(new ScoredValueStreamingChannel<String>() {
			@Override
			public void onValue(ScoredValue<String> member) {
				System.out.println("zrevrange (ValueStreamingChannel) -> " +member.score+" "+member.value);
			}
		}, key, 0, -1);
		System.out.println("zrevrange "+key+" 0 -1 withscores -> return: "+count2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGEBYSCORE

// ZREVRANGEBYSCORE key max min [withscores] [limit offset count] -> return List<String> or List<ScoredValue<String>>
protected void zrevrangebyscore() {
	try {
		// del
		Redis.syncCmd.del(key);
		// zadd
		long count = Redis.syncCmd.zadd(key, 20d, "서울", 40d, "부산", 60d, "경기", 80d, "전라", 100d, "대전");
		System.out.println("zadd "+key+" -> "+count);
		// range: min max 순서로 지정해야 함.
		Range<Double> range = Range.from(Boundary.including(40d), Boundary.including(80d));
		// zrevrangebyscore
		List<ScoredValue<String>> list = Redis.syncCmd.zrevrangebyscoreWithScores(key, range);
		System.out.println("zrevrangebyscore "+key+" 80 40 withscores -> "+list.size());
		for (ScoredValue<String> sv: list) {
			System.out.println(sv.score+" "+sv.value);
		}
		// Limit offset count
		Limit limit = Limit.create(1, 2);
		List<ScoredValue<String>> list2 = Redis.syncCmd.zrevrangebyscoreWithScores(key, range, limit);
		System.out.println("zrevrangebyscore "+key+" 80 40 limit 1 2 withscores -> "+list2.size());
		for (ScoredValue<String> sv: list2) {
			System.out.println(sv.score+" "+sv.value);
		}
		// ScoredValueStreamingChannel
		long count2 = Redis.syncCmd.zrevrangebyscoreWithScores(new ScoredValueStreamingChannel<String>() {
			@Override
			public void onValue(ScoredValue<String> member) {
				System.out.println("zrevrangebyscore (ValueStreamingChannel) -> " +member.score+" "+member.value);
			}
		}, key, range);
		System.out.println("zrevrangebyscore "+key+" 80 40 withscores -> return: "+count2);
		
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGEBYLEX

// ZREVRANGEBYLEX key max min [limit offset count] -> return List<String> or List<ScoredValue<String>>
protected void zrevrangebylex() {
	try {
		// del
		Redis.syncCmd.del(key);
		// zadd
		long count = Redis.syncCmd.zadd(key, 0d, "경기", 0d, "대전", 0d, "부산", 0d, "서울", 0d, "전라");
		System.out.println("zadd "+key+" -> "+count);
		Range<String> range = Range.unbounded();
		List<String> list = Redis.syncCmd.zrevrangebylex(key, range);
		System.out.println("zrevrangebylex "+key+" + - -> "+list.size());
		for (String v: list) {
			System.out.println(v);
		}
		// range: min max 순서로 지정해야 함. 원래 순서와 다름.  [ 포함 including, ( 미포함 excluding
		Range<String> range2 = Range.from(Boundary.including("대전"), Boundary.including("서울"));
		// zrevrangebylex
		List<String> list2 = Redis.syncCmd.zrevrangebylex(key, range2);
		System.out.println("zrevrangebylex "+key+" [서울 [대전 -> "+list2.size());
		for (String v: list2) {
			System.out.println(v);
		}
		// Limit offset count
		Limit limit = Limit.create(1, 2);
		List<String> list3 = Redis.syncCmd.zrevrangebylex(key, range2, limit);
		System.out.println("zrevrangebylex "+key+" [서울 [대전 limit 1 2 -> "+list3.size());
		for (String v: list3) {
			System.out.println(v);
		}
		// No withscores
		// No ValueStreamingChannel
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANK

// ZRANK key member -> return long
protected void zrank() {
	try {
		Long index = Redis.syncCmd.zrank(key, "대전");
		System.out.println("ZRANK "+key+" 대전 -> "+index);
		Long index2 = Redis.syncCmd.zrank(key, "서울");
		System.out.println("ZRANK "+key+" 서울 -> "+index2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANK

// ZREVRANK key member -> return long
protected void zrevrank() {
	try {
		Long index = Redis.syncCmd.zrevrank(key, "대전");
		System.out.println("ZREVRANK "+key+" 대전 -> "+index);
		Long index2 = Redis.syncCmd.zrevrank(key, "서울");
		System.out.println("ZREVRANK "+key+" 서울 -> "+index2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZSCORE

// ZSCORE key member -> return double
protected void zscore() {
	try {
		Double score = Redis.syncCmd.zscore(key, "대전");
		System.out.println("ZSCORE "+key+" 대전 -> "+score);
		Double score2 = Redis.syncCmd.zscore(key, "서울");
		System.out.println("ZSCORE "+key+" 서울 -> "+score2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZINCRBY

// ZINCRBY key increment member -> return double
protected void zincrby() {
	long time = System.currentTimeMillis(); 
	String key = "daily_views";
	String mem = new SimpleDateFormat("yyyyMMdd").format(time);		
	try {
		Double score = Redis.syncCmd.zincrby(key, 1, mem);
		System.out.println("ZINCRBY "+key+" 1 "+mem+" -> "+score);
		Double score2 = Redis.syncCmd.zincrby(key, 1, mem);
		System.out.println("ZINCRBY "+key+" 1 "+mem+" -> "+score2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZUNIONSTORE

// ZUNIONSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> return long
protected void zunionstore() {
	String srcKey1 = "myzset1";
	String srcKey2 = "myzset2";
	String destKey = "dest_key";
	try {
		Redis.syncCmd.del(destKey, srcKey1, srcKey2);
		Redis.syncCmd.zadd(srcKey1, 1d, "A", 2d, "B", 3d, "C");
		Redis.syncCmd.zadd(srcKey2, 4d, "B", 5d, "C", 6d, "D");
		List<ScoredValue<String>> list1 = Redis.syncCmd.zrangeWithScores(srcKey1, 0, -1);
		System.out.println("zrange "+srcKey1+" 0 -1 -> "+list1.toString());
		List<ScoredValue<String>> list2 = Redis.syncCmd.zrangeWithScores(srcKey2, 0, -1);
		System.out.println("zrange "+srcKey2+" 0 -1 -> "+list2.toString());
		// zunionstore: numkeys는 넣지 않음.
		Long count = Redis.syncCmd.zunionstore(destKey, srcKey1, srcKey2);
		System.out.println("ZUNIONSTORE "+destKey+" "+srcKey1+" "+srcKey2+" -> "+count);
		List<ScoredValue<String>> list3 = Redis.syncCmd.zrangeWithScores(destKey, 0, -1);
		System.out.println("zrange "+destKey+" 0 -1 -> "+list3.toString());
		// Aggregate sum/min/max (defatul: sum)
		ZStoreArgs args = new ZStoreArgs().max();
		Long count2 = Redis.syncCmd.zunionstore(destKey, args, srcKey1, srcKey2);
		System.out.println("ZUNIONSTORE "+destKey+" "+srcKey1+" "+srcKey2+" aggregate max -> "+count2);
		List<ScoredValue<String>> list4 = Redis.syncCmd.zrangeWithScores(destKey, 0, -1);
		System.out.println("zrange "+destKey+" 0 -1 -> "+list4.toString());
		// weights
		args.weights(2d, 3d).sum();
		Long count3 = Redis.syncCmd.zunionstore(destKey, args, srcKey1, srcKey2);
		System.out.println("ZUNIONSTORE "+destKey+" "+srcKey1+" "+srcKey2+" weights 2 3 -> "+count3);
		List<ScoredValue<String>> list5 = Redis.syncCmd.zrangeWithScores(destKey, 0, -1);
		System.out.println("zrange "+destKey+" 0 -1 -> "+list5.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZINTERSTORE

// ZINTERSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> return long
protected void zinterstore() {
	String srcKey1 = "myzset1";
	String srcKey2 = "myzset2";
	String destKey = "dest_key";
	try {
		Redis.syncCmd.del(destKey, srcKey1, srcKey2);
		Redis.syncCmd.zadd(srcKey1, 1d, "A", 2d, "B", 3d, "C");
		Redis.syncCmd.zadd(srcKey2, 4d, "B", 5d, "C", 6d, "D");
		List<ScoredValue<String>> list1 = Redis.syncCmd.zrangeWithScores(srcKey1, 0, -1);
		System.out.println("zrange "+srcKey1+" 0 -1 -> "+list1.toString());
		List<ScoredValue<String>> list2 = Redis.syncCmd.zrangeWithScores(srcKey2, 0, -1);
		System.out.println("zrange "+srcKey2+" 0 -1 -> "+list2.toString());
		// zunionstore: numkeys는 넣지 않음.
		Long count = Redis.syncCmd.zinterstore(destKey, srcKey1, srcKey2);
		System.out.println("ZINTERSTORE "+destKey+" "+srcKey1+" "+srcKey2+" -> "+count);
		List<ScoredValue<String>> list3 = Redis.syncCmd.zrangeWithScores(destKey, 0, -1);
		System.out.println("zrange "+destKey+" 0 -1 -> "+list3.toString());
		// Aggregate sum/min/max (defatul: sum)
		ZStoreArgs args = new ZStoreArgs().max();
		Long count2 = Redis.syncCmd.zinterstore(destKey, args, srcKey1, srcKey2);
		System.out.println("ZINTERSTORE "+destKey+" "+srcKey1+" "+srcKey2+" aggregate max -> "+count2);
		List<ScoredValue<String>> list4 = Redis.syncCmd.zrangeWithScores(destKey, 0, -1);
		System.out.println("zrange "+destKey+" 0 -1 -> "+list4.toString());
		// weights
		args.weights(2d, 3d).sum();
		Long count3 = Redis.syncCmd.zinterstore(destKey, args, srcKey1, srcKey2);
		System.out.println("ZINTERSTORE "+destKey+" "+srcKey1+" "+srcKey2+" weights 2 3 -> "+count3);
		List<ScoredValue<String>> list5 = Redis.syncCmd.zrangeWithScores(destKey, 0, -1);
		System.out.println("zrange "+destKey+" 0 -1 -> "+list5.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZSCAN

// ZSCAN key cursor [MATCH pattern] [COUNT count] -> return ScoredValueScanCursor<String>
// zscan은 항상 withscores이다.
protected void zscan() {
	String p = "_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
	try {
		Redis.syncCmd.del(key);
		for (int i=65; i<91; i++) {
			Redis.syncCmd.zadd(key, (double) i, (Character.toString((char) i)+p));
		}
		// limit
		ScanArgs args = new ScanArgs().limit(5);
		ScoredValueScanCursor<String> zset = Redis.syncCmd.zscan(key, args);
		System.out.println("zscan "+key+" limit 5-> "+zset.getValues().size()+" (size)");
		for (ScoredValue<String> sv: zset.getValues()) {
			System.out.println(sv.score+" -> "+sv.value);				
		}
		System.out.println("nextCursor -> "+zset.getCursor());

		System.out.println("-------------------------------------------------------------------------");
		System.out.println("do-while loop");
		ScoredValueScanCursor<String> zset3 = new ScoredValueScanCursor<String>();
		zset3.setCursor("0");
		do {
			zset3 = Redis.syncCmd.zscan(key, zset3);
			System.out.println("zscan "+key+" -> size: "+zset3.getValues().size());
			for (ScoredValue<String> sv: zset3.getValues()) {
				System.out.println(sv.score+" "+sv.value);
			}
			System.out.println("nextCursor -> "+zset3.getCursor()+", Finish: "+zset3.isFinished());

		} while (zset3.isFinished() == false);

		System.out.println("-------------------------------------------------------------------------");
		System.out.println("match F*");
		// match
		args.match("F*");
		ScoredValueScanCursor<String> zset2 = Redis.syncCmd.zscan(key, args);
		System.out.println("zscan "+key+" match F* -> "+zset2.getValues().size()+" (size)");
		for (ScoredValue<String> sv: zset2.getValues()) {
			System.out.println(sv.score+" -> "+sv.value);				
		}

		System.out.println("-------------------------------------------------------------------------");
		System.out.println("ScoredValueStreamingChannel, do-while loop");
		ScanCursor cursor = new ScanCursor();
		cursor.setCursor("0");
		StreamScanCursor stream = null;
		// match
		args.match("F*");
		do {
			stream = Redis.syncCmd.zscan(new ScoredValueStreamingChannel<String>() {
				@Override
				public void onValue(ScoredValue<String> member) {
					System.out.println("zscan (ScoredValueStreamingChannel) -> " +member.score+" "+member.value);
				}
			}, key, cursor, args);
			System.out.println("nextCursor -> "+ stream.getCursor());
			cursor.setCursor(stream.getCursor());
		} while (stream.isFinished() == false);
	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Sets	ZSets	Hashes >>

조회수 :

Email 返事がかかってなれば、メールでお知らせします。