Jedis ZSets

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

ZSets

Class 변수로 선언

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

ZADD

// ZADD key [NX|XX] [CH] [INCR] score member [score member ...] -> Integer reply, specifically:
//		The number of elements added to the sorted sets, not including elements already existing for which the score was updated.
//		If the INCR option is specified, the return value will be Bulk string reply:
//			the new score of member (a double precision floating point number), represented as string.
// add된 member 개수 리턴
protected void zadd() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZADD key [NX|XX] [CH] [INCR] score member [score member ...] -> return long");
	try {
		Redis.cmd.del(key);
		long count = Redis.cmd.zadd(key, 60d, "경기");
		System.out.println("zadd "+key+" 60 경기 -> "+count);
		Map<String, Double> map = new HashMap<String, Double>(); 
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("대전", 100d);
		map.put("전라", 80d);
		count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);
		// Options: NX, XX, CH 있음. INCR은?
		// CH : score를 변경했을 경우 1을 리턴
		count = Redis.cmd.zadd(key, 80d, "전라", ZAddParams.zAddParams().nx());
		System.out.println("zadd "+key+" NX 80 전라 -> "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREM

// ZREM key member [member] -> Integer reply, specifically:
//		The number of members removed from the sorted set, not including non existing members
protected void zrem() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREM key member [member] ->  return long");
	try {
		long count = Redis.cmd.zrem(key, "서울");
		System.out.println("zrem "+key+" 서울 -> "+count);
		long count2 = Redis.cmd.zrem(key, "경기", "부산");
		System.out.println("zrem "+key+" 경기 부산 -> "+count2);
		String list[] = new String[2];
		list[0] = "전라";
		list[1] = "대전";
		long count3 = Redis.cmd.zrem(key, list);
		System.out.println("zrem "+key+" 전라 대전 -> "+count3+" (Array)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGE

// ZRANGE key start stop [withscores] -> Array reply: list of elements in the specified range 
//			(optionally with their scores, in case the WITHSCORES option is given).
protected void zrange() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZRANGE key start stop [withscores] -> return Set<String> or Set<Tuple>");
	try {
		Set<String> set = Redis.cmd.zrange(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 -> "+set.toString());
		// WithScores
		// Tuple 한글 처리 못함.
		Set<Tuple> set2 = Redis.cmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+set2.toString());
		set2.forEach(System.out::println);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZCARD

// ZCARD key -> Integer reply: the cardinality (number of elements) of the sorted set, or 0 if key does not exist.
protected void zcard() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZCARD key -> return Long");
	try {
		Long count = Redis.cmd.zcard(key);
		System.out.println("zcard "+key+" -> "+count);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGEBYSCORE

// ZRANGEBYSCORE key min max [withscores] [limit offset count] -> Array reply: list of elements in the specified score range (optionally with their scores).
protected void zrangebyscore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZRANGEBYSCORE key min max [withscores] [limit offset count] -> return Set<String> ");
	try {
		Set<String> set = Redis.cmd.zrangeByScore(key, 0, 200);	
		System.out.println("zrangebyscore "+key+" 0 200 -> "+set.toString());
		Set<String> set2 = Redis.cmd.zrangeByScore(key, "-inf", "+inf");	
		System.out.println("zrangebyscore "+key+" -inf +inf -> "+set2.toString());
		Set<String> set3 = Redis.cmd.zrangeByScore(key, "(20", "(120");	
		System.out.println("zrangebyscore "+key+" (20 (120 -> "+set3.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZCOUNT

// ZCOUNT key min max -> Integer reply: the number of elements in the specified score range.
protected void zcount() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZCOUNT key min max -> return long");
	try {
		// including
		Long count = Redis.cmd.zcount(key, 20d, 120d);
		System.out.println("zcount "+key+" 20 120 -> "+count);
		// excluding
		Long count2= Redis.cmd.zcount(key, "(20", "(120");
		System.out.println("zcount "+key+" (20 (120 -> "+count2);
		// unbound
		Long count3 = Redis.cmd.zcount(key, "-inf", "+inf");
		System.out.println("zcount "+key+" -inf +inf -> "+count3);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANGEBYLEX

// ZRANGEBYLEX key min max [limit offset count] -> Array reply: list of elements in the specified value range
protected void zrangebylex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZRANGEBYLEX key min max [limit offset count] -> return List<String>");
	try {
		Redis.cmd.del(key);
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("경기", 0d);
		map.put("서울", 0d);
		map.put("부산", 0d);
		map.put("대전", 0d);
		map.put("전라", 0d);
		long count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);
		// including -> [
		Set<String> set = Redis.cmd.zrangeByLex(key, "[경기", "[전라");
		System.out.println("zrangebylex "+key+" [경기 [전라 -> "+set.toString());
		// excluding -> (
		Set<String> set2 = Redis.cmd.zrangeByLex(key, "(경기", "(전라");
		System.out.println("zrangebylex "+key+" (경기 (전라 -> "+set2.toString());
		// Limit offset count
		Set<String> set3 = Redis.cmd.zrangeByLex(key, "(경기", "(전라", 0, 1);
		System.out.println("zrangebylex "+key+" (경기 (전라 limit 0 1 -> "+set3.toString());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZLEXCOUNT

// ZLEXCOUNT key min max -> Integer reply: the number of elements in the specified score range.
protected void zlexcount() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZLEXCOUNT key min max -> return long");
	try {
		Redis.cmd.del(key);
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("경기", 0d);
		map.put("서울", 0d);
		map.put("부산", 0d);
		map.put("대전", 0d);
		map.put("전라", 0d);
		long count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);
		// including
		Long count2 = Redis.cmd.zlexcount(key, "[경기", "[전라");
		System.out.println("zlexcount "+key+" [경기 [전라 -> "+count2+" (including)");
		// excluding
		Long count3 = Redis.cmd.zlexcount(key, "(경기", "(전라");
		System.out.println("zlexcount "+key+" (경기 (전라 -> "+count3+" (excluding)");
		// excluding, unbounded
		Long count4 = Redis.cmd.zlexcount(key, "(경기", "+");
		System.out.println("zlexcount "+key+" (경기 + -> "+count4+" (excluding, unbounded)");
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYRANK

// ZREMRANGEBYRANK key start stop -> Integer reply: the number of elements removed.
protected void zremrangebyrank() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREMRANGEBYRANK key start stop -> return long");
	try {
		// del
		Redis.cmd.del(key);
		// zadd
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("경기", 60d);
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("대전", 100d);
		map.put("전라", 80d);
		long count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);
		// zrange
		Set<Tuple> set = Redis.cmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+set.toString()+" "+set.size());
		set.forEach(System.out::println);
		// zremrangebyrank
		long count2 = Redis.cmd.zremrangeByRank(key, 1, 3);
		System.out.println("zremrangebyrank "+key+" 1 3 -> "+count2);
		// zrange
		Set<Tuple> set2 = Redis.cmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+set2.toString()+" "+set2.size());
		set2.forEach(System.out::println);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYSCORE

// ZREMRANGEBYSCORE key min max -> Integer reply: the number of elements removed.
protected void zremrangebyscore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREMRANGEBYSCORE key min max -> return long");
	try {
		// del
		Redis.cmd.del(key);
		// zadd
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("경기", 60d);
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("대전", 100d);
		map.put("전라", 80d);
		long count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);
		// zrange : before
		Set<Tuple> set = Redis.cmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+set.toString()+" "+set.size());
		set.forEach(System.out::println);
		// zremrangebyscore
		Long count2 = Redis.cmd.zremrangeByScore(key, 40d, 80d);
		System.out.println("zremrangebyscore "+key+" 40 80 -> "+count2+" (including)");
		// zrange : after
		Set<Tuple> set2 = Redis.cmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+set2.toString()+" "+set2.size());
		set2.forEach(System.out::println);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREMRANGEBYLEX

// ZREMRANGEBYLEX key min max -> Integer reply: the number of elements removed.
protected void zremrangebylex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREMRANGEBYLEX key min max -> return long");
	try {
		// del
		Redis.cmd.del(key);
		// zadd
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("경기", 0d);
		map.put("서울", 0d);
		map.put("부산", 0d);
		map.put("대전", 0d);
		map.put("전라", 0d);
		long count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);
		// zrange : before
		Set<Tuple> set = Redis.cmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+set.toString()+" "+set.size());
		set.forEach(System.out::println);
		// zremrangebylex
		Long count2 = Redis.cmd.zremrangeByLex(key, "[대전", "[서울");
		System.out.println("zremrangebylex "+key+" [대전 [서울 -> "+count2+" (including)");
		// zrange : after
		Set<Tuple> set2 = Redis.cmd.zrangeWithScores(key, 0, -1);
		System.out.println("zrange "+key+" 0 -1 withscores -> "+set2.toString()+" "+set2.size());
		set2.forEach(System.out::println);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGE

// ZREVRANGE key start stop [withscores] -> Array reply: list of elements in the specified range (optionally with their scores).
protected void zrevrange() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREVRANGE key start stop [withscores] -> return Set<Tuple>");
	try {
		// del
		Redis.cmd.del(key);
		// zadd
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("경기", 60d);
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("대전", 100d);
		map.put("전라", 80d);
		long count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);
		// zrevrange
		Set<Tuple> set = Redis.cmd.zrevrangeWithScores(key, 0, -1);
		System.out.println("zrevrange "+key+" 0 -1 withscores -> "+set.toString()+" "+set.size());
		set.forEach(System.out::println);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGEBYSCORE

// ZREVRANGEBYSCORE key max min [withscores] [limit offset count] -> Array reply: list of elements in the specified score range (optionally with their scores).
protected void zrevrangebyscore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREVRANGEBYSCORE key max min [withscores] [limit offset count] -> return Set<Tuple>");
	try {
		// del
		Redis.cmd.del(key);
		// zadd
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("경기", 60d);
		map.put("서울", 20d);
		map.put("부산", 40d);
		map.put("대전", 100d);
		map.put("전라", 80d);
		long count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);
		// zrevrangebyscore
		Set<Tuple> set = Redis.cmd.zrevrangeByScoreWithScores(key, 80d, 40d);
		System.out.println("zrevrangebyscore "+key+" 80 40 withscores -> "+set.toString()+" "+set.size());
		set.forEach(System.out::println);
		// Limit offset count
		Set<Tuple> set2 = Redis.cmd.zrevrangeByScoreWithScores(key, 80d, 40d, 1, 2);
		System.out.println("zrevrangebyscore "+key+" 80 40 limit 1 2 withscores -> "+set2.toString()+" "+set2.size());
		set2.forEach(System.out::println);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANGEBYLEX

// ZREVRANGEBYLEX key max min [limit offset count] -> Array reply: list of elements in the specified score range.
protected void zrevrangebylex() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREVRANGEBYLEX key max min [limit offset count] -> return Set<String>");
	try {
		// del
		Redis.cmd.del(key);
		// zadd
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("경기", 0d);
		map.put("서울", 0d);
		map.put("부산", 0d);
		map.put("대전", 0d);
		map.put("전라", 0d);
		long count = Redis.cmd.zadd(key, map);
		System.out.println("zadd "+key+" -> "+count);

		Set<String> set = Redis.cmd.zrevrangeByLex(key, "+", "-");
		System.out.println("zrevrangebylex "+key+" + - -> "+set.toString()+" "+set.size());
		// [ 포함 including, ( 미포함 excluding
		// zrevrangebylex
		Set<String> set2 = Redis.cmd.zrevrangeByLex(key, "[대전", "[서울");
		System.out.println("zrevrangebylex "+key+" [서울 [대전 -> "+set2.toString()+" "+set2.size());
		// Limit offset count
		Set<String> set3 = Redis.cmd.zrevrangeByLex(key,  "[대전", "[서울", 1, 2);
		System.out.println("zrevrangebylex "+key+" [서울 [대전 limit 1 2 -> "+set3.toString()+" "+set3.size());
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZRANK

// ZRANK key member -> If member exists in the sorted set, Integer reply: the rank of member.
//								If member does not exist in the sorted set or key does not exist, Bulk string reply: nil.
protected void zrank() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZRANK key member -> return long");
	try {
		Long index = Redis.cmd.zrank(key, "대전");
		System.out.println("zrank "+key+" 대전 -> "+index);
		Long index2 = Redis.cmd.zrank(key, "서울");
		System.out.println("zrank "+key+" 서울 -> "+index2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZREVRANK

// ZREVRANK key member -> If member exists in the sorted set, Integer reply: the rank of member.
//									If member does not exist in the sorted set or key does not exist, Bulk string reply: nil.
protected void zrevrank() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZREVRANK key member -> return long");
	try {
		Long index = Redis.cmd.zrevrank(key, "대전");
		System.out.println("zrevrank "+key+" 대전 -> "+index);
		Long index2 = Redis.cmd.zrevrank(key, "서울");
		System.out.println("zrevrank "+key+" 서울 -> "+index2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZSCORE

// ZSCORE key member -> Bulk string reply: the score of member (a double precision floating point number), represented as string.
protected void zscore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZSCORE key member -> return double");
	try {
		Double score = Redis.cmd.zscore(key, "대전");
		System.out.println("ZSCORE "+key+" 대전 -> "+score);
		Double score2 = Redis.cmd.zscore(key, "서울");
		System.out.println("ZSCORE "+key+" 서울 -> "+score2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZINCRBY

// ZINCRBY key increment member -> Bulk string reply: the new score of member (a double precision floating point number), represented as string.
protected void zincrby() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZINCRBY key increment member -> return double");
	long time = System.currentTimeMillis(); 
	String key = "daily_views";
	String mem = new SimpleDateFormat("yyyyMMdd").format(time);		
	try {
		Double score = Redis.cmd.zincrby(key, 1, mem);
		System.out.println("ZINCRBY "+key+" 1 "+mem+" -> "+score);
		Double score2 = Redis.cmd.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] -> Integer reply: the number of elements in the resulting sorted set at destination.
protected void zunionstore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZUNIONSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> return long");
	String srcKey1 = "myzset1";
	String srcKey2 = "myzset2";
	String destKey = "dest_key";
	try {
		Redis.cmd.del(destKey, srcKey1, srcKey2);
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("A", 1d);
		map.put("B", 2d);
		map.put("C", 3d);
		Redis.cmd.zadd(srcKey1, map);
		Map<String, Double> map2 = new HashMap<String, Double>();
		map2.put("B", 4d);
		map2.put("C", 5d);
		map2.put("D", 6d);
		Redis.cmd.zadd(srcKey2, map2);
		
		Set<Tuple> set1 = Redis.cmd.zrangeWithScores(srcKey1, 0, -1);
		System.out.println("zrange "+srcKey1+" 0 -1 -> "+set1.toString());
		set1.forEach(System.out::println);
		Set<Tuple> set2 = Redis.cmd.zrangeWithScores(srcKey2, 0, -1);
		System.out.println("zrange "+srcKey2+" 0 -1 -> "+set2.toString());
		set2.forEach(System.out::println);
		// zunionstore: numkeys는 넣지 않음.
		Long count = Redis.cmd.zunionstore(destKey, srcKey1, srcKey2);
		System.out.println("ZUNIONSTORE "+destKey+" "+srcKey1+" "+srcKey2+" -> "+count);
		Set<Tuple> set3 = Redis.cmd.zrangeWithScores(destKey, 0, -1);
		System.out.println("zrange "+destKey+" 0 -1 -> "+set3.toString());
		set3.forEach(System.out::println);
		// Aggregate sum/min/max (defatul: sum)
		//Long count2 = Redis.cmd.zunionstore(destKey, ZParams.Aggregate.MAX, srcKey1, srcKey2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZINTERSTORE

// ZINTERSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> Integer reply: the number of elements in the resulting sorted set at destination.
protected void zinterstore() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZINTERSTORE dest_key numkeys src_key [src_key ...] [WEIGHTS weight [weight ...]] [AGGREGATE SUM|MIN|MAX] -> return long");
	String srcKey1 = "myzset1";
	String srcKey2 = "myzset2";
	String destKey = "dest_key";
	try {
		Redis.cmd.del(destKey, srcKey1, srcKey2);
		Map<String, Double> map = new HashMap<String, Double>();
		map.put("A", 1d);
		map.put("B", 2d);
		map.put("C", 3d);
		Redis.cmd.zadd(srcKey1, map);
		Map<String, Double> map2 = new HashMap<String, Double>();
		map2.put("B", 4d);
		map2.put("C", 5d);
		map2.put("D", 6d);
		Redis.cmd.zadd(srcKey2, map2);
		
		Set<Tuple> set1 = Redis.cmd.zrangeWithScores(srcKey1, 0, -1);
		System.out.println("zrange "+srcKey1+" 0 -1 -> "+set1.toString());
		set1.forEach(System.out::println);
		Set<Tuple> set2 = Redis.cmd.zrangeWithScores(srcKey2, 0, -1);
		System.out.println("zrange "+srcKey2+" 0 -1 -> "+set2.toString());
		set2.forEach(System.out::println);
		// zinterstore: numkeys는 넣지 않음.
		Long count = Redis.cmd.zinterstore(destKey, srcKey1, srcKey2);
		System.out.println("ZINTERSTORE "+destKey+" "+srcKey1+" "+srcKey2+" -> "+count);
		Set<Tuple> set3 = Redis.cmd.zrangeWithScores(destKey, 0, -1);
		System.out.println("zrange "+destKey+" 0 -1 -> "+set3.toString());
		set3.forEach(System.out::println);
		// Aggregate sum/min/max (defatul: sum)
		// Long count2 = Redis.cmd.zinterstore(destKey, ZParams.Aggregate.MAX, srcKey1, srcKey2);
	} catch (Exception e) {
		System.out.println(e);
	}
}

ZSCAN

// ZSCAN key cursor [MATCH pattern] [COUNT count] -> array of elements contain two elements, a member and its 
// zscan은 항상 withscores이다.
protected void zscan() {
	System.out.println("-------------------------------------------------------------------------");
	System.out.println("ZSCAN key cursor [MATCH pattern] [COUNT count] -> return ScanResult<Tuple>");
	String p = "_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
	try {
		Redis.cmd.del(key);
		Map<String, Double> map = new HashMap<String, Double>();
		for (int i=65; i<91; i++) {
			map.put((Character.toString((char) i)+p), (double) i);
		}
		Redis.cmd.zadd(key, map);
		
		ScanResult<Tuple> set = Redis.cmd.zscan(key, "0");
		System.out.println(set.getResult()+" "+set.getStringCursor());
		do {
			set = Redis.cmd.zscan(key, set.getStringCursor());
			System.out.println(set.getResult()+" "+set.getStringCursor());
		} while ( !(set.getStringCursor().equals("0")) );
	} catch (Exception e) {
		System.out.println(e);
	}
}

<< Sets	ZSets	Hashes >>

Email 답글이 올라오면 이메일로 알려드리겠습니다.