Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
ruanhaishen
redis
Commits
c937aa89
Commit
c937aa89
authored
Mar 24, 2009
by
antirez
Browse files
Server replies now in the new format, test-redis.tcl and redis-cli modified accordingly
parent
796d05f8
Changes
3
Expand all
Hide whitespace changes
Inline
Side-by-side
redis-cli.c
View file @
c937aa89
...
...
@@ -40,11 +40,6 @@
#define REDIS_CMD_INLINE 1
#define REDIS_CMD_BULK 2
#define REDIS_CMD_INTREPLY 4
#define REDIS_CMD_RETCODEREPLY 8
#define REDIS_CMD_BULKREPLY 16
#define REDIS_CMD_MULTIBULKREPLY 32
#define REDIS_CMD_SINGLELINEREPLY 64
#define REDIS_NOTUSED(V) ((void) V)
...
...
@@ -60,54 +55,56 @@ struct redisCommand {
};
static
struct
redisCommand
cmdTable
[]
=
{
{
"get"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_BULKREPLY
},
{
"set"
,
3
,
REDIS_CMD_BULK
|
REDIS_CMD_RETCODEREPLY
},
{
"setnx"
,
3
,
REDIS_CMD_BULK
|
REDIS_CMD_INTREPLY
},
{
"del"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"exists"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"incr"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"decr"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"rpush"
,
3
,
REDIS_CMD_BULK
|
REDIS_CMD_RETCODEREPLY
},
{
"lpush"
,
3
,
REDIS_CMD_BULK
|
REDIS_CMD_RETCODEREPLY
},
{
"rpop"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_BULKREPLY
},
{
"lpop"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_BULKREPLY
},
{
"llen"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"lindex"
,
3
,
REDIS_CMD_INLINE
|
REDIS_CMD_BULKREPLY
},
{
"lset"
,
4
,
REDIS_CMD_BULK
|
REDIS_CMD_RETCODEREPLY
},
{
"lrange"
,
4
,
REDIS_CMD_INLINE
|
REDIS_CMD_MULTIBULKREPLY
},
{
"ltrim"
,
4
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"lrem"
,
4
,
REDIS_CMD_BULK
|
REDIS_CMD_INTREPLY
},
{
"sadd"
,
3
,
REDIS_CMD_BULK
|
REDIS_CMD_INTREPLY
},
{
"srem"
,
3
,
REDIS_CMD_BULK
|
REDIS_CMD_INTREPLY
},
{
"sismember"
,
3
,
REDIS_CMD_BULK
|
REDIS_CMD_INTREPLY
},
{
"scard"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"sinter"
,
-
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_MULTIBULKREPLY
},
{
"sinterstore"
,
-
3
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"smembers"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_MULTIBULKREPLY
},
{
"incrby"
,
3
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"decrby"
,
3
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"randomkey"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_SINGLELINEREPLY
},
{
"select"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"move"
,
3
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"rename"
,
3
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"renamenx"
,
3
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"keys"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_BULKREPLY
},
{
"dbsize"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"ping"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"echo"
,
2
,
REDIS_CMD_BULK
|
REDIS_CMD_BULKREPLY
},
{
"save"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"bgsave"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"shutdown"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"lastsave"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_INTREPLY
},
{
"type"
,
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_SINGLELINEREPLY
},
{
"flushdb"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"flushall"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_RETCODEREPLY
},
{
"sort"
,
-
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_MULTIBULKREPLY
},
{
"info"
,
1
,
REDIS_CMD_INLINE
|
REDIS_CMD_BULKREPLY
},
{
"mget"
,
-
2
,
REDIS_CMD_INLINE
|
REDIS_CMD_MULTIBULKREPLY
},
{
"get"
,
2
,
REDIS_CMD_INLINE
},
{
"set"
,
3
,
REDIS_CMD_BULK
},
{
"setnx"
,
3
,
REDIS_CMD_BULK
},
{
"del"
,
2
,
REDIS_CMD_INLINE
},
{
"exists"
,
2
,
REDIS_CMD_INLINE
},
{
"incr"
,
2
,
REDIS_CMD_INLINE
},
{
"decr"
,
2
,
REDIS_CMD_INLINE
},
{
"rpush"
,
3
,
REDIS_CMD_BULK
},
{
"lpush"
,
3
,
REDIS_CMD_BULK
},
{
"rpop"
,
2
,
REDIS_CMD_INLINE
},
{
"lpop"
,
2
,
REDIS_CMD_INLINE
},
{
"llen"
,
2
,
REDIS_CMD_INLINE
},
{
"lindex"
,
3
,
REDIS_CMD_INLINE
},
{
"lset"
,
4
,
REDIS_CMD_BULK
},
{
"lrange"
,
4
,
REDIS_CMD_INLINE
},
{
"ltrim"
,
4
,
REDIS_CMD_INLINE
},
{
"lrem"
,
4
,
REDIS_CMD_BULK
},
{
"sadd"
,
3
,
REDIS_CMD_BULK
},
{
"srem"
,
3
,
REDIS_CMD_BULK
},
{
"sismember"
,
3
,
REDIS_CMD_BULK
},
{
"scard"
,
2
,
REDIS_CMD_INLINE
},
{
"sinter"
,
-
2
,
REDIS_CMD_INLINE
},
{
"sinterstore"
,
-
3
,
REDIS_CMD_INLINE
},
{
"smembers"
,
2
,
REDIS_CMD_INLINE
},
{
"incrby"
,
3
,
REDIS_CMD_INLINE
},
{
"decrby"
,
3
,
REDIS_CMD_INLINE
},
{
"randomkey"
,
1
,
REDIS_CMD_INLINE
},
{
"select"
,
2
,
REDIS_CMD_INLINE
},
{
"move"
,
3
,
REDIS_CMD_INLINE
},
{
"rename"
,
3
,
REDIS_CMD_INLINE
},
{
"renamenx"
,
3
,
REDIS_CMD_INLINE
},
{
"keys"
,
2
,
REDIS_CMD_INLINE
},
{
"dbsize"
,
1
,
REDIS_CMD_INLINE
},
{
"ping"
,
1
,
REDIS_CMD_INLINE
},
{
"echo"
,
2
,
REDIS_CMD_BULK
},
{
"save"
,
1
,
REDIS_CMD_INLINE
},
{
"bgsave"
,
1
,
REDIS_CMD_INLINE
},
{
"shutdown"
,
1
,
REDIS_CMD_INLINE
},
{
"lastsave"
,
1
,
REDIS_CMD_INLINE
},
{
"type"
,
2
,
REDIS_CMD_INLINE
},
{
"flushdb"
,
1
,
REDIS_CMD_INLINE
},
{
"flushall"
,
1
,
REDIS_CMD_INLINE
},
{
"sort"
,
-
2
,
REDIS_CMD_INLINE
},
{
"info"
,
1
,
REDIS_CMD_INLINE
},
{
"mget"
,
-
2
,
REDIS_CMD_INLINE
},
{
NULL
,
0
,
0
}
};
static
int
cliReadReply
(
int
fd
);
static
struct
redisCommand
*
lookupCommand
(
char
*
name
)
{
int
j
=
0
;
while
(
cmdTable
[
j
].
name
!=
NULL
)
{
...
...
@@ -150,38 +147,26 @@ static sds cliReadLine(int fd) {
return
sdstrim
(
line
,
"
\r\n
"
);
}
static
int
cliRead
Inl
ineReply
(
int
fd
,
int
type
)
{
static
int
cliRead
SingleL
ineReply
(
int
fd
)
{
sds
reply
=
cliReadLine
(
fd
);
if
(
reply
==
NULL
)
return
1
;
printf
(
"%s
\n
"
,
reply
);
if
(
type
==
REDIS_CMD_SINGLELINEREPLY
)
return
0
;
if
(
type
==
REDIS_CMD_INTREPLY
)
return
atoi
(
reply
)
<
0
;
if
(
type
==
REDIS_CMD_RETCODEREPLY
)
return
reply
[
0
]
==
'-'
;
return
0
;
}
static
int
cliReadBulkReply
(
int
fd
,
int
multibulk
)
{
static
int
cliReadBulkReply
(
int
fd
)
{
sds
replylen
=
cliReadLine
(
fd
);
char
*
reply
,
crlf
[
2
];
int
bulklen
,
error
=
0
;
int
bulklen
;
if
(
replylen
==
NULL
)
return
1
;
if
(
strcmp
(
replylen
,
"nil"
)
==
0
)
{
sdsfree
(
replylen
);
printf
(
"(nil)
\n
"
);
return
0
;
}
bulklen
=
atoi
(
replylen
);
if
(
multibulk
&&
bulklen
==
-
1
)
{
if
(
bulklen
==
-
1
)
{
sdsfree
(
replylen
);
printf
(
"(nil)"
);
return
0
;
}
if
(
bulklen
<
0
)
{
bulklen
=
-
bulklen
;
error
=
1
;
}
reply
=
zmalloc
(
bulklen
);
anetRead
(
fd
,
reply
,
bulklen
);
anetRead
(
fd
,
crlf
,
2
);
...
...
@@ -189,10 +174,10 @@ static int cliReadBulkReply(int fd, int multibulk) {
zfree
(
reply
);
return
1
;
}
if
(
!
multibulk
&&
isatty
(
fileno
(
stdout
))
&&
reply
[
bulklen
-
1
]
!=
'\n'
)
if
(
isatty
(
fileno
(
stdout
))
&&
reply
[
bulklen
-
1
]
!=
'\n'
)
printf
(
"
\n
"
);
zfree
(
reply
);
return
error
;
return
0
;
}
static
int
cliReadMultiBulkReply
(
int
fd
)
{
...
...
@@ -200,21 +185,45 @@ static int cliReadMultiBulkReply(int fd) {
int
elements
,
c
=
1
;
if
(
replylen
==
NULL
)
return
1
;
if
(
strcmp
(
replylen
,
"nil"
)
==
0
)
{
elements
=
atoi
(
replylen
);
if
(
elements
==
-
1
)
{
sdsfree
(
replylen
);
printf
(
"(nil)
\n
"
);
return
0
;
}
elements
=
atoi
(
replylen
);
if
(
elements
==
0
)
{
printf
(
"(empty list or set)
\n
"
);
}
while
(
elements
--
)
{
printf
(
"%d. "
,
c
);
if
(
cliReadBulkReply
(
fd
,
1
))
return
1
;
printf
(
"
\n
"
);
if
(
cliReadReply
(
fd
))
return
1
;
c
++
;
}
return
0
;
}
static
int
cliReadReply
(
int
fd
)
{
char
type
;
if
(
anetRead
(
fd
,
&
type
,
1
)
<=
0
)
exit
(
1
);
switch
(
type
)
{
case
'-'
:
printf
(
"(error) "
);
cliReadSingleLineReply
(
fd
);
return
1
;
case
'+'
:
case
':'
:
return
cliReadSingleLineReply
(
fd
);
case
'$'
:
return
cliReadBulkReply
(
fd
);
case
'*'
:
return
cliReadMultiBulkReply
(
fd
);
default:
printf
(
"protocol error, got '%c' as reply type byte
\n
"
,
type
);
return
1
;
}
}
static
int
cliSendCommand
(
int
argc
,
char
**
argv
)
{
struct
redisCommand
*
rc
=
lookupCommand
(
argv
[
0
]);
int
fd
,
j
,
retval
=
0
;
...
...
@@ -247,17 +256,7 @@ static int cliSendCommand(int argc, char **argv) {
cmd
=
sdscat
(
cmd
,
"
\r\n
"
);
}
anetWrite
(
fd
,
cmd
,
sdslen
(
cmd
));
if
(
rc
->
flags
&
REDIS_CMD_INTREPLY
)
{
retval
=
cliReadInlineReply
(
fd
,
REDIS_CMD_INTREPLY
);
}
else
if
(
rc
->
flags
&
REDIS_CMD_RETCODEREPLY
)
{
retval
=
cliReadInlineReply
(
fd
,
REDIS_CMD_RETCODEREPLY
);
}
else
if
(
rc
->
flags
&
REDIS_CMD_SINGLELINEREPLY
)
{
retval
=
cliReadInlineReply
(
fd
,
REDIS_CMD_SINGLELINEREPLY
);
}
else
if
(
rc
->
flags
&
REDIS_CMD_BULKREPLY
)
{
retval
=
cliReadBulkReply
(
fd
,
0
);
}
else
if
(
rc
->
flags
&
REDIS_CMD_MULTIBULKREPLY
)
{
retval
=
cliReadMultiBulkReply
(
fd
);
}
retval
=
cliReadReply
(
fd
);
if
(
retval
)
{
close
(
fd
);
return
retval
;
...
...
redis.c
View file @
c937aa89
This diff is collapsed.
Click to expand it.
test-redis.tcl
View file @
c937aa89
...
...
@@ -124,16 +124,16 @@ proc main {server port} {
puts -nonewline $fd
"SET k1 4
\r\n
xyzk
\r\n
GET k1
\r\n
PING
\r\n
"
flush $fd
set res
{}
append res
[
string match
+
OK*
[
redis_read_re
tcode
$fd
]]
append res
[
redis_
bulk_read
$fd
]
append res
[
string match
+
PONG*
[
redis_read_re
tcode
$fd
]]
append res
[
string match OK*
[
redis_read_re
ply
$fd
]]
append res
[
redis_
read_reply
$fd
]
append res
[
string match PONG*
[
redis_read_re
ply
$fd
]]
format $res
}
{
1xyzk1
}
test
{
Non existing command
}
{
puts -nonewline $fd
"foo
\r\n
"
flush $fd
string match
-
ERR*
[
redis_read_re
tcode
$fd
]
string match ERR*
[
redis_read_re
ply
$fd
]
}
{
1
}
test
{
Basic LPUSH, RPUSH, LLENGTH, LINDEX
}
{
...
...
@@ -181,19 +181,19 @@ proc main {server port} {
redis_del $fd mylist
redis_set $fd mylist foobar
redis_llen $fd mylist
}
{
-2
}
}
{
ERR*
}
test
{
LINDEX against non-list value error
}
{
redis_lindex $fd mylist 0
}
{
*
ERR
OR
*
}
}
{
ERR*
}
test
{
LPUSH against non-list value error
}
{
redis_lpush $fd mylist 0
}
{
-
ERR*
}
}
{
ERR*
}
test
{
RPUSH against non-list value error
}
{
redis_rpush $fd mylist 0
}
{
-
ERR*
}
}
{
ERR*
}
test
{
RENAME basic usage
}
{
redis_set $fd mykey hello
...
...
@@ -236,11 +236,11 @@ proc main {server port} {
test
{
RENAME against non existing source key
}
{
redis_rename $fd nokey foobar
}
{
-
ERR*
}
}
{
ERR*
}
test
{
RENAME where source and dest key is the same
}
{
redis_rename $fd mykey mykey
}
{
-
ERR*
}
}
{
ERR*
}
test
{
DEL all keys again
(
DB 0
)}
{
foreach key
[
redis_keys $fd *
]
{
...
...
@@ -309,7 +309,7 @@ proc main {server port} {
test
{
LPOP against non list value
}
{
redis_set $fd notalist foo
redis_lpop $fd notalist
}
{
*
ERR
OR*against
*
}
}
{
ERR
*kind
*
}
test
{
Mass LPUSH/LPOP
}
{
set sum 0
...
...
@@ -363,16 +363,16 @@ proc main {server port} {
test
{
LSET out of range index
}
{
redis_lset $fd mylist 10 foo
}
{
-
ERR*range*
}
}
{
ERR*range*
}
test
{
LSET against non existing key
}
{
redis_lset $fd nosuchkey 10 foo
}
{
-
ERR*key*
}
}
{
ERR*key*
}
test
{
LSET against non list value
}
{
redis_set $fd nolist foobar
redis_lset $fd nolist 0 foo
}
{
-
ERR*value*
}
}
{
ERR*value*
}
test
{
SADD, SCARD, SISMEMBER, SMEMBERS basics
}
{
redis_sadd $fd myset foo
...
...
@@ -391,7 +391,7 @@ proc main {server port} {
test
{
SADD against non set
}
{
redis_sadd $fd mylist foo
}
{
-2
}
}
{
ERR*kind*
}
test
{
SREM basics
}
{
redis_sadd $fd myset ciao
...
...
@@ -431,7 +431,7 @@ proc main {server port} {
redis_set $fd myemptykey
{}
redis_set $fd mynormalkey
{
blablablba
}
redis_save $fd
}
{
+
OK
}
}
{
OK
}
test
{
Create a random list
}
{
set tosort
{}
...
...
@@ -606,221 +606,224 @@ proc redis_readnl {fd len} {
return $buf
}
proc redis_bulk_read
{
fd
{
multi 0
}}
{
set count
[
redis_read_integer $fd
]
if
{
$count
eq
{
nil
}}
return
{}
if
{
$multi
&& $count == -1
}
return
{}
set len
[
expr
{
abs
(
$count
)}]
set buf
[
redis_readnl $fd $len
]
if
{
$count
< 0
}
{
return
"***ERROR***
$buf
"
}
proc redis_bulk_read
{
fd
}
{
set count
[
redis_read_line $fd
]
if
{
$count
== -1
}
return
{}
set buf
[
redis_readnl $fd $count
]
return $buf
}
proc redis_multi_bulk_read fd
{
set count
[
redis_read_integer $fd
]
if
{
$count
eq
{
nil
}}
return
{}
if
{
$count
< 0
}
{
set len
[
expr
{
abs
(
$count
)}]
set buf
[
redis_readnl $fd $len
]
return
"***ERROR***
$buf
"
}
set count
[
redis_read_line $fd
]
if
{
$count
== -1
}
return
{}
set l
{}
for
{
set i 0
}
{
$i
< $count
}
{
incr i
}
{
lappend l
[
redis_
bulk_read
$fd
1
]
lappend l
[
redis_
read_reply
$fd
]
}
return $l
}
proc redis_read_retcode fd
{
set retcode
[
string trim
[
gets $fd
]]
# puts
"S:
$retcode
"
return $retcode
proc redis_read_line fd
{
string trim
[
gets $fd
]
}
proc redis_read_integer fd
{
string trim
[
gets $fd
]
proc redis_read_reply fd
{
set type
[
read $fd 1
]
if
{
$type
eq
{
:
}}
{
redis_read_line $fd
}
elseif
{
$type
eq
{
-
}}
{
redis_read_line $fd
}
elseif
{
$type
eq
{
+
}}
{
redis_read_line $fd
}
elseif
{
$type
eq
{
$
}}
{
redis_bulk_read $fd
}
elseif
{
$type
eq
{*}
}
{
redis_multi_bulk_read $fd
}
else
{
error
"Bad protocol:
$type
as initial reply byte"
}
}
### Actual API ###
proc redis_set
{
fd key val
}
{
redis_writenl $fd
"set
$key
[
string length $val
]
\r\n
$val
"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_setnx
{
fd key val
}
{
redis_writenl $fd
"setnx
$key
[
string length $val
]
\r\n
$val
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_get
{
fd key
}
{
redis_writenl $fd
"get
$key
"
redis_
bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_select
{
fd id
}
{
redis_writenl $fd
"select
$id
"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_move
{
fd key id
}
{
redis_writenl $fd
"move
$key
$id
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_del
{
fd key
}
{
redis_writenl $fd
"del
$key
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_keys
{
fd pattern
}
{
redis_writenl $fd
"keys
$pattern
"
split
[
redis_
bulk_read
$fd
]
split
[
redis_
read_reply
$fd
]
}
proc redis_dbsize
{
fd
}
{
redis_writenl $fd
"dbsize"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_incr
{
fd key
}
{
redis_writenl $fd
"incr
$key
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_decr
{
fd key
}
{
redis_writenl $fd
"decr
$key
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_exists
{
fd key
}
{
redis_writenl $fd
"exists
$key
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_lpush
{
fd key val
}
{
redis_writenl $fd
"lpush
$key
[
string length $val
]
\r\n
$val
"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_rpush
{
fd key val
}
{
redis_writenl $fd
"rpush
$key
[
string length $val
]
\r\n
$val
"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_llen
{
fd key
}
{
redis_writenl $fd
"llen
$key
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_scard
{
fd key
}
{
redis_writenl $fd
"scard
$key
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_lindex
{
fd key index
}
{
redis_writenl $fd
"lindex
$key
$index
"
redis_
bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_lrange
{
fd key first last
}
{
redis_writenl $fd
"lrange
$key
$first
$last
"
redis_
multi_bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_mget
{
fd args
}
{
redis_writenl $fd
"mget
[
join $args
]
"
redis_
multi_bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_sort
{
fd key
{
params
{}}}
{
redis_writenl $fd
"sort
$key
$params
"
redis_
multi_bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_ltrim
{
fd key first last
}
{
redis_writenl $fd
"ltrim
$key
$first
$last
"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_rename
{
fd key1 key2
}
{
redis_writenl $fd
"rename
$key1
$key2
"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_renamenx
{
fd key1 key2
}
{
redis_writenl $fd
"renamenx
$key1
$key2
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_lpop
{
fd key
}
{
redis_writenl $fd
"lpop
$key
"
redis_
bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_rpop
{
fd key
}
{
redis_writenl $fd
"rpop
$key
"
redis_
bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_lset
{
fd key index val
}
{
redis_writenl $fd
"lset
$key
$index
[
string length $val
]
\r\n
$val
"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_sadd
{
fd key val
}
{
redis_writenl $fd
"sadd
$key
[
string length $val
]
\r\n
$val
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_srem
{
fd key val
}
{
redis_writenl $fd
"srem
$key
[
string length $val
]
\r\n
$val
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_sismember
{
fd key val
}
{
redis_writenl $fd
"sismember
$key
[
string length $val
]
\r\n
$val
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc redis_sinter
{
fd args
}
{
redis_writenl $fd
"sinter
[
join $args
]
"
redis_
multi_bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_sinterstore
{
fd args
}
{
redis_writenl $fd
"sinterstore
[
join $args
]
"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_smembers
{
fd key
}
{
redis_writenl $fd
"smembers
$key
"
redis_
multi_bulk_read
$fd
redis_
read_reply
$fd
}
proc redis_echo
{
fd str
}
{
redis_writenl $fd
"echo
[
string length $str
]
\r\n
$str
"
redis_
writenl $fd
"smembers
$key
"
redis_
read_reply $fd
}
proc redis_save
{
fd
}
{
redis_writenl $fd
"save"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_flushall
{
fd
}
{
redis_writenl $fd
"flushall"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_flushdb
{
fd
}
{
redis_writenl $fd
"flushdb"
redis_read_re
tcode
$fd
redis_read_re
ply
$fd
}
proc redis_lrem
{
fd key count val
}
{
redis_writenl $fd
"lrem
$key
$count
[
string length $val
]
\r\n
$val
"
redis_read_
integer
$fd
redis_read_
reply
$fd
}
proc stress
{}
{
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment