Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
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
Show 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