Lettuce Sets

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

Sets

Class 변수로 선언

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

SADD

// SADD key member [member ...] -> return Long
protected void sadd() {
	try {
		long retLong = Redis.syncCmd.sadd(key, "value"+idx);
		// Redis.syncCmd.sadd(key, "value2", "value3");
		// String set[] = new String[10];
		// Redis.syncCmd.sadd(key, set);
		System.out.println("sadd "+key+" value"+idx+" -> " +retLong);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
}

SREM

// SREM key member [member ...] -> return Long
protected void srem() {
	try {
		long retLong = Redis.syncCmd.srem(key, "value"+idx);
		// Redis.syncCmd.srem(key, "value2", "value3");
		// String set[] = new String[10];
		// Redis.syncCmd.srem(key, set);
		System.out.println("srem "+key+" value"+idx+" -> " +retLong);
		idx++;
	} catch (Exception e) {
		System.out.println(e);
	}
}

SMEMBERS

// SMEMBERS key -> return Set<String>
protected void smembers() {
	try {
		Set<String> set = Redis.syncCmd.smembers(key);
		System.out.println("smembers "+key+" -> " +set.toString());
		for (String member: set) {
			System.out.println("smembers "+key+" -> " +member);
		}
		// Set에 real memory보다 더 많은 member가 있을 경우 ValueStreamingChannel 사용
		long count = Redis.syncCmd.smembers(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String member) {
				System.out.println("smembers "+key+" (ValueStreamingChannel) -> " +member);
			}
		}, key);
		System.out.println("smembers "+key+" (ValueStreamingChannel) -> " +count);

	} catch (Exception e) {
		System.out.println(e);
	}
}

SCARD

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

SUNION

// SUNION key [key ...] -> return Set<String>
protected void sunion() {
	try {
		Redis.syncCmd.del("myset1", "myset2");
		Redis.syncCmd.sadd("myset1", "A", "B", "C");
		Redis.syncCmd.sadd("myset2", "B", "C", "D");
		Set<String> set = Redis.syncCmd.sunion("myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sunion myset1 myset2 -> " +set.toString());
		// ValueStreamingChannel
		long count = Redis.syncCmd.sunion(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String member) {
				System.out.println("sunion myset1 myset2 (ValueStreamingChannel) -> " +member);
			}
		}, "myset1", "myset2");
	System.out.println("sunion myset1 myset2 (ValueStreamingChannel) -> " +count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SINTER

// SINTER key [key ...] -> return Set<String>
protected void sinter() {
	try {
		Redis.syncCmd.del("myset1", "myset2");
		Redis.syncCmd.sadd("myset1", "A", "B", "C");
		Redis.syncCmd.sadd("myset2", "B", "C", "D");
		Set<String> set = Redis.syncCmd.sinter("myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sinter myset1 myset2 -> " +set.toString());
		// ValueStreamingChannel
		long count = Redis.syncCmd.sinter(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String member) {
				System.out.println("sinter myset1 myset2 (ValueStreamingChannel) -> " +member);
			}
		}, "myset1", "myset2");
	System.out.println("sinter myset1 myset2 (ValueStreamingChannel) -> " +count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SDIFF

// SDIFF key [key ...] -> return Set<String>
protected void sdiff() {
	try {
		Redis.syncCmd.del("myset1", "myset2");
		Redis.syncCmd.sadd("myset1", "A", "B", "C");
		Redis.syncCmd.sadd("myset2", "B", "D");
		Set<String> set = Redis.syncCmd.sdiff("myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, D]");
		System.out.println("sdiff myset1 myset2 -> " +set.toString());
		// ValueStreamingChannel
		long count = Redis.syncCmd.sdiff(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String member) {
				System.out.println("sdiff myset1 myset2 (ValueStreamingChannel) -> " +member);
			}
		}, "myset1", "myset2");
	System.out.println("sdiff myset1 myset2 (ValueStreamingChannel) -> " +count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SUNIONSTORE

// SUNIONSTORE destination_key source_key [source_key ...] -> return Long
protected void sunionstore() {
	try {
		Redis.syncCmd.del("myset1", "myset2");
		Redis.syncCmd.sadd("myset1", "A", "B", "C");
		Redis.syncCmd.sadd("myset2", "B", "C", "D");
		long count = Redis.syncCmd.sunionstore("dest_key", "myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sunionstore dest_key myset1 myset2 -> " +count);
		Set<String> set = Redis.syncCmd.smembers("dest_key");
		System.out.println("smember dest_key -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SINTERSTORE

// SINTERSTORE destination_key source_key [source_key ...] -> return Long
protected void sinterstore() {
	try {
		Redis.syncCmd.del("myset1", "myset2");
		Redis.syncCmd.sadd("myset1", "A", "B", "C");
		Redis.syncCmd.sadd("myset2", "B", "C", "D");
		long count = Redis.syncCmd.sinterstore("dest_key", "myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, C, D]");
		System.out.println("sinterstore dest_key myset1 myset2 -> " +count);
		Set<String> set = Redis.syncCmd.smembers("dest_key");
		System.out.println("smember dest_key -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SDIFFSTORE

// SDIFFSTORE destination_key source_key [source_key ...] -> return Long
protected void sdiffstore() {
	try {
		Redis.syncCmd.del("myset1", "myset2");
		Redis.syncCmd.sadd("myset1", "A", "B", "C");
		Redis.syncCmd.sadd("myset2", "B", "D");
		long count = Redis.syncCmd.sdiffstore("dest_key", "myset1", "myset2");
		System.out.println("myset1 -> [A, B, C]");
		System.out.println("myset2 -> [B, D]");
		System.out.println("sdiffstore dest_key myset1 myset2 -> " +count);
		Set<String> set = Redis.syncCmd.smembers("dest_key");
		System.out.println("smember dest_key -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SISMEMBER

// SISMEMBER key member -> return Boolean
protected void sismember() {
	try {
		Redis.syncCmd.del(key);
		Redis.syncCmd.sadd(key, "멤버_1", "멤버_2");
		Set<String> set = Redis.syncCmd.smembers(key);
		System.out.println("smembers "+key+" -> " +set.toString());
		Boolean is1 = Redis.syncCmd.sismember(key, "멤버_1");
		System.out.println("sismember "+key+" 멤버_1 -> " +is1);
		Boolean is2 = Redis.syncCmd.sismember(key, "멤버_X");
		System.out.println("sismember "+key+" 멤버_X -> " +is2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SMOVE

// SMOVE source_key destination_key member -> return Boolean
protected void smove() {
	try {
		Redis.syncCmd.del("src_key", "dest_key");
		Redis.syncCmd.sadd("src_key", "A", "B", "C");
		Redis.syncCmd.sadd("dest_key", "D");
		Set<String> src = Redis.syncCmd.smembers("src_key");
		System.out.println("smembers src_key -> " +src.toString());
		Set<String> dest = Redis.syncCmd.smembers("dest_key");
		System.out.println("smembers dest_key -> " +dest.toString());
		
		Boolean move = Redis.syncCmd.smove("src_key", "dest_key", "A");
		System.out.println("smove src_key dest_key A -> "+move);
		Set<String> src2 = Redis.syncCmd.smembers("src_key");
		System.out.println("smembers src_key -> " +src2.toString());
		Set<String> dest2 = Redis.syncCmd.smembers("dest_key");
		System.out.println("smembers dest_key -> " +dest2.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SPOP

// SPOP key [count] -> return String or Set<String>
protected void spop() {
	try {
		Redis.syncCmd.del(key);
		Redis.syncCmd.sadd(key, "멤버_1", "멤버_2", "멤버_3");
		String m = Redis.syncCmd.spop(key);
		System.out.println("spop "+key+" -> " +m);
		Set<String> set = Redis.syncCmd.spop(key, 2);
		System.out.println("spop "+key+" 2 -> " +set.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

SRANDMEMBER

// SRANDMEMBER key [count] -> return String or Set<String> or long(ValueStreamingChannel)
protected void srandmember() {
	try {
		Redis.syncCmd.del(key);
		Redis.syncCmd.sadd(key, "멤버_1", "멤버_2", "멤버_3", "멤버_4", "멤버_5", "멤버_6", "멤버_7", "멤버_8", "멤버_9");
		Set<String> src = Redis.syncCmd.smembers(key);
		System.out.println("smembers "+key+" -> " +src.toString());
		
		String m = Redis.syncCmd.srandmember(key);
		System.out.println("srandmember "+key+" -> " +m);
		// return set이 아니고 list이다. count가 음수이면 값이 중복될 수 있다.
		List<String> list = Redis.syncCmd.srandmember(key, 2);
		System.out.println("srandmember "+key+" 2 -> " +list.toString());
		// ValueStreamingChannel
		long count = Redis.syncCmd.srandmember(new ValueStreamingChannel<String>() {
			@Override
			public void onValue(String member) {
				System.out.println("srandmember (ValueStreamingChannel) -> " +member);
			}
		}, key, 5);
		System.out.println("srandmember "+key+" 5 (ValueStreamingChannel) -> " +count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

SSCAN

// SSCAN key cursor [MATCH pattern] [COUNT count] -> return ValueScanCursor<String> or StreamScanCursor
protected void sscan() {
	try {
		Redis.syncCmd.del(key);
		Redis.syncCmd.sadd(key, "A1", "A2", "A3", "B1", "B2", "B3", "C1", "C2", "C3", "D1", "D2", "D3", "E1", "E2", "E3");
		Set<String> src = Redis.syncCmd.smembers(key);
		System.out.println("smembers "+key+" -> " +src.toString()+" "+src.size());
		
		ValueScanCursor<String> set = Redis.syncCmd.sscan(key);
		System.out.println(set.getValues().toString()+" "+set.getValues().size());
		System.out.println("nextCursor -> "+set.getCursor());
		
		ScanCursor cursor = new ScanCursor();
		cursor.setCursor(set.getCursor());
		ValueScanCursor<String> set2 = Redis.syncCmd.sscan(key, cursor);
		System.out.println(set2.getValues().toString()+" count -> "+set2.getValues().size());
		System.out.println("nextCursor -> "+set2.getCursor());
		
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("do-while loop");
		ScanCursor cursor2 = new ScanCursor();
		cursor2.setCursor("0");
		ValueScanCursor<String> set3 = null;
		do {
			set3 = Redis.syncCmd.sscan(key, cursor2);
			System.out.println(set3.getValues().toString()+" count -> "+set3.getValues().size());
			System.out.println("nextCursor -> "+set3.getCursor());
			cursor2.setCursor(set3.getCursor());
		} while (set3.isFinished() == false);
		
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("match A* count 100");
		// ScanArgs ->  [MATCH pattern] [COUNT count]
		ScanArgs args = new ScanArgs();
		args.match("A*").limit(100);
		// args.match("A*").match("B*"); 	// 마지막 match가 적용.  redis-cli에서도 동일함.
		ValueScanCursor<String> set4 = Redis.syncCmd.sscan(key, args);
		System.out.println(set4.getValues().toString()+" count -> "+set4.getValues().size());
		
		System.out.println("-------------------------------------------------------------------------");
		System.out.println("ValueStreamingChannel, do-while loop");

		ScanCursor cursor3 = new ScanCursor();
		cursor3.setCursor("0");
		StreamScanCursor stream = null;
		do {
			stream = Redis.syncCmd.sscan(new ValueStreamingChannel<String>() {
				@Override
				public void onValue(String member) {
					System.out.println("sscan (ValueStreamingChannel) -> " +member);
				}
			}, key, cursor3);
			System.out.println("nextCursor -> "+ stream.getCursor());
			cursor3.setCursor(stream.getCursor());
		} while (stream.isFinished() == false);

	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Lists	Sets	ZSets >>

조회수 :

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