Clients

Lettuce for Redis Enterprise

Redis Developer Course	Redis Technical Support	Redis Enterprise Server

Lettuce for Redis Enterprise

Lettuce 6.1.3.ENT에서 지원하는 Redis Enterprise 명령

공통 COMMON

포함해야 할 package

Import package

import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.Map;

import io.lettuce.core.RedisClient;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;
import io.lettuce.core.KeyValue;
import io.lettuce.core.ScoredValue;

접속 connection

Connect to Redis Server

RedisClient redisClient = RedisClient.create("redis://127.0.0.1:6379/0");
StatefulRedisConnection<String, String> connection = redisClient.connect();
RedisCommands<String, String> syncCommands = connection.sync();

CD (change database)

Redis Enterprise에서는 데이터베이스 변경 시 cd를 사용합니다.
Select는 데이터를 조회하는 SQL Select로 사용합니다.

사용 예

cd 1 -> syncCommands.cd(1); 1번 db로 옮깁니다.

Test code

/* CD [index] */
String ret = syncCommands.cd(1);
System.out.println("cd(1) -> "+ret);
결과: cd(1) -> OK

LS (list)

패턴을 키를 조회할 수 있고 다른 다양한 방법으로 키를 조회할 수 있습니다.

사용 예

ls * -> syncCommands.ls("*"); 모든 키를 조회합니다.
ls user* -> syncCommands.ls("user*"); user로 시작하는 키를 조회합니다.
ls * string -> syncCommands.ls("*","string"); string 키를 모두 조회합니다.
ls * type -> syncCommands.ls("*","type"); 모든 키와 data type을 조회합니다.
ls * memory -> syncCommands.ls("*","memory"); 모든 키와 키가 사용하고 있는 메모리를 조회합니다.
ls * sort -> syncCommands.ls("*","sort"); 모든 키를 소트해서 조회합니다.
ls * count 10 -> syncCommands.ls("*","count","10"); 키를 10개만 조회합니다.

Test code

/* LS [pattern] [string|list|set|zset|hash|stream]
      [type|encoding|value|strlen|len|memory|ttl|pttl|idletime|slot|time|expire_keys|default]
      [table]
      [sort|asc|desc]
      [count <integer>] [top <integer>] */

// ls * 
List<String> keys = syncCommands.ls("*");
System.out.println("  ls * -> size: "+keys2.size()+", "+keys2.toString());
결과: ls * -> size: 11, [user2, key2, key10, key3, key1, user1, meset, myset, mylist, user10, user3]

// ls * sort
keys = syncCommands.ls("*","sort");
System.out.println("  ls * sort -> size: "+keys.size()+", "+keys.toString());
결과: ls * sort -> size: 11, [key1, key10, key2, key3, meset, mylist, myset, user1, user10, user2, user3]

// ls * desc 
keys = syncCommands.ls("*","desc");
System.out.println("  ls * desc -> size: "+keys.size()+", "+keys.toString());
결과: ls * desc -> size: 11, [user3, user2, user10, user1, myset, mylist, meset, key3, key2, key10, key1]

// ls * count 2 
keys = syncCommands.ls("*","count","2");
System.out.println("  ls * count 2 -> size: "+keys.size()+", "+keys.toString());
결과: ls * count 2 -> size: 2, [user2, key2]

// ls * sort top 2 
keys = syncCommands.ls("*","sort","top","2");
System.out.println("  ls * sort top 2 -> size: "+keys.size()+", "+keys.toString());
결과: ls * sort top 2 -> size: 2, [key1, key10]

// ls user* 
List<String> keys3 = syncCommands.ls("user*");
System.out.println("  ls user* -> size: "+keys3.size()+", "+keys3.toString());
결과: ls user* -> size: 4, [user2, user1, user10, user3]

// ls user? 
keys = syncCommands.ls("user?");
System.out.println("  ls user? -> size: "+keys.size()+", "+keys.toString());
결과: ls user? -> size: 3, [user2, user1, user3]

// ls m[ye]set 
keys = syncCommands.ls("m[ye]set");
System.out.println("  ls my[ye]set -> size: "+keys.size()+", "+keys.toString());
결과: ls my[ye]set -> size: 2, [meset, myset]

// ls * string 
keys = syncCommands.ls("*","string");
System.out.println("  ls * string -> size: "+keys.size()+", "+keys.toString());
결과: ls * string -> size: 10, [key1, key10, key2, key3, meset, myset, user1, user10, user2, user3]

// ls * type 
keys = syncCommands.ls("*","type");
System.out.println("  ls * type -> size: "+keys.size()+", "+keys.toString());
결과: ls * type -> size: 22, [user2, string, key2, string, key10, string, key3, string, key1, string, user1, string, meset, string, myset, string, mylist, list, user10, string, user3, string]

// ls * memory 
keys = syncCommands.ls("*","memory");
System.out.println("  ls * memory -> size: "+keys.size()+", "+keys.toString());
결과: ls * memory -> size: 22, [user2, 71, key2, 70, key10, 70, key3, 70, key1, 70, user1, 71, meset, 75, myset, 75, mylist, 171, user10, 73, user3, 71]

// ls * string value 
keys = syncCommands.ls("*","string","value");
System.out.println("  ls * string value -> size: "+keys.size()+", "+keys.toString());
결과: ls * string value -> size: 20, [key1, value1, key10, key11, key2, value2, key3, value3, meset, mesetValue, myset, mysetValue, user1, Redis1, user10, Redis10, user2, Redis2, user3, Redis3]

RM (remove)

삭제할 키를 여러 개 지정할 수 있고, 서브쿼리를 사용할 수 있습니다.

사용 예

rm key1 -> syncCommands.rm("key1"); key1을 삭제합니다.
rm key2 key3 -> syncCommands.rm("key2","key3"); key2, key3을 삭제합니다.

Test code

/* RM key [key ...] */

// rm 'key1'
Long count = syncCommands.rm("key1");
System.out.println("  rm(key1) -> "+count);
결과: rm(key1) -> 1

// rm 'key2', 'key3'
Long count = syncCommands.rm("key2","key3");
System.out.println("  rm(key2, key3) -> "+count);
결과: rm(key2, key3) -> 2

RMS (remove subquery)

서브쿼리를 사용할 수 있습니다.

사용 예

rms (get key) -> syncCommands.rms("(get key)"); get key의 결과로 키를 삭제합니다.
rms (ls user*) -> syncCommands.rms("(ls user*)"); user로 시작하는 키를 삭제합니다.
rms (ls * string) -> syncCommands.rms("(ls * string)"); string 키 모두를 삭제합니다.

Test code

/* RMS (subquery) */

syncCommands.set("key10", "key11");
syncCommands.set("key11", "value11");
// rms '(get key10)' 
count = syncCommands.rms("(get key10)");
System.out.println("  rms('get key10') -> "+count);
결과: rms('get key10') -> 1

syncCommands.set("mykey1", "myvalue1");
syncCommands.set("mykey2", "myvalue2");
syncCommands.set("mykey3", "myvalue3");
syncCommands.lpush("mylist", "mykey1","mykey2","mykey3");

// rms '(lrange mylist 0 -1)' 
count = syncCommands.rms("(lrange mylist 0 -1)");
System.out.println("  rms('lrange mylist 0 -1') -> "+count);
결과: rms('lrange mylist 0 -1') -> 3

// rms '(ls user*)' 
count = syncCommands.rms("(ls user*)");
System.out.println("  rms('ls user*') -> "+count);
결과: rms('ls user*') -> 4

SQL

SELECT

SELECT로 데이터를 조회합니다.

사용 예

select * from string.*; -> syncCommands.sqlselect('select * from string.*;'); String 키,값을 조회합니다.
select * from list.*; -> syncCommands.sqlselect('select * from list.*;'); List 키,값을 조회합니다.
select * from set.*; -> syncCommands.sqlselect('select * from set.*;'); Set 키,값을 조회합니다.
select * from zset.*; -> syncCommands.sqlselect('select * from zset.*;'); ZSet 키,값을 조회합니다.
select * from hash.*; -> syncCommands.sqlselect('select * from hash.*;'); Hash 키,값을 조회합니다.
select * from stream.*; -> syncCommands.sqlselect('select * from stream.*;'); Stream 키,값을 조회합니다.

String Test code

Test code 1: select key from string.*; String sql = "select key from string.*"; List<Object> select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key] 1) [key] 2) [key1] 3) [key10] 4) [key2] 5) [key3] 6) [key4] 7) [meset] 8) [user1] 9) [user10] 10) [user2] 11) [user3]
Test code 2: select * from string.*; sql = "select * from string.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, value] 1) [key, Hello Redis!] 2) [key1, value1] 3) [key10, key11] 4) [key2, value2] 5) [key3, value3] 6) [key4, Hello Redis!Hello Redis!] 7) [meset, mesetValue] 8) [user1, Redis1] 9) [user10, Redis10] 10) [user2, Redis2] 11) [user3, Redis3]
Test code 3: select count(*) from string.*; sql = "select count(*) from string.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [count(*)] 1) [11]
Test code 4: select * from string.user*; sql = "select * from string.user*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, value] 1) [user1, Redis1] 2) [user10, Redis10] 3) [user2, Redis2] 4) [user3, Redis3]
Test code 5: select * from string.user1; sql = "select * from string.user1"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, value] 1) [user1, Redis1]
Test code 6: select min(key), max(key) from string.*; sql = "select min(key), max(key) from string.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [min(key), max(key)] 1) [key, user3]
Test code 7: select * from string.* where key <= 'key3'; sql = "select * from string.* where key <= 'key3'"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, value] 1) [key, Hello Redis!] 2) [key1, value1] 3) [key10, key11] 4) [key2, value2] 5) [key3, value3]
Test code 8: select * from string.* where value glob 'value*'; sql = "select * from string.* where value glob 'value*'"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, value] 1) [key1, value1] 2) [key2, value2] 3) [key3, value3]
Test code 9: select left(key,3), count(*) from string.* group by left(key,3); sql = "select left(key,3), count(*) from string.* group by left(key,3)"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [left(key,3), count(*)] 1) [key, 6] 2) [mes, 1] 3) [use, 4]

List Test code

Test code 1: select * from list.*; sql = "select * from list.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, value] 1) [mylist, mykey1] 2) [mylist, mykey2] 3) [mylist, mykey3] 4) [mylist, Hello Redis!] 5) [mylist, Hello Redis!] 6) [mylist, mykey3] 7) [mylist, mykey2] 8) [mylist, mykey1] 9) [mylist2, Hello Redis!] 10) [mylist2, mykey1] 11) [mylist2, mykey2] 12) [mylist2, mykey3] 13) [mylist2, A1] 14) [mylist2, A2] 15) [mylist2, A3] 16) [mylist2, Hello Redis!] 17) [mylist2, Hello Redis!] 18) [mylist2, A3] 19) [mylist2, A2] 20) [mylist2, A1] 21) [mylist2, mykey3] 22) [mylist2, mykey2] 23) [mylist2, mykey1]

Set Test code

Test code 1: select * from set.*; sql = "select * from set.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, value] 1) [myset, A3] 2) [myset, A1] 3) [myset, B1] 4) [myset, B2] 5) [myset, B3] 6) [myset, A2] 7) [myset2, B1] 8) [myset2, B2] 9) [myset2, C1] 10) [myset2, C3] 11) [myset2, B3] 12) [myset2, C2] 13) [myset3, B2] 14) [myset3, C1] 15) [myset3, B1] 16) [myset3, C3] 17) [myset3, B3] 18) [myset3, C2] 19) [myset4, Hello Redis!] 20) [myset4, mykey1] 21) [myset4, mykey3] 22) [myset4, mykey2]

ZSet Test code

Test code 1: select * from zset.*; sql = "select * from zset.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, score, value] 1) [myzset, 10.0, A1] 2) [myzset, 20.0, A2] 3) [myzset, 30.0, A3] 4) [myzset, 40.0, B1] 5) [myzset, 50.0, B2] 6) [myzset, 60.0, B3] 7) [myzset4, 0.0, Hello Redis!] 8) [myzset5, 0.0, A1] 9) [myzset5, 0.0, A2] 10) [myzset5, 0.0, A3] 11) [myzset5, 0.0, B1] 12) [myzset5, 0.0, B2] 13) [myzset5, 0.0, B3]

Hash Test code

Test code 1: select * from hash.* sql = "select * from hash.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, A1, A2, A3, B1, B2, B3, user1] 1) [myhash1, AV1, AV2, AV3, (nil), (nil), (nil), (nil)] 2) [myhash2, (nil), (nil), (nil), BV1, BV2, BV3, (nil)] 3) [myhash3, AV1, AV2, AV3, BV1, BV2, BV3, Redis1]

Stream Test code

Test code 1: select * from stream.* sql = "select * from stream.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, id, field1, field2] 1) [sensor_1, 1649813130595-0, value1, value2] 2) [sensor_2, 1649813130596-0, value1, (nil)] 3) [sensor_3, 1649813130596-0, 50.7, (nil)]

Function valcnt(), len(), card() Test code
키에 속한 값/요소(element)/멤버(member) 개수를 조회한다. Valcnt = len = card
String은 항상 1이 조회된다. 다른 데이터 타입은 값의 개수가 조회된다.

Test code: select key, valcnt(key), len(key), card(key) from hash.* sql = "select key, valcnt(key), len(key), card(key) from hash.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, valcnt(key), len(key), card(key)] 1) [myhash1, 3, 3, 3] 2) [myhash2, 3, 3, 3] 3) [myhash3, 7, 7, 7]

Function memory() Test code
키와 값이 차지하고 있는 메모리량을 조회한다.

Test code: select key, memory(key) from hash.* sql = "select key, memory(key) from hash.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, memory(key)] 1) [myhash1, 95] 2) [myhash2, 95] 3) [myhash3, 497]

Function type(), encoding() Test code
키의 데이터 타입, 인코딩 타입을 조회한다.

Test code: select key, type(key), encoding(key) from hash.* sql = "select key, type(key), encoding(key) from hash.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, type(key), encoding(key)] 1) [myhash1, hash, ziplist] 2) [myhash2, hash, ziplist] 3) [myhash3, hash, hashtable]

Function updatetime() Test code
키의 마지막 갱신시각(updatetime)을 조회한다.

Test code: select key, type(key), updatetime(key) from hash.* sql = "select key, type(key), updatetime(key) from hash.*"; select = syncCommands.sqlselect(sql); System.out.println(sql+"; => size: "+select.size()); for(int i=0; i<select.size(); i++) System.out.println(i+") "+select.get(i).toString()); ------ 결과 ------------------------------------------------------- 0) [key, type(key), updatetime(key)] 1) [myhash1, hash, 2022-04-13 10:42:57] 2) [myhash2, hash, 2022-04-13 10:42:57] 3) [myhash3, hash, 2022-04-13 10:42:57]

INSERT

INSERT로 데이터를 저장합니다.

사용 예

String -> syncCommands.sqlinsert("insert into string values('key1','value1')");
List -> syncCommands.sqlinsert("insert into list values('mylist1','value1','value2')");
Set -> syncCommands.sqlinsert("insert into set values('myset1','value1','value2')");
ZSet -> syncCommands.sqlinsert("insert into zset values('zset1', 23.5, 'value1', 36.7, 'value2')");
Hash -> syncCommands.sqlinsert("insert into hash values('myhash1', 'field1', 'value1', 'field2', 'value2')");
Stream -> syncCommands.sqlinsert("insert into stream values('sensor_1', '*', 'field1', 'value1', 'field2', 'value2')");

String insert Test code

Test code: sql = "insert into string values('key1','value1')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); sql = "insert into string values('key2','value2'),('key2','value3')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- insert into string values('key1','value1'); -> 1 inserted insert into string values('key2','value2'),('key2','value3'); -> 2 inserted

List insert Test code

Test code: sql = "insert into list values('mylist1','value1','value2')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); sql = "insert into list values('mylist2','value1','value2'), ('mylist3','value1','value2')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- insert into list values('mylist1','value1','value2'); -> 1 inserted insert into list values('mylist2','value1','value2'), ('mylist3','value1','value2'); -> 2 inserted

Set insert Test code

Test code: sql = "insert into set values('myset1','value1','value2')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); sql = "insert into set values('myset2','value1','value2'), ('myset3','value1','value2');"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- insert into set values('myset1','value1','value2'); -> 1 inserted insert into set values('myset2','value1','value2'), ('myset3','value1','value2'); -> 2 inserted

ZSet insert Test code

Test code: sql = "insert into zset values('zset1', 23.5, 'value1', 36.7, 'value2')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); sql = "insert into zset values('zset2', 23.5, 'value1'), ('zset3', 36.7, 'value2')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- insert into zset values('zset1', 23.5, 'value1', 36.7, 'value2'); -> 1 inserted insert into zset values('zset2', 23.5, 'value1'), ('zset3', 36.7, 'value2'); -> 2 inserted

Hash insert Test code

Test code: sql = "insert into hash values('myhash1', 'field1', 'value1', 'field2', 'value2')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); sql = "insert into hash values('myhash2', 'field1', 'value1'),('myhash3', 'field1', 'value1')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- insert into hash values('myhash1', 'field1', 'value1', 'field2', 'value2'); -> 1 inserted insert into hash values('myhash2', 'field1', 'value1'),('myhash3', 'field1', 'value1'); -> 2 inserted

Stream insert Test code

Test code: sql = "insert into stream values('sensor_1', '*', 'field1', 'value1', 'field2', 'value2')"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); sql = "insert into stream values('sensor_2', '*', 'field1', 'value1'), ('sensor_3', '*', 'field1', 50.7);"; ret = syncCommands.sqlinsert(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- insert into stream values('sensor_1', '*', 'field1', 'value1', 'field2', 'value2'); -> 1 inserted insert into stream values('sensor_2', '*', 'field1', 'value1'), ('sensor_3', '*', 'field1', 50.7); -> 2 inserted

DELETE

DELETE로 데이터를 삭제합니다.

사용 예

String; -> syncCommands.sqldelete("delete from string.key1");
List -> syncCommands.sqldelete("delete from list.mylist1");
Set -> syncCommands.sqldelete("delete from set.myset1");
Zset -> syncCommands.sqldelete("delete from zset.zset1");
Hash -> syncCommands.sqldelete("delete from hash.myhash1");
Stream -> syncCommands.sqldelete("delete from stream.sensor_1");

String delete Test code

Test code: sql = "delete from string.key1"; ret = syncCommands.sqldelete(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- delete from string.key1; -> 1 keys deleted

List delete Test code

Test code: sql = "delete from list.mylist1"; ret = syncCommands.sqldelete(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- delete from list.mylist1; -> 1 keys deleted

Set delete Test code

Test code: sql = "delete from set.myset1"; ret = syncCommands.sqldelete(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- delete from set.myset1; -> 1 keys deleted

ZSet delete Test code

Test code: sql = "delete from zset.zset1"; ret = syncCommands.sqldelete(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- delete from zset.zset1; -> 1 keys deleted

Hash delete Test code

Test code: sql = "delete from hash.myhash1"; ret = syncCommands.sqldelete(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- delete from hash.myhash1; -> 1 keys deleted

Stream delete Test code

Test code: sql = "delete from stream.sensor_1"; ret = syncCommands.sqldelete(sql); System.out.println(sql+"; -> "+ret); ------ 결과 ------------------------------------------------------- delete from stream.sensor_1; -> 1 keys deleted

STRING

SETS

String에서 서브쿼리를 사용해 값을 저장합니다.

사용 예

sets mykey (get key) -> syncCommands.sets("mykey", "(get key)"); get key의 결과 값을 mykey에 넣습니다.

Test code

/* SETS key (subquery) */
syncCommands.set("key", "Hello Redis!");
String ret = syncCommands.sets("mykey", "(get key)");
System.out.println("  sets mykey '(get key)' -> "+ret);
결과: sets mykey '(get key)' -> OK

String v = syncCommands.get("mykey");
System.out.println("  get mykey -> "+v);
결과: get mykey -> Hello Redis!

APPENDS

String에서 서브쿼리를 사용해 값을 추가합니다.

사용 예

appends mykey (get key) -> syncCommands.appends("mykey", "(get key)"); get key의 결과 값을 mykey에 추가합니다.

Test code

/* APPENDS key (subquery) */
Long len = syncCommands.appends("mykey", "(get key)");
System.out.println("  appends mykey '(get key)' -> "+len);
결과: appends mykey '(get key)' -> 24

String v = syncCommands.get("mykey");
System.out.println("  get mykey -> "+v);
결과: get mykey -> Hello Redis!Hello Redis!

LIST

LPUSHS

List에서 서브쿼리를 사용해 값을 넣습니다.

사용 예

lpushs mylist (get key) -> syncCommands.lpushs("mylist", "(get key)"); get key의 결과 값을 mylist에 넣습니다.
lpushs mylist2 (lrange mylist 0 -1) -> syncCommands.lpushs("mylist2", "(lrange mylist 0 -1)");
"lrange mylist 0 -1"의 결과 값을 mylist2에 넣습니다.

Test code

/* LPUSHS key (subquery) */
len = syncCommands.lpushs("mylist", "(get key)");
System.out.println("  lpushs mylist '(get key)' -> "+len);
결과: lpushs mylist '(get key)' -> 4

list = syncCommands.lls("mylist","*");
System.out.println("  lls mylist * -> size: "+list.size()+", "+list.toString());
결과: lls mylist * -> size: 4, [Hello Redis!, mykey3, mykey2, mykey1]

len = syncCommands.lpushs("mylist", "(lrange mylist 0 -1)");
System.out.println("  lpushs mylist '(lrange mylist 0 -1)' -> "+len);
결과: lpushs mylist '(lrange mylist 0 -1)' -> 8

list = syncCommands.lls("mylist","*");
System.out.println("  lls mylist * -> size: "+list.size()+", "+list.toString());
결과: lls mylist * -> size: 8, [mykey1, mykey2, mykey3, Hello Redis!, Hello Redis!, mykey3, mykey2, mykey1]

RPUSHS

List에서 서브쿼리를 사용해 값을 넣습니다.

사용 예

rpushs mylist2 (lrange mylist 0 -1) -> syncCommands.rpushs("mylist2", "(lrange mylist 0 -1)");
"lrange mylist 0 -1"의 결과 값들을 mylist2에 넣습니다.

Test code

/* RPUSHS key (subquery) */
len = syncCommands.rpushs("mylist2", "(get key)");
System.out.println("  lpushs mylist2 '(get key)' -> "+len);
결과: lpushs mylist2 '(get key)' -> 1

len = syncCommands.rpushs("mylist2", "(lrange mylist 0 -1)");
System.out.println("  rpushs mylist2 '(lrange mylist 0 -1)' -> "+len);
결과: rpushs mylist2 '(lrange mylist 0 -1)' -> 9

list = syncCommands.lls("mylist2","*");
System.out.println("  lls mylist2 * -> size: "+list.size()+", "+list.toString());
결과: lls mylist2 * -> size: 9, [Hello Redis!, mykey1, mykey2, mykey3, Hello Redis!, Hello Redis!, mykey3, mykey2, mykey1]

LLS (list list)

리스트에서 패턴으로 값을 조회할 수 있고, 소트할 수 있습니다.

사용 예

lls mylist A* -> syncCommands.lls("mylist","A*"); mylist에서 A로 시작하는 값을 조회합니다.
lls mylist A* sort -> syncCommands.lls("mylist","A*","sort"); mylist에서 A로 시작하는 값을 소트해서 조회합니다.

Test code

/* LLS key pattern [sort|asc|desc] */

syncCommands.lpush("mylist", "A1","A2","A3");

// lls mylist * 
List<String> list = syncCommands.lls("mylist","*");
System.out.println("  lls mylist * -> size: "+list.size()+", "+list.toString());
결과: lls mylist * -> size: 6, [A3, A2, A1, mykey3, mykey2, mykey1]

// lls mylist A* 
list = syncCommands.lls("mylist","A*");
System.out.println("  lls mylist A* -> size: "+list.size()+", "+list.toString());
결과: lls mylist A* -> size: 3, [A3, A2, A1]

// lls mylist A* sort 
list = syncCommands.lls("mylist","A*","sort");
System.out.println("  lls mylist A* sort -> size: "+list.size()+", "+list.toString());
결과: lls mylist A* sort -> size: 3, [A1, A2, A3]

LRM (list remove)

리스트에서 패턴으로 값을 삭제합니다.

사용 예

lrm mylist A* -> syncCommands.lrm("mylist","A*"); mylist에서 A로 시작하는 값을 삭제합니다.

Test code

/* LRM key pattern */

Long count = syncCommands.lrm("mylist","A*");
System.out.println("  lrm mylist A* -> "+count);
결과: lrm mylist A* -> 3

LRANGE

소트해서 조회할 수 있습니다.
주의: CLI에서는 LRANGE를 사용하고 Lettuce에서는 LRANGE2()를 사용합니다.

사용 예

lrange mylist 0 -1 sort -> syncCommands.lrange2("mylist",0,-1,"sort");
mylist의 값을 소트해서 조회합니다.

Test code

/* LRANGE key start stop [sort|asc|desc] */
List<String> list = syncCommands.lrange2("mylist",0,-1,"sort");
System.out.println("  lrange2 mylist 0 -1 sort -> size: "+list.size()+", "+list.toString());
결과: lrange2 mylist 0 -1 sort -> size: 8, [Hello Redis!, Hello Redis!, mykey1, mykey1, mykey2, mykey2, mykey3, mykey3]

LREVRANGE

리스트의 값을 오른쪽에서 왼쪽으로 조회합니다.
주의: CLI에서는 LREVRANGE를 사용하고 Lettuce에서는 LREVRANGE2()를 사용합니다.

사용 예

lrevrange mylist -1 0-> syncCommands.lrevrange2("mylist",-1,0);
mylist의 값을 오른쪽에서 왼쪽으로 조회합니다.

Test code

/* LREVRANGE key start stop [sort|asc|desc] */
list = syncCommands.lrevrange2("mylist",-1,0);
System.out.println("  lrevrange2 mylist -1 0 -> size: "+list.size()+", "+list.toString());
결과: lrevrange2 mylist -1 0 -> size: 8, [mykey1, mykey2, mykey3, Hello Redis!, Hello Redis!, mykey3, mykey2, mykey1]

SET

SADD

Member에 만료시간(expire)를 설정할 수 있습니다.

사용 예

sadd myset E1 ex 20 -> syncCommands.sadd("myset", "E1","ex","20");
만료시간(expire)를 지정할 수 있습니다.

Test code

/* SADDS key member  [ex seconds] */
len = syncCommands.sadd("myset", "E1","ex", "5");
System.out.println("  sadd myset E1 ex 5 -> len: "+len);
결과: sadd myset E1 ex 5 -> len: 1

Set<String> set = syncCommands.smembers("myset");
System.out.println("  smembers myset -> size: "+set.size()+", "+set.toString());
결과: smembers myset -> size: 4, [E1, B1, B2, B3]

System.out.println("  Waiting 5 seconds...");
try {
  Thread.sleep(5000); 
} catch (InterruptedException e) {
  e.printStackTrace();
}
set = syncCommands.smembers("myset");
System.out.println("  smembers myset -> size: "+set.size()+", "+set.toString());
결과: smembers myset -> size: 3, [B1, B2, B3]

SADDS

Set에서 서브쿼리를 사용해서 member를 저장할 수 있습니다.

사용 예

sadds myset (lrange mylist 0 -1) -> syncCommands.sadds("myset", "(lrange mylist 0 -1)");
서브쿼리를 사용해서 데이터를 넣을 수 있습니다.
sadd myset (lrange mylist 0 -1) ex 20 -> syncCommands.sadd("myset", "(lrange mylist 0 -1)","ex","20");
만료시간(expire)를 지정할 수 있습니다. 이 경우 서브쿼리 결과 멤버 모두에 만료시간이 적용됩니다.

Test code

/* SADDS key (subquery)   [ex seconds] */
Long len = syncCommands.sadds("myset3", "(smembers myset2)");
System.out.println("  sadds myset3 '(smembers myset2)' -> len: "+len);
결과: sadds myset3 '(smembers myset2)' -> len: 6

len = syncCommands.sadds("myset4", "(lrange mylist 0 -1)");
System.out.println("  sadds myset4 '(lrange mylist 0 -1)' -> len: "+len);
결과: sadds myset4 '(lrange mylist 0 -1)' -> len: 4

SLS (set list)

셋(Set)에서 패턴으로 값을 조회할 수 있고, 소트할 수 있습니다.

사용 예

sls myset A* -> syncCommands.sls("myset","A*"); myset에서 A로 시작하는 값을 조회합니다.
sls myset A* sort -> syncCommands.sls("myset","A*","sort"); myset에서 A로 시작하는 값을 소트해서 조회합니다.

Test code

/* SLS key pattern [sort|asc|desc] */

syncCommands.rm("myset");
syncCommands.sadd("myset", "A1","A2","A3","B1","B2","B3");

// sls myset *
Set<String> set = syncCommands.sls("myset","*");
System.out.println("  sls myset * -> size: "+set.size()+", "+set.toString());
결과:  sls myset * -> size: 6, [A2, A3, A1, B1, B2, B3]

// sls myset A*
set = syncCommands.sls("myset","A*");
System.out.println("  sls myset A* -> size: "+set.size()+", "+set.toString());
결과:  sls myset A* -> size: 3, [A2, A3, A1]

// sls myset A* sort 
set = syncCommands.sls("myset","A*","sort");
System.out.println("  sls myset A* sort -> size: "+set.size()+", "+set.toString());
결과:  sls myset A* sort -> size: 3, [A1, A2, A3]

SRM (set remove)

셋(Set)에서 패턴으로 값을 삭제합니다.

사용 예

srm myset A* -> syncCommands.srm("myset","A*") myset에서 A로 시작하는 값을 삭제합니다.

Test code

/* SRM key pattern */

Long count = syncCommands.srm("myset","A*");
System.out.println("  srm myset A* -> "+count);
결과: srm myset A* -> 3

SLEN

Set에서 키에 속한 멤버 개수를 조회합니다.

사용 예

slen myset -> syncCommands.slen("myset");
myset에 속한 멤버 개수를 조회합니다.

Test code

/* SLEN key */
Long len = syncCommands.slen("myset");
System.out.println("  slen myset -> len: "+len);
결과: slen myset -> len: 3

len = syncCommands.slen("myset2");
System.out.println("  slen myset2 -> len: "+len);
결과: slen myset2 -> len: 6

SMEMBERS

Set에서 키를 여러 개 사용해서 조회할 수 있고, 소트할 수 있습니다.
주의: CLI에서는 SMEMBERS를 사용하고 Lettuce에서는 SMEMBERS2()를 사용합니다.

사용 예

smembers myset1 myset2 -> syncCommands.smembers2("myset","myset2");
키를 여러 개 사용해서 조회할 수 있습니다.
smembers myset1 myset2 sort -> $this->redis->smembers2('myset1', 'myset2', 'sort');
소트해서 조회할 수 있습니다. 이 경우 각 키 안에 있는 멤버를 대상으로 소트합니다.

Test code

/* SMEMBERS key [key ...] [sort|asc|desc] */
syncCommands.sadd("myset2", "C1","C2","C3","D1","D2","D3");
set = syncCommands.smembers2("myset","myset2");
System.out.println("  smembers2 myset myset2 -> size: "+set.size()+", "+set.toString());
결과: smembers2 myset myset2 -> size: 13, [myset, 3, B1, B2, B3, myset2, 6, C2, D1, C1, C3, D2, D3]

set = syncCommands.smembers2("myset","myset2","sort");
System.out.println("  smembers2 myset myset2 sort -> size: "+set.size()+", "+set.toString());
결과: smembers2 myset myset2 sort -> size: 13, [myset, 3, B1, B2, B3, myset2, 6, C1, C2, C3, D1, D2, D3]

SUNION / SINTER / SDIFF

연산(합집합, 교집합, 차집합) 결과를 소트할 수 있습니다.
주의: CLI에서는 SUNION/SINTER/SDIFF를 사용하고 Lettuce에서는 SUNION2()/SINTER2()/SDIFF2()를 사용합니다.

사용 예

sunion myset1 myset2 -> syncCommands.sunion2("myset","myset2");
myset1과 myset2의 합집합을 구해서 소트해서 조회합니다.
sinter myset1 myset2 -> syncCommands.sinter2("myset","myset2");
myset1과 myset2의 교집합을 구해서 소트해서 조회합니다.
sdiff myset1 myset2 -> syncCommands.sdiff2("myset","myset2");
myset1과 myset2의 차집합을 구해서 소트해서 조회합니다.

Test code

/* SUNION/SINTER/SDIFF key [key ...] [sort|asc|desc] */
set = syncCommands.sunion2("myset","myset2");
System.out.println("  sunion2 myset myset2 -> size: "+set.size()+", "+set.toString());
결과: sunion2 myset myset2 -> size: 9, [D2, C3, C1, C2, D1, B1, B2, B3, D3]

set = syncCommands.sunion2("myset","myset2","sort");
System.out.println("  sunion2 myset myset2 sort -> size: "+set.size()+", "+set.toString());
결과: sunion2 myset myset2 sort -> size: 9, [B1, B2, B3, C1, C2, C3, D1, D2, D3]

set = syncCommands.sinter2("myset","myset2");
System.out.println("  sinter2 myset myset2 -> size: "+set.size()+", "+set.toString());
결과: sinter2 myset myset2 -> size: 0, []

set = syncCommands.sinter2("myset","myset2","sort");
System.out.println("  sinter2 myset myset2 sort -> size: "+set.size()+", "+set.toString());
결과: sinter2 myset myset2 sort -> size: 0, []

set = syncCommands.sdiff2("myset","myset2");
System.out.println("  sdiff2 myset myset2 -> size: "+set.size()+", "+set.toString());
결과: sdiff2 myset myset2 -> size: 3, [B1, B2, B3]

set = syncCommands.sdiff2("myset","myset2","sort");
System.out.println("  sdiff2 myset myset2 sort -> size: "+set.size()+", "+set.toString());
결과: sdiff2 myset myset2 sort -> size: 3, [B1, B2, B3]

ZSET

ZADD

ZSet에서 member에 만료시간(expire)를 설정할 수 있습니다.

사용 예

zadd myzset 10 value ex 20 -> syncCommands.zadds("myzset", 10, "value", "ex", "20"); ex 20으로 만료시간(expire)를 지정할 수 있습니다.

Test code

/* ZADD key score member [ex seconds] */

len = syncCommands.zadd("myzset7", 13, "value", "ex", "5");
System.out.println("  zadds myzset7 13 value ex 5 -> "+len);
결과: zadds myzset7 13 value ex 5 -> 1

list2 = syncCommands.zrangeWithScores("myzset7", 0, -1);
System.out.println("  zrange myzset7 0 -1 withscores -> "+list2.toString());
결과: zrange myzset7 0 -1 withscores -> [ScoredValue[13.0, value]]

System.out.println("  Waiting 5 seconds...");
try {
  Thread.sleep(5000); 
} catch (InterruptedException e) {
  e.printStackTrace();
}
list2 = syncCommands.zrangeWithScores("myzset7", 0, -1);
System.out.println("  zrange myzset7 0 -1 withscores -> "+list2.toString());
결과: zrange myzset7 0 -1 withscores -> []

ZADDS

ZSet에서 서브쿼리를 사용해서 score, member를 저장할 수 있고, 만료시간(expire)를 지정할 수 있습니다.

사용 예

zadds myset (lrange mylist 0 -1) -> syncCommands.zadds("myzset", "(lrange mylist 0 -1)");
'lrange mylist 0 -1' 쿼리 결과가 myzset에 저장됩니다. 이 경우 스코어는 0으로 들어갑니다.
zadds myzset (lrange mylist 0 -1) ex 20 -> syncCommands.zadds("myzset", "(lrange mylist 0 -1)", "ex", "20"); ex 20으로 만료시간(expire)를 지정할 수 있습니다. 이 경우 서브쿼리 결과 멤버 모두에 만료시간이 적용됩니다.

Test code

/* ZADDS key (subquery) [ex seconds] */

len = syncCommands.zadds("myzset4", "(get key)");
System.out.println("  zadds myzset4 '(get key)' -> "+len);
결과: zadds myzset4 '(get key)' -> 1

list = syncCommands.zrange("myzset4", 0, -1);
System.out.println("  zrange myzset4 0 -1 -> "+list.toString());
결과: zrange myzset4 0 -1 -> [Hello Redis!]

List<ScoredValue<String>> list2 = syncCommands.zrangeWithScores("myzset4", 0, -1);
System.out.println("  zrange myzset4 0 -1 withscores -> "+list2.toString());
결과: zrange myzset4 0 -1 withscores -> [ScoredValue[0.0, Hello Redis!]]

len = syncCommands.zadds("myzset5", "(smembers myset)");
list2 = syncCommands.zrangeWithScores("myzset5", 0, -1);
System.out.println("  zrange myzset5 0 -1 withscores -> "+list2.toString());
결과: zrange myzset5 0 -1 withscores -> [ScoredValue[0.0, B1], ScoredValue[0.0, B2], ScoredValue[0.0, B3]]

len = syncCommands.zadds("myzset6", "(smembers myset)","ex", "5");
System.out.println("  zadds myzset6 '(smembers myset)' ex 5 -> "+len);
결과: zadds myzset6 '(smembers myset)' ex 5 -> 3

list2 = syncCommands.zrangeWithScores("myzset6", 0, -1);
System.out.println("  zrange myzset6 0 -1 withscores -> "+list2.toString());
결과: zrange myzset6 0 -1 withscores -> [ScoredValue[0.0, B1], ScoredValue[0.0, B2], ScoredValue[0.0, B3]]

System.out.println("  Waiting 5 seconds...");
try {
  Thread.sleep(5000); 
} catch (InterruptedException e) {
  e.printStackTrace();
}
list2 = syncCommands.zrangeWithScores("myzset6", 0, -1);
System.out.println("  zrange myzset6 0 -1 withscores -> "+list2.toString());
결과: zrange myzset6 0 -1 withscores -> []

ZLS (zset list)

ZSet에서 패턴으로 값을 조회할 수 있고, 소트할 수 있습니다.

사용 예

zls myzset A* -> syncCommands.zls("myzset","A*"); myzset에서 A로 시작하는 값을 조회합니다.
zls myzset A* sort -> syncCommands.zls("myzset","A*","sort"); 값을 소트해서 조회합니다.

Test code

/* ZLS key pattern [sort/asc/desc] */

syncCommands.zadd("myzset", 10, "A1");
syncCommands.zadd("myzset", 20, "A2");
syncCommands.zadd("myzset", 30, "A3");
syncCommands.zadd("myzset", 40, "B1");
syncCommands.zadd("myzset", 50, "B2");
syncCommands.zadd("myzset", 60, "B3");

// zls myzset A* 
List<String> listz = syncCommands.zls("myzset","A*");
System.out.println("  zls myzset A* -> size: "+listz.size()+", "+listz.toString());
결과: zls myzset A* -> size: 3, [A1, A2, A3]

// zls myzset B* 
listz = syncCommands.zls("myzset","B*");
System.out.println("  zls myzset B* -> size: "+listz.size()+", "+listz.toString());
결과: zls myzset B* -> size: 3, [B1, B2, B3]

// zls myzset A* desc 
listz = syncCommands.zls("myzset","A*","desc");
System.out.println("  zls myzset A* desc -> size: "+listz.size()+", "+listz.toString());
결과: zls myzset A* desc -> size: 3, [A3, A2, A1]

ZRM (zset remove)

ZSet에서 패턴으로 값을 삭제합니다.

사용 예

zrm myzset A* -> syncCommands.zrm("myzset","A*"); myzset에서 A로 시작하는 값을 삭제합니다.

Test code

/* ZRM key pattern */

// zrm myzset A* 
Long count = syncCommands.zrm("myzset","A*");
System.out.println("  zrm myzset A* -> "+count);
결과: zrm myzset A* -> 3

// zrm myzset B* 
count = syncCommands.zrm("myzset","B*");
System.out.println("  zrm myzset B* -> "+count);
결과: zrm myzset B* -> 3

ZISMEMBER

ZSet에서 키에 멤버가 있는지 확인합니다.

사용 예

zismember myzset 'A1' -> syncCommands.zismember("myzset","A1");
키 myzset에 'A1'이 있는지 확인합니다.

Test code

/* ZISMEMBER key member */
Boolean b = syncCommands.zismember("myzset4", "Hello Redis!");
System.out.println("  zismember myzset4 'Hello Redis!' -> "+b);
결과: zismember myzset4 'Hello Redis!' -> true

b = syncCommands.zismember("myzset7", "value");
System.out.println("  zismember myzset7 value -> "+b);
결과: zismember myzset7 value -> false

HASH

HSETS

Hash에서 서브쿼리를 사용해서 fiend, value를 저장할 수 있고, 만료시간(expire)를 지정할 수 있습니다.

사용 예

hsets myhash3 (get user1) -> syncCommands.hsets("myhash3", "(get user1)");
'get user1' 쿼리 결과가 myhash3에 user1은 field로, 값은 value로 저장됩니다.
hsets myhash3 (hgetall myhash) ex 20 -> syncCommands.hsets("myhash3", "(hgetall myhash)", "ex", "20"); ex 20으로 만료시간(expire)를 지정할 수 있습니다. 이 경우 서브쿼리 결과 멤버 모두에 만료시간이 적용됩니다.

Test code

/* HSETS key (subquery) [ex seconds] */

count = syncCommands.hsets("myhash3", "(get user1)");
System.out.println("  hsets myhash3 (get user1) -> 1 => "+count);
Map<String, String> m = syncCommands.hgetall("myhash3");
System.out.println("  hgetall myhash3 -> 1 => size: "+m.size()+", "+m.toString());
결과: hgetall myhash3 -> 1 => size: 1, {user1=Redis1}

count = syncCommands.hsets("myhash3", "(hgetall myhash)");
System.out.println("  hsets myhash3 (hgetall myhash) -> 6 => "+count);
m = syncCommands.hgetall("myhash3");
System.out.println("  hgetall myhash3 -> 7 => size: "+m.size()+", "+m.toString());
결과: hgetall myhash3 -> 7 => size: 7, {B1=BV1, B2=BV2, user1=Redis1, A3=AV3, B3=BV3, A2=AV2, A1=AV1}

HLS (hash list)

해시(Hash)에서 필드에 패턴으로 값을 조회할 수 있고, 소트할 수 있습니다.

사용 예

hls myhash A* -> syncCommands.hls("myhash","A*"); myhash에서 A로 시작하는 필드를 조회합니다.
hls myhash A* sort -> syncCommands.hls("myhash","A*","sort"); 값을 소트해서 조회합니다.

Test code

/* HLS key field-pattern [sort|asc|desc] */

syncCommands.hset("myhash", "A1","AV1");
syncCommands.hset("myhash", "A2","AV2");
syncCommands.hset("myhash", "A3","AV3");
syncCommands.hset("myhash", "B1","BV1");
syncCommands.hset("myhash", "B2","BV2");
syncCommands.hset("myhash", "B3","BV3");

// hls myhash A* 
List<KeyValue<String, String>> listkv = syncCommands.hls("myhash","A*");
System.out.println("  hls myhash A* -> size: "+listkv.size()+", "+listkv.toString());
결과: hls myhash A* -> size: 3, [KeyValue[A1, AV1], KeyValue[A2, AV2], KeyValue[A3, AV3]]

// hls myhash B* 
listkv = syncCommands.hls("myhash","B*");
System.out.println("  hls myhash B* -> size: "+listkv.size()+", "+listkv.toString());
결과: hls myhash B* -> size: 3, [KeyValue[B1, BV1], KeyValue[B2, BV2], KeyValue[B3, BV3]]

// hls myhash A* desc 
listkv = syncCommands.hls("myhash","A*","desc");
System.out.println("  hls myhash A* desc -> size: "+listkv.size()+", "+listkv.toString());
결과: hls myhash A* desc -> size: 3, [KeyValue[A3, AV3], KeyValue[A2, AV2], KeyValue[A1, AV1]]

HRM (zset remove)

해시(Hash)에서 필드에 패턴으로 값을 삭제합니다.

사용 예

hrm myhash A* -> syncCommands.hrm("myhash","A*"); myhash에서 A로 시작하는 필드를 삭제합니다.

Test code

/* HRM key field-pattern */
/* hrm myhash A* */
Long count = syncCommands.hrm("myhash","A*");
System.out.println("  hrm myhash A* -> "+count);
결과: hrm myhash A* -> 3

/* hrm myhash B* */
count = syncCommands.hrm("myhash","B*");
System.out.println("  hrm myhash B* -> "+count);
결과: hrm myhash B* -> 3

ZLEN

ZSet에서 키에 속한 멤버 개수를 조회합니다.

사용 예

zlen myzset -> syncCommands.zlen("myzset");
myzset에 속한 멤버 개수를 조회합니다.

Test code

/* ZLEN key */
syncCommands.zadd("myzset", 10, "A1");
syncCommands.zadd("myzset", 20, "A2");
syncCommands.zadd("myzset", 30, "A3");
syncCommands.zadd("myzset", 40, "B1");
syncCommands.zadd("myzset", 50, "B2");
syncCommands.zadd("myzset", 60, "B3");

Long len = syncCommands.zlen("myzset");
System.out.println("  zlen myzset -> len: "+len);
결과: zlen myzset -> len: 6

HKEYS / HVALS / HGETALL

멀티 키 사용: 해시(Hash)에서 키를 여러 개 입력해서 조회합니다.

사용 예

hkeys myhash1 myhash2 -> syncCommands.hkeys("myhash1","myhash2");
키 myhash1과 myhash2의 필드를 조회합니다.
hvals myhash1 myhash2 -> syncCommands.hvals("myhash1","myhash2");
키 myhash1과 myhash2의 값을 조회합니다.
hgetall myhash1 myhash2 -> syncCommands.hgetall("myhash1","myhash2");
키 myhash1과 myhash2의 필드와 값을 조회합니다.

Test code

/* hkeys, hvals, hgetall -> multi keys test */
/* HKEYS key [key ...], HVALS key [key ...], HGETALL key [key ...] */

syncCommands.hset("myhash1", "A1","AV1");
syncCommands.hset("myhash1", "A2","AV2");
syncCommands.hset("myhash1", "A3","AV3");
syncCommands.hset("myhash2", "B1","BV1");
syncCommands.hset("myhash2", "B2","BV2");
syncCommands.hset("myhash2", "B3","BV3");

/* hkeys myhash1 myhash2 */
list = syncCommands.hkeys("myhash1");
System.out.println("  hkeys  myhash1 -> size: "+list.size()+", "+list.toString());
결과: hkeys  myhash1 -> size: 3, [A1, A2, A3]

list = syncCommands.hkeys("myhash1","myhash2");
System.out.println("  hkeys  myhash1 myhash2 -> size: "+list.size()+", "+list.toString());
결과: hkeys  myhash1 myhash2 -> size: 10, [myhash1, 3, A1, A2, A3, myhash2, 3, B1, B2, B3]

/* hvals myhash1 myhash2 */
list = syncCommands.hvals("myhash1");
System.out.println("  hvals myhash1 -> size: "+list.size()+", "+list.toString());
결과: hvals myhash1 -> size: 3, [AV1, AV2, AV3]

list = syncCommands.hvals("myhash1","myhash2");
System.out.println("  hvals myhash1 myhash2 -> size: "+list.size()+", "+list.toString());
결과: hvals myhash1 myhash2 -> size: 10, [myhash1, 3, AV1, AV2, AV3, myhash2, 3, BV1, BV2, BV3]

/* hgetall myhash1 myhash2 */
Map<String, String> m = syncCommands.hgetall("myhash1");
System.out.println("  hgetall myhash1 -> size: "+m.size()+", "+m.toString());
결과: hgetall myhash1 -> size: 3, {A1=AV1, A2=AV2, A3=AV3}

m = syncCommands.hgetall("myhash1","myhash2");
System.out.println("  hgetall myhash1 myhash2 -> size: "+m.size()+", "+m.toString());
결과: hgetall myhash1 myhash2 -> size: 8, {myhash1=6, A1=AV1, A2=AV2, A3=AV3, myhash2=6, B1=BV1, B2=BV2, B3=BV3}

<< Cluster	Enterprise