Clients

PhpRedis for Redis Enterprise

레디스 개발자 교육 신청	레디스 정기점검/기술지원 Redis Technical Support	레디스 엔터프라이즈 서버 Redis Enterprise Server

Redis Clients PHPREDIS

PhpRedis 5.3.3에서 지원하는 Redis Enterprise 명령

공통 COMMON

CD (change database)

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

사용 예

cd 1 -> $this->redis->cd(1); 1번 db로 옮깁니다.

Test code

/* CD [index] */
public function testCd() {
    $this->assertFalse($this->redis->cd(-1));
    $this->assertTrue($this->redis->cd(0));
}

LS (list)

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

사용 예

ls -> $this->redis->ls(); 모든 키를 조회합니다.
ls user* -> $this->redis->ls('user*'); user로 시작하는 키를 조회합니다.
ls * string -> $this->redis->ls('*', 'string'); string 키를 모두 조회합니다.
ls * type -> $this->redis->ls('*', 'type'); 모든 키와 data type을 조회합니다.
ls * memory -> $this->redis->ls('*', 'memory'); 모든 키와 키가 사용하고 있는 메모리를 조회합니다.
ls * sort -> $this->redis->ls('*', 'sort'); 모든 키를 소트해서 조회합니다.
ls * count 10 -> $this->redis->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>] */
public function testLs()
{   
    $this->redis->rm('(ls)'); // delete all keys
    $cnt = 3; 
    $pattern1 = 'key_';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->set($pattern1.$i, 'value_'.$i);
    }
    $pattern2 = 'mylist_';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->lpush($pattern2.$i, 'value_'.$i);
    }
    $keys = $this->redis->ls(); // ls
    $this->assertEquals((count($keys)), $cnt*2);
    $keys = $this->redis->ls('*'); // ls *
    $this->assertEquals((count($keys)), $cnt*2);
    $keys = $this->redis->ls($pattern1.'*'); // ls key_* 
    $this->assertEquals((count($keys)), $cnt);
    $keys = $this->redis->ls($pattern2.'*'); // ls mylist_* 
    $this->assertEquals((count($keys)), $cnt);
    $keys = $this->redis->ls('A*'); // ls A* 
    $this->assertEquals((count($keys)), 0);
    $keys = $this->redis->ls($pattern1.'*','sort'); // ls key_* sort
    $this->assertEquals((count($keys)), $cnt);
    $this->assertTrue($keys === ['key_1','key_2','key_3']);
    
    $keys = $this->redis->ls('*','string'); // ls * string
    $this->assertEquals((count($keys)), $cnt);
    
    $keys = $this->redis->ls('*','list','desc'); // ls * list desc 
    $this->assertEquals((count($keys)), $cnt);
    $this->assertTrue($keys === ['mylist_3','mylist_2','mylist_1']);
}

RM (remove)

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

사용 예

rm (get key) -> $this->redis->rm('(get key)'); get key의 결과로 키를 삭제합니다.
rm (ls user*) -> $this->redis->rm('(ls user*)'); user로 시작하는 키를 삭제합니다.
rm (ls * string) -> $this->redis->rm('(ls * string)'); string 키 모두를 삭제합니다.

Test code

/* RM key [key ...]|(subquery) */
public function testrm() {
  $this->redis->set('key','valueX');
  $this->assertTrue($this->redis->rm('key') === 1); // ok
  $this->redis->set('key1','valueX1');
  $this->redis->set('key2','valueX2');
  $this->redis->set('key3','valueX3');
  $this->assertTrue($this->redis->rm('key1','key2','key3') === 3); // ok
  $this->redis->set('mykey','myvalue');
  $this->redis->set('key','mykey');
  $this->assertTrue($this->redis->rm('(get key)') === 1); // ok
  $this->redis->set('key1','valueX1');
  $this->redis->set('key2','valueX2');
  $this->redis->set('key3','valueX3');
  $this->assertTrue($this->redis->rm('(ls)') === 4); // ok
}

SQL

SELECT

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

사용 예

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

String Test code

Test code 1 /* String */ $key = 'mykey'; $cnt = 5; $this->redis->rm('(ls * string)'); // delete string keys for($i = 1; $i <= $cnt; $i++) { $this->redis->set($key.$i, 'value-'.$i); } $arr = $this->redis->sqlselect('select * from string.*;'); $this->assertEquals(count($arr), $cnt+1); for($i = 0; $i < $cnt; $i++) { $this->assertEquals(count($arr[$i]), 2); } $this->assertTrue($arr[0] === ['key','value']); $this->assertTrue($arr[1] === ['mykey1','value-1']);
Test code 2 $rc .= "<h3>SELECT String</h3>"; $key = 'mykey'; $cnt = 5; $this->redistest->rm('(ls * string)'); // delete string keys for($i = 1; $i <= $cnt; $i++) { $this->redistest->set($key.$i, 'value-'.$i); } $r = $this->redistest->sqlselect('select * from string.mykey*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { /* 마지막 컬럼은 '|'를 표시하지 않는다. */ $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
Test code 2 -> 결과 SELECT String 0 -> key|value 1 -> mykey1|value-1 2 -> mykey2|value-2 3 -> mykey3|value-3 4 -> mykey4|value-4 5 -> mykey5|value-5

List Test code

Test code 1 /* List */ $key = 'mylist'; $cnt = 5; $this->redis->rm('(ls * list)'); // delete list keys for($i = 1; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redis->rpush($key.$i, 'value-'.$j); } } $arr = $this->redis->sqlselect('select * from list.*;'); $this->assertEquals(count($arr), $cnt*$cnt+1);
Test code 2 /* List */ $rc .= "<h3>SELECT List</h3>"; $key = 'mylist'; $cnt = 3; $this->redistest->rm('(ls * list)'); // delete list keys for($i = 1; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redistest->rpush($key.$i, 'value-'.$j); } } $r = $this->redistest->sqlselect('select * from list.mylist*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { /* 마지막 컬럼은 '|'를 표시하지 않는다. */ $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
Test code 2 -> 결과 SELECT List 0 -> key|value 1 -> mylist1|value-1 2 -> mylist1|value-2 3 -> mylist1|value-3 4 -> mylist2|value-1 5 -> mylist2|value-2 6 -> mylist2|value-3 7 -> mylist3|value-1 8 -> mylist3|value-2 9 -> mylist3|value-3

Set Test code

Test code 1 /* Set */ $key = 'myset'; $cnt = 5; $this->redis->rm('(ls * set)'); // delete set keys for($i = 1; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redis->sadd($key.$i, 'value-'.$j); } } $arr = $this->redis->sqlselect('select * from set.*;'); $this->assertEquals(count($arr), $cnt*$cnt+1);
Test code 2 /* Set */ $rc .= "<h3>SELECT Set</h3>"; $key = 'myset'; $cnt = 3; $this->redistest->rm('(ls * set)'); // delete set keys for($i = 1; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redistest->sadd($key.$i, 'value-'.$j); } } $r = $this->redistest->sqlselect('select * from set.myset*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { /* 마지막 컬럼은 '|'를 표시하지 않는다. */ $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
Test code 2 -> 결과 SELECT Set 0 -> key|value 1 -> myset1|value-2 2 -> myset1|value-3 3 -> myset1|value-1 4 -> myset2|value-2 5 -> myset2|value-3 6 -> myset2|value-1 7 -> myset3|value-2 8 -> myset3|value-3 9 -> myset3|value-1

ZSet Test code

Test code 1 /* ZSet */ $key = 'myzset'; $cnt = 5; $this->redis->rm('(ls * zset)'); // delete zset keys for($i = 1; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redis->zadd($key.$i, $j, 'value-'.$j); } } $arr = $this->redis->sqlselect('select * from zset.*;'); $this->assertEquals(count($arr), $cnt*$cnt+1);
Test code 2 /* ZSet */ $rc .= "<h3>SELECT ZSet</h3>"; $key = 'myzset'; $cnt = 3; $this->redistest->rm('(ls * zset)'); // delete zset keys for($i = 1; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redistest->zadd($key.$i, $j, 'value-'.$j); } } $r = $this->redistest->sqlselect('select * from zset.myzset*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { /* 마지막 컬럼은 '|'를 표시하지 않는다. */ $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
Test code 2 -> 결과 SELECT ZSet 0 -> key|score|value 1 -> myzset1|1.0|value-1 2 -> myzset1|2.0|value-2 3 -> myzset1|3.0|value-3 4 -> myzset2|1.0|value-1 5 -> myzset2|2.0|value-2 6 -> myzset2|3.0|value-3 7 -> myzset3|1.0|value-1 8 -> myzset3|2.0|value-2 9 -> myzset3|3.0|value-3

Hash Test code

Test code 1 /* Hash */ $key = 'myhash'; $cnt = 5; $this->redis->rm('(ls * hash)'); // delete hash keys for($i = 1; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redis->hset($key.$i, 'field-'.$j, 'value-'.$j); } } $arr = $this->redis->sqlselect('select * from hash.*;'); $this->assertEquals(count($arr), $cnt+1);
Test code 2 /* Hash */ $rc .= "<h3>SELECT Hash</h3>"; $key = 'myhash'; $cnt = 3; $this->redistest->rm('(ls * hash)'); // delete hash keys for($i = 1; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redistest->hset($key.$i, 'field-'.$j, 'value-'.$j); } } $cnt = 5; for($i = 4; $i <= $cnt; $i++) { for($j = 1; $j <= $cnt; $j++) { $this->redistest->hset($key.$i, 'field-'.$j, 'value-'.$j); } } $r = $this->redistest->sqlselect('select * from hash.myhash*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { /* 마지막 컬럼은 '|'를 표시하지 않는다. */ $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
Test code 2 -> 결과 SELECT Hash 0 -> key|field-1|field-2|field-3|field-4|field-5 1 -> myhash1|value-1|value-2|value-3|(nil)|(nil) 2 -> myhash2|value-1|value-2|value-3|(nil)|(nil) 3 -> myhash3|value-1|value-2|value-3|(nil)|(nil) 4 -> myhash4|value-1|value-2|value-3|value-4|value-5 5 -> myhash5|value-1|value-2|value-3|value-4|value-5

Stream Test code

Test code 1 /* Stream */ $key = 'sensor_1'; $cnt = 5; $this->redis->rm('(ls * stream)'); // delete stream keys $this->redis->xadd($key, '*', ['foo'=>10,'humid'=>20,'pres'=>30,'vib'=>40]); $this->redis->xadd($key, '*', ['foo'=>11,'humid'=>25,'pres'=>28,'vib'=>50]); $this->redis->xadd($key, '*', ['foo'=>12,'humid'=>30,'pres'=>26,'vib'=>60]); $this->redis->xadd($key, '*', ['foo'=>13,'humid'=>35,'pres'=>24,'vib'=>20]); $this->redis->xadd($key, '*', ['foo'=>14,'humid'=>40,'pres'=>22,'vib'=>30]); $arr = $this->redis->sqlselect('select * from stream.*;'); $this->assertEquals(count($arr), $cnt+1);
Test code 2 /* Stream */ $rc .= "<h3>SELECT Stream </h3>"; $key = 'sensor_1'; $cnt = 5; $this->redistest->rm('(ls * stream)'); // delete stream keys $this->redistest->xadd($key, '*', ['temp'=>10,'humid'=>20,'pres'=>30,'vib'=>40]); $this->redistest->xadd($key, '*', ['temp'=>11,'humid'=>25,'pres'=>28,'vib'=>50]); $this->redistest->xadd($key, '*', ['temp'=>12,'humid'=>30,'pres'=>26,'vib'=>60]); $this->redistest->xadd($key, '*', ['temp'=>13,'humid'=>30,'pres'=>24,'vib'=>20]); $this->redistest->xadd($key, '*', ['temp'=>14,'humid'=>40,'pres'=>22,'vib'=>30]); $r = $this->redistest->sqlselect('select * from stream.*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { // 마지막 컬럼은 '|'를 표시하지 않는다. $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
Test code 2 -> 결과 SELECT Stream 0 -> key|id|temp|humid|pres|vib 1 -> sensor_1|1616198721752-0|10|20|30|40 2 -> sensor_1|1616198721752-1|11|25|28|50 3 -> sensor_1|1616198721752-2|12|30|26|60 4 -> sensor_1|1616198721752-3|13|30|24|20 5 -> sensor_1|1616198721752-4|14|40|22|30

Function valcnt() Test code
키에 속한 값/요소(element)/멤버(member) 개수를 조회한다.
String은 항상 1이 조회된다. 다른 데이터 타입은 값의 개수가 조회된다.
$this->redis->sqlselect('select key, valcnt(key) from hash.*;');

Test code $rc .= "<h3>SELECT valcnt() Hash </h3>"; $r = $this->redistest->sqlselect('select key, valcnt(key) from hash.*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { // 마지막 컬럼은 '|'를 표시하지 않는다. $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
결과 SELECT valcnt() Hash 0 -> key|valcnt(key) 1 -> myhash1|3 2 -> myhash2|3 3 -> myhash3|3 4 -> myhash4|5 5 -> myhash5|5

Function memory() Test code
키와 값이 차지하고 있는 메모리량을 조회한다.
$this->redis->sqlselect('select key, memory(key) from hash.*;');

Test code /* Memory */ $rc .= "<h3>SELECT memory() Hash </h3>"; $r = $this->redistest->sqlselect('select key, memory(key) from hash.*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { // 마지막 컬럼은 '|'를 표시하지 않는다. $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
결과 SELECT memory() Hash 0 -> key|memory(key) 1 -> myhash1|130 2 -> myhash2|130 3 -> myhash3|130 4 -> myhash4|166 5 -> myhash5|166

Function type(), encoding() Test code
키의 데이터 타입, 인코딩 타입을 조회한다.
$this->redis->sqlselect('select key, type(key),encoding(key) from hash.*;');

Test code /* Type, Encoding */ $rc .= "<h3>SELECT type(), encoding() Hash </h3>"; $r = $this->redistest->sqlselect('select key, type(key),encoding(key) from hash.*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { // 마지막 컬럼은 '|'를 표시하지 않는다. $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
결과 SELECT type(), encoding() Hash 0 -> key|type(key)|encoding(key) 1 -> myhash1|hash|ziplist 2 -> myhash2|hash|ziplist 3 -> myhash3|hash|ziplist 4 -> myhash4|hash|ziplist 5 -> myhash5|hash|ziplist

Function updatetime() Test code
키의 마지막 갱신시각(updatetime)을 조회한다.
$this->redis->sqlselect('select key, updatetime(key) from hash.*;');

Test code /* Updatetime */ $rc .= "<h3>SELECT updatetime() Hash </h3>"; $r = $this->redistest->sqlselect('select key, updatetime(key) from hash.*;'); while ( key($r) !== NULL ) { $rc .= " ".key($r)." -> "; $row = current($r); $columns = count($row); for($i = 1; $i <= $columns; $i++) { if ($i < $columns) { $rc .= current($row)."|"; } else { // 마지막 컬럼은 '|'를 표시하지 않는다. $rc .= current($row); } next($row); } $rc .= "<br>"; next($r); }
결과 SELECT updatetime() Hash 0 -> key|updatetime(key) 1 -> myhash1|2021-03-20 09:05:21.751 2 -> myhash2|2021-03-20 09:05:21.751 3 -> myhash3|2021-03-20 09:05:21.751 4 -> myhash4|2021-03-20 09:05:21.751 5 -> myhash5|2021-03-20 09:05:21.752

STRING

SET

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

사용 예

set mykey (get key1) -> $this->redis->set('mykey', '(get key1)'); get key1의 결과 값을 mykey에 넣습니다.

Test code

/* SET key value [NX|XX] [EX 초] [PX 밀리초] [KEEPTTL] | (subquery) */
public function testSetSubquery()
{    
    $this->redis->rm('(ls * string)'); // delete string keys
    $this->redis->set('key2','value2'); 
    $this->redis->set('key1','(get key2)'); 
}

APPEND

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

사용 예

append mykey (get key1) -> $this->redis->append('mykey', '(get key1)'); get key1의 결과 값을 mykey에 추가합니다.

Test code

/* APPEND key value | (subquery) */
public function testAppend()
{    
    $this->redis->rm('(ls * string)'); // delete string keys
    $this->redis->set('key1','value1'); 
    $this->redis->set('key2','value2'); 
    $this->redis->append('key1','(get key2)'); 
}

LIST

LPUSH

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

사용 예

lpush mylist (get key1) -> $this->redis->lpush('mylist', '(get key1)'); get key1의 결과 값을 mylist에 넣습니다.
lpush mylist (lrange mylist2 0 -1) -> $this->redis->lpush('mylist', '(lrange mylist2 0 -1)');
"lrange mylist2 0 -1"의 결과 값을 mylist에 넣습니다.

Test code

/* LPUSH key value [value ...]|(subquery) */
public function testLpushSubquery()
{    
    $mylist = 'mylist';
    $this->redis->rm('(ls * string)');  // delete string keys
    $this->redis->rm('(ls * list)');    // delete list keys
    $this->redis->set('key1','value1'); 
    $this->redis->lpush($mylist,'(get key1)'); 
    $arr = $this->redis->lls($mylist,'*'); 
    $this->assertTrue($arr === ['value1']);
    $cnt = 3; 
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->lpush($mylist, 'A'.$i);
    }    
    $mylist2 = 'mylist2';
    $r = $this->redis->lpush($mylist2,'(lrange mylist 0 -1)'); 
    $this->assertEquals($r, 4);
    $arr = $this->redis->lrange($mylist2,0,-1);
    $this->assertTrue($arr === ['value1','A1','A2','A3']);

    $mylist3 = 'mylist3';
    $r = $this->redis->lpush($mylist3,'(lrange mylist2 0 -1)','(get key1)'); 
    $this->assertEquals($r, 5);
    $arr = $this->redis->lrange($mylist3,0,-1);
    $this->assertTrue($arr === ['value1','A3','A2','A1','value1']);
}

RPUSH

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

사용 예

rpush mylist (lrange mylist2 0 -1) -> $this->redis->rpush('mylist', '(lrange mylist2 0 -1)');
"lrange mylist2 0 -1"의 결과 값들을 mylist에 넣습니다.

Test code

/* RPUSH key value [value ...]|(subquery) */
public function testRpushSubquery()
{
    $mylist = 'mylist';
    $this->redis->rm('(ls * string)');  // delete string keys
    $this->redis->rm('(ls * list)');    // delete list keys
    $this->redis->set('key1','value1');
    $this->redis->rpush($mylist,'(get key1)');
    $arr = $this->redis->lls($mylist,'*');
    $this->assertTrue($arr === ['value1']);
    $cnt = 3;
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->rpush($mylist, 'A'.$i);
    }
    $mylist2 = 'mylist2';
    $r = $this->redis->rpush($mylist2,'(lrange mylist 0 -1)');
    $this->assertEquals($r, 4);
    $arr = $this->redis->lrange($mylist2,0,-1);
    $this->assertTrue($arr === ['value1','A1','A2','A3']);

    $mylist3 = 'mylist3';
    $r = $this->redis->rpush($mylist3,'(lrange mylist2 0 -1)','(get key1)');
    $this->assertEquals($r, 5);
    $arr = $this->redis->lrange($mylist3,0,-1);
    $this->assertTrue($arr === ['value1','A1','A2','A3','value1']);
}

LLS (list list)

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

사용 예

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

Test code

/* LLS key pattern [sort|asc|desc] */
public function testLls()
{
    $this->redis->rm('(ls * list)'); // delete list keys
    $cnt = 3;
    $key= 'mylist';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->lpush($key, 'A'.$i);
    }
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->lpush($key, 'B'.$i);
    }
    $keys = $this->redis->lls($key,'*'); // lls mylist *
    $this->assertEquals((count($keys)), $cnt*2);
    $keys = $this->redis->lls($key,'A*'); // lls mylist A*
    $this->assertEquals((count($keys)), $cnt);
    $keys = $this->redis->lls($key,'A*','sort'); // lls mylist A* sort
    $this->assertEquals((count($keys)), $cnt);
    $this->assertTrue($keys === ['A1','A2','A3']);
}

LRM (list remove)

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

사용 예

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

Test code

/* LRM key pattern */
public function testLrm()
{
    $this->redis->rm('(ls * list)'); // delete list keys
    $cnt = 3;
    $key= 'mylist';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->lpush($key, 'A'.$i);
    }
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->lpush($key, 'B'.$i);
    }
    $r = $this->redis->lrm($key,'A*'); // lrm mylist A*
    $this->assertEquals($r, $cnt);
    $r = $this->redis->lrm($key,'*'); // lrm mylist *
    $this->assertEquals($r, $cnt);
    $r = $this->redis->lrm($key,'*'); // lrm mylist *
    $this->assertTrue($r == NULL);
}

LRANGE

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

사용 예

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

Test code

/* LRANGE key start stop [sort|asc|desc] */
public function testLrange2()
{
    $mylist = 'mylist';
    $this->redis->rm('(ls * list)');    // delete list keys
    $this->redis->lpush($mylist,'A2');
    $this->redis->lpush($mylist,'A1');
    $this->redis->lpush($mylist,'A3');
    $arr = $this->redis->lrange2($mylist,0,-1,'sort');
    $this->assertEquals(count($arr), 3);
    $this->assertTrue($arr === ['A1','A2','A3']);
}

LREVRANGE

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

사용 예

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

Test code

/* LREVRANGE key start stop [sort|asc|desc] */
public function testLrevrange2()
{    
    $mylist = 'mylist';
    $this->redis->rm('(ls * list)');    // delete list keys
    $this->redis->lpush($mylist,'A2'); 
    $this->redis->lpush($mylist,'A1'); 
    $this->redis->lpush($mylist,'A3'); 
    $arr = $this->redis->lrevrange2($mylist,-1,0);
    $this->assertEquals(count($arr), 3);
    $this->assertTrue($arr === ['A2','A1','A3']);
    $arr = $this->redis->lrevrange2($mylist,-1,0,'desc');
    $this->assertEquals(count($arr), 3);
    $this->assertTrue($arr === ['A3','A2','A1']);
}

SET

SADD

서브쿼리를 사용할 수 있고, 만료시간(expire)를 지정할 수 있습니다.

사용 예

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

Test code

/* SADD key member [member ...] | (subquery)   [ex seconds] */
public function testsadd2()
{
    $key1 = 'key1';
    $key2 = 'myset1';
    $key3 = 'mylist1';
    $this->redis->rm('(ls * set)');     // delete hash keys
    $this->redis->set($key1,'A1');
    $this->redis->lpush($key3,'B1','B2','B3');
    /* subquery */
    $this->redis->sadd($key2,'(get key1)');
    $r = $this->redis->slen($key2);
    $this->assertEquals($r, 1);
    $this->redis->sadd($key2,'(lrange mylist1 0 -1)','ex','20');
    $r = $this->redis->slen($key2);
    $this->assertEquals($r, 4);
    /* ex 20 */
    $this->redis->sadd($key2,'E1','ex','20');
}

SLS (set list)

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

사용 예

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

Test code

/* SLS key pattern [sort|asc|desc] */
public function testSls()
{
    $this->redis->rm('(ls * set)'); // delete set keys
    $cnt = 3;
    $key= 'myset';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->sadd($key, 'A'.$i);
    }
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->sadd($key, 'B'.$i);
    }
    $keys = $this->redis->sls($key,'*'); // sls myset *
    $this->assertEquals((count($keys)), $cnt*2);
    $keys = $this->redis->sls($key,'A*'); // sls myset A*
    $this->assertEquals((count($keys)), $cnt);
    $keys = $this->redis->sls($key,'A*','sort'); // sls myset A* sort
    $this->assertEquals((count($keys)), $cnt);
    $this->assertTrue($keys === ['A1','A2','A3']);
}

SRM (set remove)

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

사용 예

srm myset A* -> $this->redis->srm('myset', 'A*'); myset에서 A로 시작하는 값을 삭제합니다.

Test code

/* SRM key pattern */
public function testSrm()
{
    $this->redis->rm('(ls * set)'); // delete set keys
    $cnt = 3;
    $key= 'myset';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->sadd($key, 'A'.$i);
    }
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->sadd($key, 'B'.$i);
    }
    $r = $this->redis->srm($key,'A*'); // srm myset A*
    $this->assertEquals($r, $cnt);
    $r = $this->redis->srm($key,'*'); // srm myset *
    $this->assertEquals($r, $cnt);
    $r = $this->redis->srm($key,'*'); // srm myset *
    $this->assertTrue($r == NULL);
}

SLEN

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

사용 예

slen myset -> $this->redis->slen('myset');
myset에 속한 멤버 개수를 조회합니다.

Test code

/* SLEN key */
public function testSlen()
{
    $key1 = 'myset1';
    $this->redis->rm('(ls * set)');     // delete set keys
    $this->redis->sadd($key1,'A2','A1','A3');
    $r = $this->redis->slen($key1);
    $this->assertEquals($r, 3);
}

SMEMBERS

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

사용 예

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

Test code

/* SMEMBERS key [key ...] [sort|asc|desc] */
public function testSmembers2()
{    
    $key1 = 'myset1';
    $key2 = 'myset2';
    $this->redis->rm('(ls * set)');     // delete set keys
    $this->redis->sadd($key1,'A2','A1','A3'); 
    $this->redis->sadd($key2,'B2','B1','B3'); 
    $arr = $this->redis->smembers2($key1);
    $this->assertEquals(count($arr), 3);
    $arr = $this->redis->smembers2($key1,$key2);
    $this->assertEquals(count($arr), 10); 

    $arr = $this->redis->smembers2($key1,'sort');
    $this->assertEquals(count($arr), 3);
    $this->assertTrue($arr === ['A1','A2','A3']);
    $arr = $this->redis->smembers2($key1,$key2,'sort');
    $this->assertEquals(count($arr), 10); 
    $this->assertTrue($arr === ['myset1','3','A1','A2','A3','myset2','3','B1','B2','B3']);
}

SUNION / SINTER / SDIFF

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

사용 예

sunion myset1 myset2 -> $this->redis->sunion2('myset1', 'myset2', 'sort');
myset1과 myset2의 합집합을 구해서 소트해서 조회합니다.
sinter myset1 myset2 -> $this->redis->sinter2('myset1', 'myset2', 'sort');
myset1과 myset2의 교집합을 구해서 소트해서 조회합니다.
sdiff myset1 myset2 -> $this->redis->sdiff2('myset1', 'myset2', 'sort');
myset1과 myset2의 차집합을 구해서 소트해서 조회합니다.

Test code

/* SUNION key [key ...] [sort|asc|desc] */
public function testSunion2()
{
  $key1 = 'myset1';
  $key2 = 'myset2';
  $this->redis->rm('(ls * set)');     // delete set keys
  $this->redis->sadd($key1,'A2','A1','A3');
  $this->redis->sadd($key2,'A3','A4','A5');
  /* sunion2 */
  $arr = $this->redis->sunion2($key1);
  $this->assertEquals(count($arr), 3);
  $arr = $this->redis->sunion2($key1,'sort');
  $this->assertEquals(count($arr), 3);
  $this->assertTrue($arr === ['A1','A2','A3']);
  $arr = $this->redis->sunion2($key1,$key2,'sort');
  $this->assertEquals(count($arr), 5);
  $this->assertTrue($arr === ['A1','A2','A3','A4','A5']);
  /* sinter */
  $arr = $this->redis->sinter2($key1,$key2,'sort');
  $this->assertEquals(count($arr), 1);
  $this->assertTrue($arr === ['A3']);
  /* sdiff */
  $arr = $this->redis->sdiff2($key1,$key2,'sort');
  $this->assertEquals(count($arr), 2);
  $this->assertTrue($arr === ['A1','A2']);
}

ZSET

ZADD

서브쿼리를 사용할 수 있고, 만료시간(expire)를 지정할 수 있습니다.

사용 예

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

Test code

/* ZADD key [NX|XX] [CH] [INCR] score member [score member ...] | (subquery) [ex seconds] */
public function testzadd2()
{
    $key1 = 'key1';
    $key2 = 'myzset1';
    $key3 = 'mylist1';
    $key4 = 'myzset2';
    $this->redis->rm('(ls * string)');    
    $this->redis->rm('(ls * list)');    
    $this->redis->rm('(ls * zset)');    
    $this->redis->set($key1,'A1');
    $this->redis->lpush($key3,'B1','B2','B3');
    /* subquery */
    $this->redis->zadd2($key2,'(get key1)');
    $r = $this->redis->zlen($key2);
    $this->assertEquals($r, 1);
    $this->redis->zadd2($key4,'(lrange mylist1 0 -1)');
    $r = $this->redis->zlen($key4);
    $this->assertEquals($r, 3);
    /* ex 20 */
    $this->redis->zadd2($key2,10,'E1','ex',100);
}

ZLS (zset list)

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

사용 예

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

Test code

/* ZLS key pattern [sort/asc/desc] */
public function testZls()
{
    $this->redis->rm('(ls * zset)'); // delete zset keys
    $cnt = 3;
    $key= 'myzset';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->zadd($key, 0, 'A'.$i);
    }
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->zadd($key, 0, 'B'.$i);
    }
    $keys = $this->redis->zls($key,'*'); // zls myzset *
    $this->assertEquals((count($keys)), $cnt*2);
    $keys = $this->redis->zls($key,'A*'); // zls myzset A*
    $this->assertEquals((count($keys)), $cnt);
    $keys = $this->redis->zls($key,'A*','sort'); // zls myzset A* sort
    $this->assertEquals((count($keys)), $cnt);
    $this->assertTrue($keys === ['A1','A2','A3']);
}

ZRM (zset remove)

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

사용 예

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

Test code

/* ZRM key pattern */
public function testZrm()
{
    $this->redis->rm('(ls * zset)'); // delete zset keys
    $cnt = 3;
    $key= 'myzset';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->zadd($key, 0, 'A'.$i);
    }
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->zadd($key, 0, 'B'.$i);
    }
    $r = $this->redis->zrm($key,'A*'); // zrm myzset A*
    $this->assertEquals($r, $cnt);
    $r = $this->redis->zrm($key,'*'); // zrm myzset *
    $this->assertEquals($r, $cnt);
    $r = $this->redis->zrm($key,'*'); // zrm myzset *
    $this->assertTrue($r == NULL);
}

ZISMEMBER

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

사용 예

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

Test code

/* ZISMEMBER key member */
public function testzismember()
{    
    $key1 = 'myzset1';
    $this->redis->rm('(ls * zset)');    // delete set keys
    $this->redis->zadd($key1,20,'A2',10,'A1',30,'A3'); 
    $this->assertTrue($this->redis->zismember($key1, 'A1'));
    $this->assertFalse($this->redis->zismember($key1, 'A9'));
}

HASH

HLS (hash list)

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

사용 예

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

Test code

/* HLS key field-pattern [sort|asc|desc] */
public function testHls()
{
    $this->redis->rm('(ls * hash)'); // delete hash keys
    $cnt = 3;
    $key= 'myhash';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->hset($key, 'A'.$i, 'V'.$i);
    }
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->hset($key, 'B'.$i, 'V'.$i);
    }
    $keys = $this->redis->hls($key,'*'); // zls myzset *
    $this->assertEquals((count($keys)), $cnt*4);
    $keys = $this->redis->hls($key,'A*'); // zls myzset A*
    $this->assertEquals((count($keys)), $cnt*2);
    $keys = $this->redis->hls($key,'A*','sort'); // zls myzset A* sort
    $this->assertEquals((count($keys)), $cnt*2);
    $this->assertTrue($keys === ['A1','V1','A2','V2','A3','V3']);
}

HRM (zset remove)

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

사용 예

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

Test code

/* HRM key field-pattern */
public function testHrm()
{    
    $this->redis->rm('(ls * hash)'); // delete hash keys
    $cnt = 3; 
    $key= 'myhash';
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->hset($key, 'A'.$i, 'V'.$i);
    }    
    for($i = 1; $i <= $cnt; $i++) {
        $this->redis->hset($key, 'B'.$i, 'V'.$i);
    }    
    $r = $this->redis->hrm($key,'A*'); // hrm myhash A*
    $this->assertEquals($r, $cnt);
    $r = $this->redis->hrm($key,'*'); // hrm myhash *
    $this->assertEquals($r, $cnt);
    $r = $this->redis->hrm($key,'*'); // hrm myhash *
    $this->assertTrue($r == NULL);
}

ZLEN

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

사용 예

zlen myzset -> $this->redis->zlen('myzset');
myzset에 속한 멤버 개수를 조회합니다.

Test code

/* ZLEN key */
public function testZlen()
{    
    $key1 = 'myzset1';
    $this->redis->rm('(ls * zset)');    // delete set keys
    $this->redis->zadd($key1,20,'A2',10,'A1',30,'A3'); 
    $r = $this->redis->zlen($key1);
    $this->assertEquals($r, 3);
}

HKEYS / HVALS / HGETALL

멀티 키 사용: 해시(Hash)에서 키를 여러 개 입력해서 조회합니다.
주의: CLI에서는 HKEYS/HVALS/HGETALL를 사용하고 PhpRedis에서는 HKEYS2()/HVALS2()/HGETALL2()를 사용합니다.

사용 예

hkeys myhash1 myhash2 -> $this->redis->hkeys2('myhash1','myhash2');
키 myhash1과 myhash2의 필드를 조회합니다.
hvals myhash1 myhash2 -> $this->redis->hvals2('myhash1','myhash2');
키 myhash1과 myhash2의 값을 조회합니다.
hgetall myhash1 myhash2 -> $this->redis->hgetall2('myhash1','myhash2');
키 myhash1과 myhash2의 필드와 값을 조회합니다.

Test code

/* hkeys, hvals, hgetall -> multi keys test */
/* HKEYS key [key ...], HVALS key [key ...], HGETALL key [key ...] */
public function testhkeys2()
{
    $key1 = 'myhash1';
    $key2 = 'myhash2';
    $this->redis->rm('(ls * hash)');    // delete hash keys
    $this->redis->hmset($key1,['f10'=>'v10','f11'=>'v11','f12'=>'v12']);
    $this->redis->hmset($key2,['f20'=>'v20','f21'=>'v21','f22'=>'v22']);
    /* hkeys */
    $arr = $this->redis->hkeys2($key1);
    $this->assertEquals(count($arr), 3);
    $this->assertTrue($arr === ['f10','f11','f12']);
    $arr = $this->redis->hkeys2($key1,$key2);
    $this->assertEquals(count($arr), 10);
    $this->assertTrue($arr === ['myhash1','3','f10','f11','f12','myhash2','3','f20','f21','f22']);
    /* hvals */
    $arr = $this->redis->hvals2($key1);
    $this->assertEquals(count($arr), 3);
    $this->assertTrue($arr === ['v10','v11','v12']);
    $arr = $this->redis->hvals2($key1,$key2);
    $this->assertEquals(count($arr), 10);
    $this->assertTrue($arr === ['myhash1','3','v10','v11','v12','myhash2','3','v20','v21','v22']);
    /* hgetall */
    $arr = $this->redis->hgetall2($key1);
    $this->assertEquals(count($arr), 6);
    $this->assertTrue($arr === ['f10','v10','f11','v11','f12','v12']);
    $arr = $this->redis->hgetall2($key1,$key2);
    $this->assertEquals(count($arr), 16);
    $this->assertTrue($arr === ['myhash1','6','f10','v10','f11','v11','f12','v12','myhash2', 
                                                      '6','f20','v20','f21','v21','f22','v22']);
}

<< PHPREDIS	Enterprise	Program >>