Struct Client

Source

pub struct Client { /* private fields */ }

Expand description

A Ruvio client. Against a single server it is one TCP connection. Against a sharded server it opens one connection per shard and sends each command to the shard that owns its key.

Subscribe commands open a second TCP socket, the same way Ruvio.Client does. GET, SET, PING, and PUBLISH stay on the command sockets.

The client speaks RESP2 and does not send CLIENT SETINFO or HELLO.

Implementations§

Source §

impl Client

Source

pub fn connect(host: impl Into<String>, port: u16) -> Result<Self, Error>

Opens a connection. Sends CLUSTER SLOTS so a sharded server is routed automatically.

Examples found in repository ?

examples/tour.rs (line 25)

17fn main() -> Result<(), ruvio_client::Error> {
18    let host = std::env::args()
19        .nth(1)
20        .unwrap_or_else(|| "127.0.0.1".to_owned());
21    let port = std::env::args()
22        .nth(2)
23        .and_then(|text| text.parse().ok())
24        .unwrap_or(6379);
25    let mut db = Client::connect(&host, port)?;
26
27    db.on_connection_lost(|notice| {
28        println!(
29            "connection lost {}:{} subscriber={}",
30            notice.host, notice.port, notice.subscriber
31        );
32    });
33
34    db.on_connection_restored(|notice| {
35        println!(
36            "connection restored {}:{} subscriber={}",
37            notice.host, notice.port, notice.subscriber
38        );
39    });
40
41    db.set_reconnect_delay(|attempt| {
42        if attempt >= 8 {
43            None
44        } else {
45            Some(Duration::from_millis(100 * 2u64.pow(attempt - 1)))
46        }
47    });
48
49    println!(
50        "connected cluster={} shards={} slot={}",
51        db.is_cluster(),
52        db.shard_count(),
53        ruvio_client::hash_slot("{tour}")
54    );
55    println!("reconnect armed; the command that sees a drop fails, the next one opens the socket");
56
57    if !db.is_cluster() {
58        db.select(15)?;
59        db.flushdb()?;
60        println!("selected database {}", db.database());
61    }
62
63    strings(&mut db)?;
64    owned(&mut db)?;
65    lists(&mut db)?;
66    sets(&mut db)?;
67    hashes(&mut db)?;
68    sorted_sets(&mut db)?;
69    bloom(&mut db)?;
70    streams(&mut db)?;
71    transactions(&mut db)?;
72    server(&mut db)?;
73    pubsub(&host, port)?;
74
75    println!("tour finished");
76
77    Ok(())
78}
79
80fn strings(db: &mut Client) -> Result<(), ruvio_client::Error> {
81    let key = "{tour}:s";
82
83    db.set(key, "hello")?;
84    println!("get {:?}", db.get_string(key)?);
85    db.set_with(key, "nx", None, SetMode::IfNotExists)?;
86    db.set_expires_at(
87        key,
88        "later",
89        SystemTime::now() + Duration::from_secs(120),
90        SetMode::Always,
91    )?;
92    db.set_keep_ttl(key, "kept", SetMode::Always)?;
93    println!(
94        "set_and_get {:?}",
95        db.set_and_get(key, "now", None, SetMode::Always)?
96    );
97    db.mset(&[("{tour}:a", "1"), ("{tour}:b", "2")])?;
98    println!(
99        "mget {:?}",
100        db.mget(&["{tour}:a", "{tour}:missing", "{tour}:b"])?
101    );
102    println!("getset {:?}", db.getset(key, "10")?);
103    println!("append {}", db.append(key, "0")?);
104    println!("strlen {}", db.strlen(key)?);
105    println!("incr {}", db.incr("{tour}:n")?);
106    println!("incr_by {}", db.incr_by("{tour}:n", 5)?);
107    println!("decr {}", db.decr("{tour}:n")?);
108    println!("decr_by {}", db.decr_by("{tour}:n", 2)?);
109    println!("exists {}", db.exists(&["{tour}:a", "{tour}:b"])?);
110    println!("exists_key {}", db.exists_key(key)?);
111    println!("type {}", db.key_type(key)?);
112    db.rename("{tour}:b", "{tour}:c")?;
113    println!("unlink {}", db.unlink(&["{tour}:c"])?);
114    println!("unlink_key {}", db.unlink_key("{tour}:gone")?);
115    db.expire(key, Duration::from_secs(30))?;
116    db.pexpire("{tour}:a", Duration::from_millis(30_000))?;
117    db.expire_at("{tour}:a", SystemTime::now() + Duration::from_secs(60))?;
118    println!("ttl {} pttl {}", db.ttl(key)?, db.pttl(key)?);
119    println!("persist {}", db.persist(key)?);
120    let page = db.scan(0, Some("{tour}:*"), Some(20))?;
121
122    println!("scan cursor={} keys={}", page.cursor, page.keys.len());
123    println!("dbsize {}", db.dbsize()?);
124    println!("del {}", db.del(&["{tour}:a"])?);
125    println!("del_key {}", db.del_key("{tour}:n")?);
126
127    Ok(())
128}
129
130fn owned(db: &mut Client) -> Result<(), ruvio_client::Error> {
131    let first = db.lease("{tour}:lock", 30_000)?;
132
133    println!(
134        "lease {:?} held {:?} release {}",
135        first,
136        db.lease("{tour}:lock", 30_000)?,
137        db.release("{tour}:lock", first.unwrap_or(0) as u64)?
138    );
139    let permit = db.semaphore("{tour}:workers", 1, 30_000)?;
140
141    println!(
142        "semaphore {:?} full {:?} release {}",
143        permit,
144        db.semaphore("{tour}:workers", 1, 30_000)?,
145        db.release("{tour}:workers", permit.unwrap_or(0) as u64)?
146    );
147    println!(
148        "incr_by_max {:?} over {:?}",
149        db.incr_by_max("{tour}:seats", 3, 4)?,
150        db.incr_by_max("{tour}:seats", 2, 4)?
151    );
152    let created = db.setv("{tour}:doc", "12", None)?;
153    let next = db.setv("{tour}:doc", "11", Some(created as u64))?;
154
155    println!("setv {created} then {next}");
156    println!(
157        "setv mismatch {}",
158        db.setv("{tour}:doc", "10", Some(created as u64))
159            .err()
160            .map(|error| error.to_string())
161            .unwrap_or_else(|| "accepted".to_owned())
162    );
163    let cursor = db.changes_start()?;
164
165    db.set("{tour}:note", "paid")?;
166    let notes = db.changes(cursor as u64)?;
167
168    println!(
169        "changes cursor={cursor} notes={} {}",
170        notes.len(),
171        notes.first().map(|(_, text)| text.as_str()).unwrap_or("")
172    );
173    println!(
174        "limit {:?} {:?}",
175        db.limit("{tour}:login", 2, 60_000)?,
176        db.limit("{tour}:login", 2, 60_000)?
177    );
178    println!(
179        "once {} {}",
180        db.once("{tour}:pay", 60_000)?,
181        db.once("{tour}:pay", 60_000)?
182    );
183    db.set("{tour}:seats", "5")?;
184    println!(
185        "take {:?} {:?}",
186        db.take("{tour}:seats", 2)?,
187        db.take("{tour}:seats", 9)?
188    );
189    println!("getex {:?}", db.getex("{tour}:seats", 60_000)?);
190
191    Ok(())
192}
193
194fn lists(db: &mut Client) -> Result<(), ruvio_client::Error> {
195    let key = "{tour}:l";
196
197    println!("rpush {}", db.rpush(key, &["a", "b", "c", "d"])?);
198    println!("lpush {}", db.lpush(key, &["z"])?);
199    println!("lpop {:?}", db.lpop(key)?);
200    println!("rpop_count {:?}", db.rpop_count(key, 2)?);
201    println!("llen {}", db.llen(key)?);
202    println!("lindex {:?}", db.lindex(key, 0)?);
203    println!("lrange {:?}", db.lrange(key, 0, -1)?);
204    db.ltrim(key, 0, 0)?;
205    println!("lpop_count {:?}", db.lpop_count(key, 1)?);
206    db.rpush(key, &["only"])?;
207    println!("blpop {:?}", db.blpop_key(key, Duration::from_millis(200))?);
208    db.rpush(key, &["right"])?;
209    println!("brpop {:?}", db.brpop(&[key], Duration::from_millis(200))?);
210    println!(
211        "brpop empty {:?}",
212        db.brpop_key(key, Duration::from_millis(1))?
213    );
214
215    Ok(())
216}
217
218fn sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
219    println!("sadd {}", db.sadd("{tour}:s1", &["a", "b", "c"])?);
220    db.sadd("{tour}:s2", &["b", "c", "d"])?;
221    println!("sismember {}", db.sismember("{tour}:s1", "a")?);
222    println!("scard {}", db.scard("{tour}:s1")?);
223    println!("smembers {:?}", db.smembers("{tour}:s1")?);
224    println!("sinter {:?}", db.sinter(&["{tour}:s1", "{tour}:s2"])?);
225    println!("sunion {:?}", db.sunion(&["{tour}:s1", "{tour}:s2"])?);
226    println!("sdiff {:?}", db.sdiff(&["{tour}:s1", "{tour}:s2"])?);
227    println!(
228        "sinterstore {}",
229        db.sinterstore("{tour}:s3", &["{tour}:s1", "{tour}:s2"])?
230    );
231    println!(
232        "sunionstore {}",
233        db.sunionstore("{tour}:s4", &["{tour}:s1", "{tour}:s2"])?
234    );
235    println!(
236        "sdiffstore {}",
237        db.sdiffstore("{tour}:s5", &["{tour}:s1", "{tour}:s2"])?
238    );
239    println!("smove {}", db.smove("{tour}:s1", "{tour}:s3", "a")?);
240    println!("srem {}", db.srem("{tour}:s3", &["a"])?);
241    println!("srandmember {:?}", db.srandmember("{tour}:s2")?);
242    println!(
243        "srandmember_count {:?}",
244        db.srandmember_count("{tour}:s2", 2)?
245    );
246    println!("spop_count {:?}", db.spop_count("{tour}:s5", 5)?);
247    println!("spop {:?}", db.spop("{tour}:s4")?);
248
249    Ok(())
250}
251
252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}
299
300fn sorted_sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
301    let key = "{tour}:z";
302
303    println!("zadd {}", db.zadd(key, &[("ada", 100.0), ("bob", 50.0)])?);
304    println!(
305        "geoadd {}",
306        db.geo_add(key, &[(13.361389, 38.115556, "Palermo")])?
307    );
308    println!(
309        "geosearch {:?}",
310        db.geo_search(key, 13.36, 38.11, 20.0, "km")?
311    );
312    let greater = SortedSetAddOptions {
313        greater_than: true,
314        changed: true,
315        ..SortedSetAddOptions::default()
316    };
317
318    println!(
319        "zadd_with {}",
320        db.zadd_with(key, greater, &[("bob", 10.0)])?
321    );
322    println!("zincr_by {}", db.zincr_by(key, "bob", 5.5)?);
323    println!(
324        "zadd_incr {:?}",
325        db.zadd_incr(key, "cy", 1.0, SortedSetAddOptions::default())?
326    );
327    println!("zrange {:?}", db.zrange(key, 0, -1)?);
328    println!("zrevrange {:?}", db.zrevrange(key, 0, 0)?);
329    println!("zrange_with_scores {:?}", db.zrange_with_scores(key, 0, 0)?);
330    println!(
331        "zrevrange_with_scores {:?}",
332        db.zrevrange_with_scores(key, 0, 0)?
333    );
334    println!(
335        "zrange_by_score {:?}",
336        db.zrange_by_score_with_scores(key, "(1", "+inf")?
337    );
338    println!("zscore {:?}", db.zscore(key, "ada")?);
339    println!("zrank {:?}", db.zrank(key, "ada")?);
340    println!("zrevrank {:?}", db.zrevrank(key, "ada")?);
341    println!("zrem {}", db.zrem(key, &["cy"])?);
342    println!("zcard {}", db.zcard(key)?);
343
344    let queue = "{tour}:zq";
345
346    db.zadd(
347        queue,
348        &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0), ("e", 5.0)],
349    )?;
350    println!("zpopmin {:?}", db.zpopmin(queue, 1)?);
351    println!("zpopmax {:?}", db.zpopmax(queue, 1)?);
352    println!(
353        "bzpopmin {:?}",
354        db.bzpopmin(&[queue], Duration::from_secs(1))?
355    );
356    println!(
357        "bzpopmax {:?}",
358        db.bzpopmax(&[queue], Duration::from_secs(1))?
359    );
360    db.zadd(queue, &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("x", 0.0)])?;
361    println!("zremrangebyrank {}", db.zremrangebyrank(queue, 0, 0)?);
362    println!(
363        "zremrangebyscore {}",
364        db.zremrangebyscore(queue, "(1", "2")?
365    );
366    println!("zremrangebylex {}", db.zremrangebylex(queue, "-", "+")?);
367
368    Ok(())
369}
370
371fn bloom(db: &mut Client) -> Result<(), ruvio_client::Error> {
372    db.bf_reserve("{tour}:bf", 0.01, 1000)?;
373    println!("bf_add {}", db.bf_add("{tour}:bf", "x")?);
374    println!(
375        "bf_exists {} {}",
376        db.bf_exists("{tour}:bf", "x")?,
377        db.bf_exists("{tour}:bf", "y")?
378    );
379
380    Ok(())
381}
382
383fn streams(db: &mut Client) -> Result<(), ruvio_client::Error> {
384    let key = "{tour}:stream";
385    let first = db.xadd(key, "*", &[("f", "1")])?;
386
387    db.xadd(key, "*", &[("f", "2")])?;
388    println!(
389        "xadd_maxlen {}",
390        db.xadd_maxlen(key, 10, "*", &[("f", "3")])?
391    );
392    println!(
393        "xadd_delay {}",
394        db.xadd_delay(key, 60_000, "*", &[("f", "later")])?
395    );
396    println!("xlen {}", db.xlen(key)?);
397    println!("xrange {}", db.xrange(key, "-", "+", None)?[0].id);
398    println!(
399        "xrevrange {}",
400        db.xrevrange(key, "+", "-", Some(1))?[0].fields[0].1
401    );
402    let read = db.xread(
403        &StreamReadOptions {
404            count: Some(2),
405            ..StreamReadOptions::default()
406        },
407        &[(key, "0")],
408    )?;
409
410    println!("xread {}", read[0].entries.len());
411    db.xgroup_create(key, "g", "0", false)?;
412    db.xgroup_create("{tour}:fresh", "g", "$", true)?;
413    let delivered = db.xreadgroup("g", "c1", &StreamReadOptions::default(), &[(key, ">")])?;
414
415    println!("xreadgroup {}", delivered[0].entries.len());
416    let pending = db.xpending(key, "g", "-", "+", 10, &StreamPendingFilter::default())?;
417
418    println!(
419        "xpending {} summary-array {}",
420        pending.len(),
421        db.xpending_summary(key, "g")?.as_array().is_some()
422    );
423    let claimed = db.xclaim(
424        key,
425        "g",
426        "c2",
427        Duration::ZERO,
428        &[&first],
429        &StreamClaimOptions::default(),
430    )?;
431
432    println!("xclaim {}", claimed[0].id);
433    println!(
434        "xclaim_ids {:?}",
435        db.xclaim_ids(
436            key,
437            "g",
438            "c2",
439            Duration::ZERO,
440            &[&first],
441            &StreamClaimOptions::default()
442        )?
443    );
444    println!("xack {}", db.xack(key, "g", &[&first])?);
445    println!(
446        "xgroup_delconsumer {}",
447        db.xgroup_delconsumer(key, "g", "c1")?
448    );
449    db.xgroup_setid(key, "g", "0")?;
450    println!("xgroup_destroy {}", db.xgroup_destroy(key, "g")?);
451    println!("xdel {}", db.xdel(key, &[&first])?);
452    println!("xtrim {}", db.xtrim_maxlen(key, 1)?);
453
454    Ok(())
455}
456
457fn transactions(db: &mut Client) -> Result<(), ruvio_client::Error> {
458    db.watch_key("{tour}:w")?;
459    db.watch(&["{tour}:w"])?;
460    db.multi()?;
461    db.execute(&["SET", "{tour}:w", "1"])?;
462    db.execute(&["INCR", "{tour}:w"])?;
463    println!(
464        "exec {} replies",
465        db.exec()?.map(|replies| replies.len()).unwrap_or(0)
466    );
467    db.unwatch()?;
468    db.multi()?;
469    db.discard()?;
470    println!(
471        "eval {:?}",
472        db.eval("return ARGV[1]", &[], &["hi"])?.as_string()?
473    );
474    let sha = db.script_load("return ruvio.call('GET', KEYS[1])")?;
475
476    println!("script_exists {:?}", db.script_exists(&[&sha, "0000"])?);
477    println!(
478        "evalsha {:?}",
479        db.evalsha(&sha, &["{tour}:w"], &[])?.as_string()?
480    );
481    db.function_load("tour_echo", "return ARGV[1]")?;
482    println!(
483        "fcall {:?}",
484        db.fcall("tour_echo", &[], &["x"])?.as_string()?
485    );
486    println!(
487        "function_list array {}",
488        db.function_list()?.as_array().is_some()
489    );
490    println!("function_delete {}", db.function_delete("tour_echo")?);
491    db.script_flush()?;
492    match db.script_kill() {
493        Ok(()) => println!("script_kill ok"),
494        Err(error) => println!("script_kill {error}"),
495    }
496
497    if !db.is_cluster() {
498        db.set("{tour}:move", "v")?;
499        println!("move {}", db.move_key("{tour}:move", 14)?);
500        db.swapdb(14, 15)?;
501        println!("swapdb back");
502        db.swapdb(14, 15)?;
503    }
504
505    Ok(())
506}
507
508fn server(db: &mut Client) -> Result<(), ruvio_client::Error> {
509    println!("ping {}", db.ping()?);
510    println!("ping_message {}", db.ping_message("tour")?);
511    println!("info has ruvio {}", db.info(None)?.contains("ruvio"));
512    println!("info server {}", db.info(Some("server"))?.len());
513    println!("config_get {}", db.config_get("databases")?.len());
514    println!("whoami {}", db.acl_whoami()?);
515    println!("acl_users {:?}", db.acl_users()?);
516    println!("acl_list {}", db.acl_list()?.len());
517    println!("acl_cat {}", db.acl_cat()?.len());
518    println!("acl_getuser null {}", db.acl_getuser("default")?.is_null());
519    db.acl_setuser("tour-reader", &["on", "~{tour}:*", "+get"])?;
520    db.client_setname("ruvio-tour")?;
521    println!("client_getname {:?}", db.client_getname()?);
522    db.client_tracking(false)?;
523    println!("cluster_keyslot {}", db.cluster_keyslot("{tour}")?);
524
525    if db.is_cluster() {
526        println!(
527            "cluster_nodes {}",
528            db.cluster_nodes()?.chars().take(40).collect::<String>()
529        );
530        println!(
531            "cluster_slots array {}",
532            db.cluster_slots()?.as_array().is_some()
533        );
534        println!(
535            "cluster_shards array {}",
536            db.cluster_shards()?.as_array().is_some()
537        );
538        println!("cluster_info {}", db.cluster_info()?.len());
539        println!("cluster_myid {}", db.cluster_myid()?);
540        db.readonly()?;
541        db.readwrite()?;
542    }
543
544    db.save()?;
545    db.bgsave()?;
546    println!("hello array {}", db.hello(2)?.as_array().is_some());
547    db.execute_many(&[&["PING"], &["PING"]])?;
548
549    Ok(())
550}
551
552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

pub fn connect_database( host: impl Into<String>, port: u16, database: u32, ) -> Result<Self, Error>

Opens a connection bound to one logical database. Sends SELECT when database is not 0.

The returned client is the database handle: every command on it runs in database.

Source

pub fn connect_ip(ip: IpAddr, port: u16, database: u32) -> Result<Self, Error>

Opens a connection to an IP address and port. Sends SELECT when database is not 0.

Source

pub fn connect_addr(address: SocketAddr, database: u32) -> Result<Self, Error>

Opens a connection to a socket address. Sends SELECT when database is not 0.

Source

pub fn connect_with(options: ClientOptions) -> Result<Self, Error>

17fn main() -> Result<(), ruvio_client::Error> {
18    let host = std::env::args()
19        .nth(1)
20        .unwrap_or_else(|| "127.0.0.1".to_owned());
21    let port = std::env::args()
22        .nth(2)
23        .and_then(|text| text.parse().ok())
24        .unwrap_or(6379);
25    let mut db = Client::connect(&host, port)?;
26
27    db.on_connection_lost(|notice| {
28        println!(
29            "connection lost {}:{} subscriber={}",
30            notice.host, notice.port, notice.subscriber
31        );
32    });
33
34    db.on_connection_restored(|notice| {
35        println!(
36            "connection restored {}:{} subscriber={}",
37            notice.host, notice.port, notice.subscriber
38        );
39    });
40
41    db.set_reconnect_delay(|attempt| {
42        if attempt >= 8 {
43            None
44        } else {
45            Some(Duration::from_millis(100 * 2u64.pow(attempt - 1)))
46        }
47    });
48
49    println!(
50        "connected cluster={} shards={} slot={}",
51        db.is_cluster(),
52        db.shard_count(),
53        ruvio_client::hash_slot("{tour}")
54    );
55    println!("reconnect armed; the command that sees a drop fails, the next one opens the socket");
56
57    if !db.is_cluster() {
58        db.select(15)?;
59        db.flushdb()?;
60        println!("selected database {}", db.database());
61    }
62
63    strings(&mut db)?;
64    owned(&mut db)?;
65    lists(&mut db)?;
66    sets(&mut db)?;
67    hashes(&mut db)?;
68    sorted_sets(&mut db)?;
69    bloom(&mut db)?;
70    streams(&mut db)?;
71    transactions(&mut db)?;
72    server(&mut db)?;
73    pubsub(&host, port)?;
74
75    println!("tour finished");
76
77    Ok(())
78}

Source

pub fn into_database(self, database: u32) -> Result<Self, Error>

Sends SELECT and returns the same connection.

This is not a second TCP socket: every later command on the client uses the new database.

Source

pub fn set_read_timeout( &mut self, timeout: Option<Duration>, ) -> Result<(), Error>

Sets how long a read may block. None waits forever.

A timed-out read returns Error::Io, and the reply may still arrive later, so drop the client unless it was only waiting in Self::read_message.

Examples found in repository ?

examples/tour.rs (line 558)

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

pub fn get(&mut self, key: &str) -> Result<Option<Vec<u8>>, Error>

80fn strings(db: &mut Client) -> Result<(), ruvio_client::Error> {
81    let key = "{tour}:s";
82
83    db.set(key, "hello")?;
84    println!("get {:?}", db.get_string(key)?);
85    db.set_with(key, "nx", None, SetMode::IfNotExists)?;
86    db.set_expires_at(
87        key,
88        "later",
89        SystemTime::now() + Duration::from_secs(120),
90        SetMode::Always,
91    )?;
92    db.set_keep_ttl(key, "kept", SetMode::Always)?;
93    println!(
94        "set_and_get {:?}",
95        db.set_and_get(key, "now", None, SetMode::Always)?
96    );
97    db.mset(&[("{tour}:a", "1"), ("{tour}:b", "2")])?;
98    println!(
99        "mget {:?}",
100        db.mget(&["{tour}:a", "{tour}:missing", "{tour}:b"])?
101    );
102    println!("getset {:?}", db.getset(key, "10")?);
103    println!("append {}", db.append(key, "0")?);
104    println!("strlen {}", db.strlen(key)?);
105    println!("incr {}", db.incr("{tour}:n")?);
106    println!("incr_by {}", db.incr_by("{tour}:n", 5)?);
107    println!("decr {}", db.decr("{tour}:n")?);
108    println!("decr_by {}", db.decr_by("{tour}:n", 2)?);
109    println!("exists {}", db.exists(&["{tour}:a", "{tour}:b"])?);
110    println!("exists_key {}", db.exists_key(key)?);
111    println!("type {}", db.key_type(key)?);
112    db.rename("{tour}:b", "{tour}:c")?;
113    println!("unlink {}", db.unlink(&["{tour}:c"])?);
114    println!("unlink_key {}", db.unlink_key("{tour}:gone")?);
115    db.expire(key, Duration::from_secs(30))?;
116    db.pexpire("{tour}:a", Duration::from_millis(30_000))?;
117    db.expire_at("{tour}:a", SystemTime::now() + Duration::from_secs(60))?;
118    println!("ttl {} pttl {}", db.ttl(key)?, db.pttl(key)?);
119    println!("persist {}", db.persist(key)?);
120    let page = db.scan(0, Some("{tour}:*"), Some(20))?;
121
122    println!("scan cursor={} keys={}", page.cursor, page.keys.len());
123    println!("dbsize {}", db.dbsize()?);
124    println!("del {}", db.del(&["{tour}:a"])?);
125    println!("del_key {}", db.del_key("{tour}:n")?);
126
127    Ok(())
128}

Source

pub fn read_message(&mut self) -> Result<RespValue, Error>

17fn main() -> Result<(), ruvio_client::Error> {
18    let host = std::env::args()
19        .nth(1)
20        .unwrap_or_else(|| "127.0.0.1".to_owned());
21    let port = std::env::args()
22        .nth(2)
23        .and_then(|text| text.parse().ok())
24        .unwrap_or(6379);
25    let mut db = Client::connect(&host, port)?;
26
27    db.on_connection_lost(|notice| {
28        println!(
29            "connection lost {}:{} subscriber={}",
30            notice.host, notice.port, notice.subscriber
31        );
32    });
33
34    db.on_connection_restored(|notice| {
35        println!(
36            "connection restored {}:{} subscriber={}",
37            notice.host, notice.port, notice.subscriber
38        );
39    });
40
41    db.set_reconnect_delay(|attempt| {
42        if attempt >= 8 {
43            None
44        } else {
45            Some(Duration::from_millis(100 * 2u64.pow(attempt - 1)))
46        }
47    });
48
49    println!(
50        "connected cluster={} shards={} slot={}",
51        db.is_cluster(),
52        db.shard_count(),
53        ruvio_client::hash_slot("{tour}")
54    );
55    println!("reconnect armed; the command that sees a drop fails, the next one opens the socket");
56
57    if !db.is_cluster() {
58        db.select(15)?;
59        db.flushdb()?;
60        println!("selected database {}", db.database());
61    }
62
63    strings(&mut db)?;
64    owned(&mut db)?;
65    lists(&mut db)?;
66    sets(&mut db)?;
67    hashes(&mut db)?;
68    sorted_sets(&mut db)?;
69    bloom(&mut db)?;
70    streams(&mut db)?;
71    transactions(&mut db)?;
72    server(&mut db)?;
73    pubsub(&host, port)?;
74
75    println!("tour finished");
76
77    Ok(())
78}

Source

pub fn reconnect(&mut self) -> Result<(), Error>

Examples found in repository ?

examples/tour.rs (line 100)

80fn strings(db: &mut Client) -> Result<(), ruvio_client::Error> {
81    let key = "{tour}:s";
82
83    db.set(key, "hello")?;
84    println!("get {:?}", db.get_string(key)?);
85    db.set_with(key, "nx", None, SetMode::IfNotExists)?;
86    db.set_expires_at(
87        key,
88        "later",
89        SystemTime::now() + Duration::from_secs(120),
90        SetMode::Always,
91    )?;
92    db.set_keep_ttl(key, "kept", SetMode::Always)?;
93    println!(
94        "set_and_get {:?}",
95        db.set_and_get(key, "now", None, SetMode::Always)?
96    );
97    db.mset(&[("{tour}:a", "1"), ("{tour}:b", "2")])?;
98    println!(
99        "mget {:?}",
100        db.mget(&["{tour}:a", "{tour}:missing", "{tour}:b"])?
101    );
102    println!("getset {:?}", db.getset(key, "10")?);
103    println!("append {}", db.append(key, "0")?);
104    println!("strlen {}", db.strlen(key)?);
105    println!("incr {}", db.incr("{tour}:n")?);
106    println!("incr_by {}", db.incr_by("{tour}:n", 5)?);
107    println!("decr {}", db.decr("{tour}:n")?);
108    println!("decr_by {}", db.decr_by("{tour}:n", 2)?);
109    println!("exists {}", db.exists(&["{tour}:a", "{tour}:b"])?);
110    println!("exists_key {}", db.exists_key(key)?);
111    println!("type {}", db.key_type(key)?);
112    db.rename("{tour}:b", "{tour}:c")?;
113    println!("unlink {}", db.unlink(&["{tour}:c"])?);
114    println!("unlink_key {}", db.unlink_key("{tour}:gone")?);
115    db.expire(key, Duration::from_secs(30))?;
116    db.pexpire("{tour}:a", Duration::from_millis(30_000))?;
117    db.expire_at("{tour}:a", SystemTime::now() + Duration::from_secs(60))?;
118    println!("ttl {} pttl {}", db.ttl(key)?, db.pttl(key)?);
119    println!("persist {}", db.persist(key)?);
120    let page = db.scan(0, Some("{tour}:*"), Some(20))?;
121
122    println!("scan cursor={} keys={}", page.cursor, page.keys.len());
123    println!("dbsize {}", db.dbsize()?);
124    println!("del {}", db.del(&["{tour}:a"])?);
125    println!("del_key {}", db.del_key("{tour}:n")?);
126
127    Ok(())
128}

Source

pub fn limit( &mut self, key: &str, max: u64, window_ms: u64, ) -> Result<Option<i64>, Error>

Sends LIMIT. None means this call did not fit in the window. Some is how many calls remain after this one.

Examples found in repository ?

examples/tour.rs (line 175)

130fn owned(db: &mut Client) -> Result<(), ruvio_client::Error> {
131    let first = db.lease("{tour}:lock", 30_000)?;
132
133    println!(
134        "lease {:?} held {:?} release {}",
135        first,
136        db.lease("{tour}:lock", 30_000)?,
137        db.release("{tour}:lock", first.unwrap_or(0) as u64)?
138    );
139    let permit = db.semaphore("{tour}:workers", 1, 30_000)?;
140
141    println!(
142        "semaphore {:?} full {:?} release {}",
143        permit,
144        db.semaphore("{tour}:workers", 1, 30_000)?,
145        db.release("{tour}:workers", permit.unwrap_or(0) as u64)?
146    );
147    println!(
148        "incr_by_max {:?} over {:?}",
149        db.incr_by_max("{tour}:seats", 3, 4)?,
150        db.incr_by_max("{tour}:seats", 2, 4)?
151    );
152    let created = db.setv("{tour}:doc", "12", None)?;
153    let next = db.setv("{tour}:doc", "11", Some(created as u64))?;
154
155    println!("setv {created} then {next}");
156    println!(
157        "setv mismatch {}",
158        db.setv("{tour}:doc", "10", Some(created as u64))
159            .err()
160            .map(|error| error.to_string())
161            .unwrap_or_else(|| "accepted".to_owned())
162    );
163    let cursor = db.changes_start()?;
164
165    db.set("{tour}:note", "paid")?;
166    let notes = db.changes(cursor as u64)?;
167
168    println!(
169        "changes cursor={cursor} notes={} {}",
170        notes.len(),
171        notes.first().map(|(_, text)| text.as_str()).unwrap_or("")
172    );
173    println!(
174        "limit {:?} {:?}",
175        db.limit("{tour}:login", 2, 60_000)?,
176        db.limit("{tour}:login", 2, 60_000)?
177    );
178    println!(
179        "once {} {}",
180        db.once("{tour}:pay", 60_000)?,
181        db.once("{tour}:pay", 60_000)?
182    );
183    db.set("{tour}:seats", "5")?;
184    println!(
185        "take {:?} {:?}",
186        db.take("{tour}:seats", 2)?,
187        db.take("{tour}:seats", 9)?
188    );
189    println!("getex {:?}", db.getex("{tour}:seats", 60_000)?);
190
191    Ok(())
192}

Source

pub fn once(&mut self, key: &str, ttl_ms: u64) -> Result<i64, Error>

Sends ONCE. 1 is the first call. 0 means the key is already taken.

Examples found in repository ?

examples/tour.rs (line 180)

130fn owned(db: &mut Client) -> Result<(), ruvio_client::Error> {
131    let first = db.lease("{tour}:lock", 30_000)?;
132
133    println!(
134        "lease {:?} held {:?} release {}",
135        first,
136        db.lease("{tour}:lock", 30_000)?,
137        db.release("{tour}:lock", first.unwrap_or(0) as u64)?
138    );
139    let permit = db.semaphore("{tour}:workers", 1, 30_000)?;
140
141    println!(
142        "semaphore {:?} full {:?} release {}",
143        permit,
144        db.semaphore("{tour}:workers", 1, 30_000)?,
145        db.release("{tour}:workers", permit.unwrap_or(0) as u64)?
146    );
147    println!(
148        "incr_by_max {:?} over {:?}",
149        db.incr_by_max("{tour}:seats", 3, 4)?,
150        db.incr_by_max("{tour}:seats", 2, 4)?
151    );
152    let created = db.setv("{tour}:doc", "12", None)?;
153    let next = db.setv("{tour}:doc", "11", Some(created as u64))?;
154
155    println!("setv {created} then {next}");
156    println!(
157        "setv mismatch {}",
158        db.setv("{tour}:doc", "10", Some(created as u64))
159            .err()
160            .map(|error| error.to_string())
161            .unwrap_or_else(|| "accepted".to_owned())
162    );
163    let cursor = db.changes_start()?;
164
165    db.set("{tour}:note", "paid")?;
166    let notes = db.changes(cursor as u64)?;
167
168    println!(
169        "changes cursor={cursor} notes={} {}",
170        notes.len(),
171        notes.first().map(|(_, text)| text.as_str()).unwrap_or("")
172    );
173    println!(
174        "limit {:?} {:?}",
175        db.limit("{tour}:login", 2, 60_000)?,
176        db.limit("{tour}:login", 2, 60_000)?
177    );
178    println!(
179        "once {} {}",
180        db.once("{tour}:pay", 60_000)?,
181        db.once("{tour}:pay", 60_000)?
182    );
183    db.set("{tour}:seats", "5")?;
184    println!(
185        "take {:?} {:?}",
186        db.take("{tour}:seats", 2)?,
187        db.take("{tour}:seats", 9)?
188    );
189    println!("getex {:?}", db.getex("{tour}:seats", 60_000)?);
190
191    Ok(())
192}

Source

pub fn idempotency_begin( &mut self, key: &str, fingerprint: &str, owner: &str, ttl_ms: u64, ) -> Result<RespValue, Error>

Native reservation: [acquired], [pending], [conflict], or [completed, binary result].

Source

pub fn idempotency_complete( &mut self, key: &str, fingerprint: &str, owner: &str, result: &str, ) -> Result<i64, Error>

194fn lists(db: &mut Client) -> Result<(), ruvio_client::Error> {
195    let key = "{tour}:l";
196
197    println!("rpush {}", db.rpush(key, &["a", "b", "c", "d"])?);
198    println!("lpush {}", db.lpush(key, &["z"])?);
199    println!("lpop {:?}", db.lpop(key)?);
200    println!("rpop_count {:?}", db.rpop_count(key, 2)?);
201    println!("llen {}", db.llen(key)?);
202    println!("lindex {:?}", db.lindex(key, 0)?);
203    println!("lrange {:?}", db.lrange(key, 0, -1)?);
204    db.ltrim(key, 0, 0)?;
205    println!("lpop_count {:?}", db.lpop_count(key, 1)?);
206    db.rpush(key, &["only"])?;
207    println!("blpop {:?}", db.blpop_key(key, Duration::from_millis(200))?);
208    db.rpush(key, &["right"])?;
209    println!("brpop {:?}", db.brpop(&[key], Duration::from_millis(200))?);
210    println!(
211        "brpop empty {:?}",
212        db.brpop_key(key, Duration::from_millis(1))?
213    );
214
215    Ok(())
216}

Source

pub fn rpop(&mut self, key: &str) -> Result<Option<String>, Error>

194fn lists(db: &mut Client) -> Result<(), ruvio_client::Error> {
195    let key = "{tour}:l";
196
197    println!("rpush {}", db.rpush(key, &["a", "b", "c", "d"])?);
198    println!("lpush {}", db.lpush(key, &["z"])?);
199    println!("lpop {:?}", db.lpop(key)?);
200    println!("rpop_count {:?}", db.rpop_count(key, 2)?);
201    println!("llen {}", db.llen(key)?);
202    println!("lindex {:?}", db.lindex(key, 0)?);
203    println!("lrange {:?}", db.lrange(key, 0, -1)?);
204    db.ltrim(key, 0, 0)?;
205    println!("lpop_count {:?}", db.lpop_count(key, 1)?);
206    db.rpush(key, &["only"])?;
207    println!("blpop {:?}", db.blpop_key(key, Duration::from_millis(200))?);
208    db.rpush(key, &["right"])?;
209    println!("brpop {:?}", db.brpop(&[key], Duration::from_millis(200))?);
210    println!(
211        "brpop empty {:?}",
212        db.brpop_key(key, Duration::from_millis(1))?
213    );
214
215    Ok(())
216}

Source

pub fn blpop( &mut self, keys: &[&str], timeout: Duration, ) -> Result<Option<(String, String)>, Error>

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hexpire( &mut self, key: &str, ttl: Duration, fields: &[&str], ) -> Result<Vec<i64>, Error>

Sets a TTL on hash fields. Sends HEXPIRE for whole seconds, otherwise HPEXPIRE. One reply per field: 1 set, 0 condition not met, 2 deleted by a zero TTL, -2 no such field or key.

db.hset("session:42", &[("token", "abc"), ("user", "ada")])?;
db.hexpire("session:42", Duration::from_secs(900), &["token"])?;

Examples found in repository ?

examples/tour.rs (line 271)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hexpire_with( &mut self, key: &str, ttl: Duration, condition: FieldExpireCondition, fields: &[&str], ) -> Result<Vec<i64>, Error>

Like Client::hexpire with NX, XX, GT, or LT.

Examples found in repository ?

examples/tour.rs (lines 275-280)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hpexpire( &mut self, key: &str, ttl: Duration, fields: &[&str], ) -> Result<Vec<i64>, Error>

Sends HPEXPIRE: a TTL in milliseconds on hash fields.

Examples found in repository ?

examples/tour.rs (line 284)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hexpire_at( &mut self, key: &str, when: SystemTime, fields: &[&str], ) -> Result<Vec<i64>, Error>

Sets an absolute deadline on hash fields. Sends HEXPIREAT for a whole second, otherwise HPEXPIREAT. A time in the past deletes the field (reply 2).

Examples found in repository ?

examples/tour.rs (line 290)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn httl(&mut self, key: &str, fields: &[&str]) -> Result<Vec<i64>, Error>

Sends HTTL: seconds left per field, -1 without a TTL, -2 when missing.

Examples found in repository ?

examples/tour.rs (line 286)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hpttl(&mut self, key: &str, fields: &[&str]) -> Result<Vec<i64>, Error>

Sends HPTTL: milliseconds left per field, -1 without a TTL, -2 when missing.

Examples found in repository ?

examples/tour.rs (line 287)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hexpiretime( &mut self, key: &str, fields: &[&str], ) -> Result<Vec<i64>, Error>

Sends HEXPIRETIME: the Unix second each field expires at, -1 or -2 as HTTL.

Examples found in repository ?

examples/tour.rs (line 292)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hpexpiretime( &mut self, key: &str, fields: &[&str], ) -> Result<Vec<i64>, Error>

Sends HPEXPIRETIME: the Unix millisecond each field expires at.

Examples found in repository ?

examples/tour.rs (line 293)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hpersist( &mut self, key: &str, fields: &[&str], ) -> Result<Vec<i64>, Error>

Sends HPERSIST: 1 removed a TTL, -1 the field had none, -2 it is missing.

Examples found in repository ?

examples/tour.rs (line 294)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn hscan( &mut self, key: &str, cursor: u64, pattern: Option<&str>, count: Option<u64>, ) -> Result<HashScanPage, Error>

Sends HSCAN with an optional MATCH pattern and COUNT hint.

Examples found in repository ?

examples/tour.rs (line 266)

252fn hashes(db: &mut Client) -> Result<(), ruvio_client::Error> {
253    let key = "{tour}:h";
254
255    println!("hset {}", db.hset(key, &[("f1", "1"), ("f2", "two")])?);
256    println!("hget {:?}", db.hget(key, "f2")?);
257    println!("hincr_by {}", db.hincr_by(key, "f1", 4)?);
258    println!("hsetnx {}", db.hsetnx(key, "f1", "9")?);
259    println!("hstrlen {}", db.hstrlen(key, "f2")?);
260    println!("hlen {}", db.hlen(key)?);
261    println!("hexists {}", db.hexists(key, "f1")?);
262    println!("hkeys {:?}", db.hkeys(key)?);
263    println!("hvals {:?}", db.hvals(key)?);
264    println!("hgetall {:?}", db.hgetall(key)?);
265    println!("hmget {:?}", db.hmget(key, &["f2", "nope"])?);
266    let page = db.hscan(key, 0, Some("f*"), Some(10))?;
267
268    println!("hscan cursor={} fields={}", page.cursor, page.fields.len());
269    println!(
270        "hexpire {:?}",
271        db.hexpire(key, Duration::from_secs(60), &["f1", "nope"])?
272    );
273    println!(
274        "hexpire_with GT {:?}",
275        db.hexpire_with(
276            key,
277            Duration::from_secs(120),
278            FieldExpireCondition::IfGreater,
279            &["f1"]
280        )?
281    );
282    println!(
283        "hpexpire {:?}",
284        db.hpexpire(key, Duration::from_millis(90_500), &["f2"])?
285    );
286    println!("httl {:?}", db.httl(key, &["f1", "f2"])?);
287    println!("hpttl {:?}", db.hpttl(key, &["f1"])?);
288    println!(
289        "hexpire_at {:?}",
290        db.hexpire_at(key, SystemTime::now() + Duration::from_secs(300), &["f2"])?
291    );
292    println!("hexpiretime {:?}", db.hexpiretime(key, &["f2"])?);
293    println!("hpexpiretime {:?}", db.hpexpiretime(key, &["f2"])?);
294    println!("hpersist {:?}", db.hpersist(key, &["f1", "f2"])?);
295    println!("hdel {}", db.hdel(key, &["f1"])?);
296
297    Ok(())
298}

Source

pub fn zadd(&mut self, key: &str, entries: &[(&str, f64)]) -> Result<i64, Error>

Sends ZADD with (member, score) pairs and returns how many members were new.

db.zadd("board", &[("ada", 100.0), ("bob", 50.0)])?;

Examples found in repository ?

examples/tour.rs (line 303)

300fn sorted_sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
301    let key = "{tour}:z";
302
303    println!("zadd {}", db.zadd(key, &[("ada", 100.0), ("bob", 50.0)])?);
304    println!(
305        "geoadd {}",
306        db.geo_add(key, &[(13.361389, 38.115556, "Palermo")])?
307    );
308    println!(
309        "geosearch {:?}",
310        db.geo_search(key, 13.36, 38.11, 20.0, "km")?
311    );
312    let greater = SortedSetAddOptions {
313        greater_than: true,
314        changed: true,
315        ..SortedSetAddOptions::default()
316    };
317
318    println!(
319        "zadd_with {}",
320        db.zadd_with(key, greater, &[("bob", 10.0)])?
321    );
322    println!("zincr_by {}", db.zincr_by(key, "bob", 5.5)?);
323    println!(
324        "zadd_incr {:?}",
325        db.zadd_incr(key, "cy", 1.0, SortedSetAddOptions::default())?
326    );
327    println!("zrange {:?}", db.zrange(key, 0, -1)?);
328    println!("zrevrange {:?}", db.zrevrange(key, 0, 0)?);
329    println!("zrange_with_scores {:?}", db.zrange_with_scores(key, 0, 0)?);
330    println!(
331        "zrevrange_with_scores {:?}",
332        db.zrevrange_with_scores(key, 0, 0)?
333    );
334    println!(
335        "zrange_by_score {:?}",
336        db.zrange_by_score_with_scores(key, "(1", "+inf")?
337    );
338    println!("zscore {:?}", db.zscore(key, "ada")?);
339    println!("zrank {:?}", db.zrank(key, "ada")?);
340    println!("zrevrank {:?}", db.zrevrank(key, "ada")?);
341    println!("zrem {}", db.zrem(key, &["cy"])?);
342    println!("zcard {}", db.zcard(key)?);
343
344    let queue = "{tour}:zq";
345
346    db.zadd(
347        queue,
348        &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0), ("e", 5.0)],
349    )?;
350    println!("zpopmin {:?}", db.zpopmin(queue, 1)?);
351    println!("zpopmax {:?}", db.zpopmax(queue, 1)?);
352    println!(
353        "bzpopmin {:?}",
354        db.bzpopmin(&[queue], Duration::from_secs(1))?
355    );
356    println!(
357        "bzpopmax {:?}",
358        db.bzpopmax(&[queue], Duration::from_secs(1))?
359    );
360    db.zadd(queue, &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("x", 0.0)])?;
361    println!("zremrangebyrank {}", db.zremrangebyrank(queue, 0, 0)?);
362    println!(
363        "zremrangebyscore {}",
364        db.zremrangebyscore(queue, "(1", "2")?
365    );
366    println!("zremrangebylex {}", db.zremrangebylex(queue, "-", "+")?);
367
368    Ok(())
369}

Source

pub fn zadd_with( &mut self, key: &str, options: SortedSetAddOptions, entries: &[(&str, f64)], ) -> Result<i64, Error>

Sends ZADD with NX, XX, GT, LT, or CH. Without SortedSetAddOptions::changed the reply counts new members.

Examples found in repository ?

examples/tour.rs (line 320)

300fn sorted_sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
301    let key = "{tour}:z";
302
303    println!("zadd {}", db.zadd(key, &[("ada", 100.0), ("bob", 50.0)])?);
304    println!(
305        "geoadd {}",
306        db.geo_add(key, &[(13.361389, 38.115556, "Palermo")])?
307    );
308    println!(
309        "geosearch {:?}",
310        db.geo_search(key, 13.36, 38.11, 20.0, "km")?
311    );
312    let greater = SortedSetAddOptions {
313        greater_than: true,
314        changed: true,
315        ..SortedSetAddOptions::default()
316    };
317
318    println!(
319        "zadd_with {}",
320        db.zadd_with(key, greater, &[("bob", 10.0)])?
321    );
322    println!("zincr_by {}", db.zincr_by(key, "bob", 5.5)?);
323    println!(
324        "zadd_incr {:?}",
325        db.zadd_incr(key, "cy", 1.0, SortedSetAddOptions::default())?
326    );
327    println!("zrange {:?}", db.zrange(key, 0, -1)?);
328    println!("zrevrange {:?}", db.zrevrange(key, 0, 0)?);
329    println!("zrange_with_scores {:?}", db.zrange_with_scores(key, 0, 0)?);
330    println!(
331        "zrevrange_with_scores {:?}",
332        db.zrevrange_with_scores(key, 0, 0)?
333    );
334    println!(
335        "zrange_by_score {:?}",
336        db.zrange_by_score_with_scores(key, "(1", "+inf")?
337    );
338    println!("zscore {:?}", db.zscore(key, "ada")?);
339    println!("zrank {:?}", db.zrank(key, "ada")?);
340    println!("zrevrank {:?}", db.zrevrank(key, "ada")?);
341    println!("zrem {}", db.zrem(key, &["cy"])?);
342    println!("zcard {}", db.zcard(key)?);
343
344    let queue = "{tour}:zq";
345
346    db.zadd(
347        queue,
348        &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0), ("e", 5.0)],
349    )?;
350    println!("zpopmin {:?}", db.zpopmin(queue, 1)?);
351    println!("zpopmax {:?}", db.zpopmax(queue, 1)?);
352    println!(
353        "bzpopmin {:?}",
354        db.bzpopmin(&[queue], Duration::from_secs(1))?
355    );
356    println!(
357        "bzpopmax {:?}",
358        db.bzpopmax(&[queue], Duration::from_secs(1))?
359    );
360    db.zadd(queue, &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("x", 0.0)])?;
361    println!("zremrangebyrank {}", db.zremrangebyrank(queue, 0, 0)?);
362    println!(
363        "zremrangebyscore {}",
364        db.zremrangebyscore(queue, "(1", "2")?
365    );
366    println!("zremrangebylex {}", db.zremrangebylex(queue, "-", "+")?);
367
368    Ok(())
369}

Source

pub fn zadd_incr( &mut self, key: &str, member: &str, delta: f64, options: SortedSetAddOptions, ) -> Result<Option<f64>, Error>

Sends ZADD ... INCR. Returns the new score, or None when an option skipped the update.

Examples found in repository ?

examples/tour.rs (line 325)

300fn sorted_sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
301    let key = "{tour}:z";
302
303    println!("zadd {}", db.zadd(key, &[("ada", 100.0), ("bob", 50.0)])?);
304    println!(
305        "geoadd {}",
306        db.geo_add(key, &[(13.361389, 38.115556, "Palermo")])?
307    );
308    println!(
309        "geosearch {:?}",
310        db.geo_search(key, 13.36, 38.11, 20.0, "km")?
311    );
312    let greater = SortedSetAddOptions {
313        greater_than: true,
314        changed: true,
315        ..SortedSetAddOptions::default()
316    };
317
318    println!(
319        "zadd_with {}",
320        db.zadd_with(key, greater, &[("bob", 10.0)])?
321    );
322    println!("zincr_by {}", db.zincr_by(key, "bob", 5.5)?);
323    println!(
324        "zadd_incr {:?}",
325        db.zadd_incr(key, "cy", 1.0, SortedSetAddOptions::default())?
326    );
327    println!("zrange {:?}", db.zrange(key, 0, -1)?);
328    println!("zrevrange {:?}", db.zrevrange(key, 0, 0)?);
329    println!("zrange_with_scores {:?}", db.zrange_with_scores(key, 0, 0)?);
330    println!(
331        "zrevrange_with_scores {:?}",
332        db.zrevrange_with_scores(key, 0, 0)?
333    );
334    println!(
335        "zrange_by_score {:?}",
336        db.zrange_by_score_with_scores(key, "(1", "+inf")?
337    );
338    println!("zscore {:?}", db.zscore(key, "ada")?);
339    println!("zrank {:?}", db.zrank(key, "ada")?);
340    println!("zrevrank {:?}", db.zrevrank(key, "ada")?);
341    println!("zrem {}", db.zrem(key, &["cy"])?);
342    println!("zcard {}", db.zcard(key)?);
343
344    let queue = "{tour}:zq";
345
346    db.zadd(
347        queue,
348        &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0), ("e", 5.0)],
349    )?;
350    println!("zpopmin {:?}", db.zpopmin(queue, 1)?);
351    println!("zpopmax {:?}", db.zpopmax(queue, 1)?);
352    println!(
353        "bzpopmin {:?}",
354        db.bzpopmin(&[queue], Duration::from_secs(1))?
355    );
356    println!(
357        "bzpopmax {:?}",
358        db.bzpopmax(&[queue], Duration::from_secs(1))?
359    );
360    db.zadd(queue, &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("x", 0.0)])?;
361    println!("zremrangebyrank {}", db.zremrangebyrank(queue, 0, 0)?);
362    println!(
363        "zremrangebyscore {}",
364        db.zremrangebyscore(queue, "(1", "2")?
365    );
366    println!("zremrangebylex {}", db.zremrangebylex(queue, "-", "+")?);
367
368    Ok(())
369}

Source

pub fn zincr_by( &mut self, key: &str, member: &str, delta: f64, ) -> Result<f64, Error>

Sends ZINCRBY and returns the new score.

Examples found in repository ?

examples/tour.rs (line 322)

300fn sorted_sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
301    let key = "{tour}:z";
302
303    println!("zadd {}", db.zadd(key, &[("ada", 100.0), ("bob", 50.0)])?);
304    println!(
305        "geoadd {}",
306        db.geo_add(key, &[(13.361389, 38.115556, "Palermo")])?
307    );
308    println!(
309        "geosearch {:?}",
310        db.geo_search(key, 13.36, 38.11, 20.0, "km")?
311    );
312    let greater = SortedSetAddOptions {
313        greater_than: true,
314        changed: true,
315        ..SortedSetAddOptions::default()
316    };
317
318    println!(
319        "zadd_with {}",
320        db.zadd_with(key, greater, &[("bob", 10.0)])?
321    );
322    println!("zincr_by {}", db.zincr_by(key, "bob", 5.5)?);
323    println!(
324        "zadd_incr {:?}",
325        db.zadd_incr(key, "cy", 1.0, SortedSetAddOptions::default())?
326    );
327    println!("zrange {:?}", db.zrange(key, 0, -1)?);
328    println!("zrevrange {:?}", db.zrevrange(key, 0, 0)?);
329    println!("zrange_with_scores {:?}", db.zrange_with_scores(key, 0, 0)?);
330    println!(
331        "zrevrange_with_scores {:?}",
332        db.zrevrange_with_scores(key, 0, 0)?
333    );
334    println!(
335        "zrange_by_score {:?}",
336        db.zrange_by_score_with_scores(key, "(1", "+inf")?
337    );
338    println!("zscore {:?}", db.zscore(key, "ada")?);
339    println!("zrank {:?}", db.zrank(key, "ada")?);
340    println!("zrevrank {:?}", db.zrevrank(key, "ada")?);
341    println!("zrem {}", db.zrem(key, &["cy"])?);
342    println!("zcard {}", db.zcard(key)?);
343
344    let queue = "{tour}:zq";
345
346    db.zadd(
347        queue,
348        &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0), ("e", 5.0)],
349    )?;
350    println!("zpopmin {:?}", db.zpopmin(queue, 1)?);
351    println!("zpopmax {:?}", db.zpopmax(queue, 1)?);
352    println!(
353        "bzpopmin {:?}",
354        db.bzpopmin(&[queue], Duration::from_secs(1))?
355    );
356    println!(
357        "bzpopmax {:?}",
358        db.bzpopmax(&[queue], Duration::from_secs(1))?
359    );
360    db.zadd(queue, &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("x", 0.0)])?;
361    println!("zremrangebyrank {}", db.zremrangebyrank(queue, 0, 0)?);
362    println!(
363        "zremrangebyscore {}",
364        db.zremrangebyscore(queue, "(1", "2")?
365    );
366    println!("zremrangebylex {}", db.zremrangebylex(queue, "-", "+")?);
367
368    Ok(())
369}

Source

pub fn geo_add( &mut self, key: &str, places: &[(f64, f64, &str)], ) -> Result<i64, Error>

Sends GEOADD. Each place is longitude, latitude, then member.

Examples found in repository ?

examples/tour.rs (line 306)

300fn sorted_sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
301    let key = "{tour}:z";
302
303    println!("zadd {}", db.zadd(key, &[("ada", 100.0), ("bob", 50.0)])?);
304    println!(
305        "geoadd {}",
306        db.geo_add(key, &[(13.361389, 38.115556, "Palermo")])?
307    );
308    println!(
309        "geosearch {:?}",
310        db.geo_search(key, 13.36, 38.11, 20.0, "km")?
311    );
312    let greater = SortedSetAddOptions {
313        greater_than: true,
314        changed: true,
315        ..SortedSetAddOptions::default()
316    };
317
318    println!(
319        "zadd_with {}",
320        db.zadd_with(key, greater, &[("bob", 10.0)])?
321    );
322    println!("zincr_by {}", db.zincr_by(key, "bob", 5.5)?);
323    println!(
324        "zadd_incr {:?}",
325        db.zadd_incr(key, "cy", 1.0, SortedSetAddOptions::default())?
326    );
327    println!("zrange {:?}", db.zrange(key, 0, -1)?);
328    println!("zrevrange {:?}", db.zrevrange(key, 0, 0)?);
329    println!("zrange_with_scores {:?}", db.zrange_with_scores(key, 0, 0)?);
330    println!(
331        "zrevrange_with_scores {:?}",
332        db.zrevrange_with_scores(key, 0, 0)?
333    );
334    println!(
335        "zrange_by_score {:?}",
336        db.zrange_by_score_with_scores(key, "(1", "+inf")?
337    );
338    println!("zscore {:?}", db.zscore(key, "ada")?);
339    println!("zrank {:?}", db.zrank(key, "ada")?);
340    println!("zrevrank {:?}", db.zrevrank(key, "ada")?);
341    println!("zrem {}", db.zrem(key, &["cy"])?);
342    println!("zcard {}", db.zcard(key)?);
343
344    let queue = "{tour}:zq";
345
346    db.zadd(
347        queue,
348        &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0), ("e", 5.0)],
349    )?;
350    println!("zpopmin {:?}", db.zpopmin(queue, 1)?);
351    println!("zpopmax {:?}", db.zpopmax(queue, 1)?);
352    println!(
353        "bzpopmin {:?}",
354        db.bzpopmin(&[queue], Duration::from_secs(1))?
355    );
356    println!(
357        "bzpopmax {:?}",
358        db.bzpopmax(&[queue], Duration::from_secs(1))?
359    );
360    db.zadd(queue, &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("x", 0.0)])?;
361    println!("zremrangebyrank {}", db.zremrangebyrank(queue, 0, 0)?);
362    println!(
363        "zremrangebyscore {}",
364        db.zremrangebyscore(queue, "(1", "2")?
365    );
366    println!("zremrangebylex {}", db.zremrangebylex(queue, "-", "+")?);
367
368    Ok(())
369}

Source

pub fn geo_dist( &mut self, key: &str, from: &str, to: &str, unit: Option<&str>, ) -> Result<Option<f64>, Error>

Sends GEODIST. unit is m, km, ft, or mi. None asks for meters.

Source

pub fn geo_hash( &mut self, key: &str, members: &[&str], ) -> Result<Vec<Option<String>>, Error>

Sends GEOHASH. A missing member is None.

Source

pub fn geo_pos( &mut self, key: &str, members: &[&str], ) -> Result<Vec<Option<(f64, f64)>>, Error>

Sends GEOPOS. A missing member is None.

Source

pub fn geo_search( &mut self, key: &str, longitude: f64, latitude: f64, radius: f64, unit: &str, ) -> Result<Vec<String>, Error>

Sends GEOSEARCH ... FROMLONLAT ... BYRADIUS ... ASC.

Examples found in repository ?

examples/tour.rs (line 310)

300fn sorted_sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
301    let key = "{tour}:z";
302
303    println!("zadd {}", db.zadd(key, &[("ada", 100.0), ("bob", 50.0)])?);
304    println!(
305        "geoadd {}",
306        db.geo_add(key, &[(13.361389, 38.115556, "Palermo")])?
307    );
308    println!(
309        "geosearch {:?}",
310        db.geo_search(key, 13.36, 38.11, 20.0, "km")?
311    );
312    let greater = SortedSetAddOptions {
313        greater_than: true,
314        changed: true,
315        ..SortedSetAddOptions::default()
316    };
317
318    println!(
319        "zadd_with {}",
320        db.zadd_with(key, greater, &[("bob", 10.0)])?
321    );
322    println!("zincr_by {}", db.zincr_by(key, "bob", 5.5)?);
323    println!(
324        "zadd_incr {:?}",
325        db.zadd_incr(key, "cy", 1.0, SortedSetAddOptions::default())?
326    );
327    println!("zrange {:?}", db.zrange(key, 0, -1)?);
328    println!("zrevrange {:?}", db.zrevrange(key, 0, 0)?);
329    println!("zrange_with_scores {:?}", db.zrange_with_scores(key, 0, 0)?);
330    println!(
331        "zrevrange_with_scores {:?}",
332        db.zrevrange_with_scores(key, 0, 0)?
333    );
334    println!(
335        "zrange_by_score {:?}",
336        db.zrange_by_score_with_scores(key, "(1", "+inf")?
337    );
338    println!("zscore {:?}", db.zscore(key, "ada")?);
339    println!("zrank {:?}", db.zrank(key, "ada")?);
340    println!("zrevrank {:?}", db.zrevrank(key, "ada")?);
341    println!("zrem {}", db.zrem(key, &["cy"])?);
342    println!("zcard {}", db.zcard(key)?);
343
344    let queue = "{tour}:zq";
345
346    db.zadd(
347        queue,
348        &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0), ("e", 5.0)],
349    )?;
350    println!("zpopmin {:?}", db.zpopmin(queue, 1)?);
351    println!("zpopmax {:?}", db.zpopmax(queue, 1)?);
352    println!(
353        "bzpopmin {:?}",
354        db.bzpopmin(&[queue], Duration::from_secs(1))?
355    );
356    println!(
357        "bzpopmax {:?}",
358        db.bzpopmax(&[queue], Duration::from_secs(1))?
359    );
360    db.zadd(queue, &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("x", 0.0)])?;
361    println!("zremrangebyrank {}", db.zremrangebyrank(queue, 0, 0)?);
362    println!(
363        "zremrangebyscore {}",
364        db.zremrangebyscore(queue, "(1", "2")?
365    );
366    println!("zremrangebylex {}", db.zremrangebylex(queue, "-", "+")?);
367
368    Ok(())
369}

Source

pub fn geo_search_store( &mut self, destination: &str, source: &str, member: &str, radius: f64, unit: &str, ) -> Result<i64, Error>

Sends GEOSEARCHSTORE from a member and a radius. Returns how many members were stored.

Source

pub fn geo_radius_by_member( &mut self, key: &str, member: &str, radius: f64, unit: &str, ) -> Result<Vec<String>, Error>

Sends GEORADIUSBYMEMBER ... ASC.

Source

pub fn geo_radius( &mut self, key: &str, longitude: f64, latitude: f64, radius: f64, unit: &str, ) -> Result<Vec<String>, Error>

300fn sorted_sets(db: &mut Client) -> Result<(), ruvio_client::Error> {
301    let key = "{tour}:z";
302
303    println!("zadd {}", db.zadd(key, &[("ada", 100.0), ("bob", 50.0)])?);
304    println!(
305        "geoadd {}",
306        db.geo_add(key, &[(13.361389, 38.115556, "Palermo")])?
307    );
308    println!(
309        "geosearch {:?}",
310        db.geo_search(key, 13.36, 38.11, 20.0, "km")?
311    );
312    let greater = SortedSetAddOptions {
313        greater_than: true,
314        changed: true,
315        ..SortedSetAddOptions::default()
316    };
317
318    println!(
319        "zadd_with {}",
320        db.zadd_with(key, greater, &[("bob", 10.0)])?
321    );
322    println!("zincr_by {}", db.zincr_by(key, "bob", 5.5)?);
323    println!(
324        "zadd_incr {:?}",
325        db.zadd_incr(key, "cy", 1.0, SortedSetAddOptions::default())?
326    );
327    println!("zrange {:?}", db.zrange(key, 0, -1)?);
328    println!("zrevrange {:?}", db.zrevrange(key, 0, 0)?);
329    println!("zrange_with_scores {:?}", db.zrange_with_scores(key, 0, 0)?);
330    println!(
331        "zrevrange_with_scores {:?}",
332        db.zrevrange_with_scores(key, 0, 0)?
333    );
334    println!(
335        "zrange_by_score {:?}",
336        db.zrange_by_score_with_scores(key, "(1", "+inf")?
337    );
338    println!("zscore {:?}", db.zscore(key, "ada")?);
339    println!("zrank {:?}", db.zrank(key, "ada")?);
340    println!("zrevrank {:?}", db.zrevrank(key, "ada")?);
341    println!("zrem {}", db.zrem(key, &["cy"])?);
342    println!("zcard {}", db.zcard(key)?);
343
344    let queue = "{tour}:zq";
345
346    db.zadd(
347        queue,
348        &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("d", 4.0), ("e", 5.0)],
349    )?;
350    println!("zpopmin {:?}", db.zpopmin(queue, 1)?);
351    println!("zpopmax {:?}", db.zpopmax(queue, 1)?);
352    println!(
353        "bzpopmin {:?}",
354        db.bzpopmin(&[queue], Duration::from_secs(1))?
355    );
356    println!(
357        "bzpopmax {:?}",
358        db.bzpopmax(&[queue], Duration::from_secs(1))?
359    );
360    db.zadd(queue, &[("a", 1.0), ("b", 2.0), ("c", 3.0), ("x", 0.0)])?;
361    println!("zremrangebyrank {}", db.zremrangebyrank(queue, 0, 0)?);
362    println!(
363        "zremrangebyscore {}",
364        db.zremrangebyscore(queue, "(1", "2")?
365    );
366    println!("zremrangebylex {}", db.zremrangebylex(queue, "-", "+")?);
367
368    Ok(())
369}

Source

pub fn zrange_by_lex( &mut self, key: &str, min: &str, max: &str, ) -> Result<Vec<String>, Error>

371fn bloom(db: &mut Client) -> Result<(), ruvio_client::Error> {
372    db.bf_reserve("{tour}:bf", 0.01, 1000)?;
373    println!("bf_add {}", db.bf_add("{tour}:bf", "x")?);
374    println!(
375        "bf_exists {} {}",
376        db.bf_exists("{tour}:bf", "x")?,
377        db.bf_exists("{tour}:bf", "y")?
378    );
379
380    Ok(())
381}

Source

pub fn xadd_nomkstream( &mut self, key: &str, id: &str, fields: &[(&str, &str)], ) -> Result<Option<String>, Error>

383fn streams(db: &mut Client) -> Result<(), ruvio_client::Error> {
384    let key = "{tour}:stream";
385    let first = db.xadd(key, "*", &[("f", "1")])?;
386
387    db.xadd(key, "*", &[("f", "2")])?;
388    println!(
389        "xadd_maxlen {}",
390        db.xadd_maxlen(key, 10, "*", &[("f", "3")])?
391    );
392    println!(
393        "xadd_delay {}",
394        db.xadd_delay(key, 60_000, "*", &[("f", "later")])?
395    );
396    println!("xlen {}", db.xlen(key)?);
397    println!("xrange {}", db.xrange(key, "-", "+", None)?[0].id);
398    println!(
399        "xrevrange {}",
400        db.xrevrange(key, "+", "-", Some(1))?[0].fields[0].1
401    );
402    let read = db.xread(
403        &StreamReadOptions {
404            count: Some(2),
405            ..StreamReadOptions::default()
406        },
407        &[(key, "0")],
408    )?;
409
410    println!("xread {}", read[0].entries.len());
411    db.xgroup_create(key, "g", "0", false)?;
412    db.xgroup_create("{tour}:fresh", "g", "$", true)?;
413    let delivered = db.xreadgroup("g", "c1", &StreamReadOptions::default(), &[(key, ">")])?;
414
415    println!("xreadgroup {}", delivered[0].entries.len());
416    let pending = db.xpending(key, "g", "-", "+", 10, &StreamPendingFilter::default())?;
417
418    println!(
419        "xpending {} summary-array {}",
420        pending.len(),
421        db.xpending_summary(key, "g")?.as_array().is_some()
422    );
423    let claimed = db.xclaim(
424        key,
425        "g",
426        "c2",
427        Duration::ZERO,
428        &[&first],
429        &StreamClaimOptions::default(),
430    )?;
431
432    println!("xclaim {}", claimed[0].id);
433    println!(
434        "xclaim_ids {:?}",
435        db.xclaim_ids(
436            key,
437            "g",
438            "c2",
439            Duration::ZERO,
440            &[&first],
441            &StreamClaimOptions::default()
442        )?
443    );
444    println!("xack {}", db.xack(key, "g", &[&first])?);
445    println!(
446        "xgroup_delconsumer {}",
447        db.xgroup_delconsumer(key, "g", "c1")?
448    );
449    db.xgroup_setid(key, "g", "0")?;
450    println!("xgroup_destroy {}", db.xgroup_destroy(key, "g")?);
451    println!("xdel {}", db.xdel(key, &[&first])?);
452    println!("xtrim {}", db.xtrim_maxlen(key, 1)?);
453
454    Ok(())
455}

Examples found in repository ?

examples/tour.rs (line 397)

383fn streams(db: &mut Client) -> Result<(), ruvio_client::Error> {
384    let key = "{tour}:stream";
385    let first = db.xadd(key, "*", &[("f", "1")])?;
386
387    db.xadd(key, "*", &[("f", "2")])?;
388    println!(
389        "xadd_maxlen {}",
390        db.xadd_maxlen(key, 10, "*", &[("f", "3")])?
391    );
392    println!(
393        "xadd_delay {}",
394        db.xadd_delay(key, 60_000, "*", &[("f", "later")])?
395    );
396    println!("xlen {}", db.xlen(key)?);
397    println!("xrange {}", db.xrange(key, "-", "+", None)?[0].id);
398    println!(
399        "xrevrange {}",
400        db.xrevrange(key, "+", "-", Some(1))?[0].fields[0].1
401    );
402    let read = db.xread(
403        &StreamReadOptions {
404            count: Some(2),
405            ..StreamReadOptions::default()
406        },
407        &[(key, "0")],
408    )?;
409
410    println!("xread {}", read[0].entries.len());
411    db.xgroup_create(key, "g", "0", false)?;
412    db.xgroup_create("{tour}:fresh", "g", "$", true)?;
413    let delivered = db.xreadgroup("g", "c1", &StreamReadOptions::default(), &[(key, ">")])?;
414
415    println!("xreadgroup {}", delivered[0].entries.len());
416    let pending = db.xpending(key, "g", "-", "+", 10, &StreamPendingFilter::default())?;
417
418    println!(
419        "xpending {} summary-array {}",
420        pending.len(),
421        db.xpending_summary(key, "g")?.as_array().is_some()
422    );
423    let claimed = db.xclaim(
424        key,
425        "g",
426        "c2",
427        Duration::ZERO,
428        &[&first],
429        &StreamClaimOptions::default(),
430    )?;
431
432    println!("xclaim {}", claimed[0].id);
433    println!(
434        "xclaim_ids {:?}",
435        db.xclaim_ids(
436            key,
437            "g",
438            "c2",
439            Duration::ZERO,
440            &[&first],
441            &StreamClaimOptions::default()
442        )?
443    );
444    println!("xack {}", db.xack(key, "g", &[&first])?);
445    println!(
446        "xgroup_delconsumer {}",
447        db.xgroup_delconsumer(key, "g", "c1")?
448    );
449    db.xgroup_setid(key, "g", "0")?;
450    println!("xgroup_destroy {}", db.xgroup_destroy(key, "g")?);
451    println!("xdel {}", db.xdel(key, &[&first])?);
452    println!("xtrim {}", db.xtrim_maxlen(key, 1)?);
453
454    Ok(())
455}

Source

pub fn xrevrange( &mut self, key: &str, end: &str, start: &str, count: Option<u64>, ) -> Result<Vec<StreamEntry>, Error>

Sends XREVRANGE from end down to start, with an optional COUNT.

Examples found in repository ?

examples/tour.rs (line 400)

383fn streams(db: &mut Client) -> Result<(), ruvio_client::Error> {
384    let key = "{tour}:stream";
385    let first = db.xadd(key, "*", &[("f", "1")])?;
386
387    db.xadd(key, "*", &[("f", "2")])?;
388    println!(
389        "xadd_maxlen {}",
390        db.xadd_maxlen(key, 10, "*", &[("f", "3")])?
391    );
392    println!(
393        "xadd_delay {}",
394        db.xadd_delay(key, 60_000, "*", &[("f", "later")])?
395    );
396    println!("xlen {}", db.xlen(key)?);
397    println!("xrange {}", db.xrange(key, "-", "+", None)?[0].id);
398    println!(
399        "xrevrange {}",
400        db.xrevrange(key, "+", "-", Some(1))?[0].fields[0].1
401    );
402    let read = db.xread(
403        &StreamReadOptions {
404            count: Some(2),
405            ..StreamReadOptions::default()
406        },
407        &[(key, "0")],
408    )?;
409
410    println!("xread {}", read[0].entries.len());
411    db.xgroup_create(key, "g", "0", false)?;
412    db.xgroup_create("{tour}:fresh", "g", "$", true)?;
413    let delivered = db.xreadgroup("g", "c1", &StreamReadOptions::default(), &[(key, ">")])?;
414
415    println!("xreadgroup {}", delivered[0].entries.len());
416    let pending = db.xpending(key, "g", "-", "+", 10, &StreamPendingFilter::default())?;
417
418    println!(
419        "xpending {} summary-array {}",
420        pending.len(),
421        db.xpending_summary(key, "g")?.as_array().is_some()
422    );
423    let claimed = db.xclaim(
424        key,
425        "g",
426        "c2",
427        Duration::ZERO,
428        &[&first],
429        &StreamClaimOptions::default(),
430    )?;
431
432    println!("xclaim {}", claimed[0].id);
433    println!(
434        "xclaim_ids {:?}",
435        db.xclaim_ids(
436            key,
437            "g",
438            "c2",
439            Duration::ZERO,
440            &[&first],
441            &StreamClaimOptions::default()
442        )?
443    );
444    println!("xack {}", db.xack(key, "g", &[&first])?);
445    println!(
446        "xgroup_delconsumer {}",
447        db.xgroup_delconsumer(key, "g", "c1")?
448    );
449    db.xgroup_setid(key, "g", "0")?;
450    println!("xgroup_destroy {}", db.xgroup_destroy(key, "g")?);
451    println!("xdel {}", db.xdel(key, &[&first])?);
452    println!("xtrim {}", db.xtrim_maxlen(key, 1)?);
453
454    Ok(())
455}

Source

pub fn xdel(&mut self, key: &str, ids: &[&str]) -> Result<i64, Error>

Sends XDEL and returns how many entries were removed.

Examples found in repository ?

examples/tour.rs (line 451)

383fn streams(db: &mut Client) -> Result<(), ruvio_client::Error> {
384    let key = "{tour}:stream";
385    let first = db.xadd(key, "*", &[("f", "1")])?;
386
387    db.xadd(key, "*", &[("f", "2")])?;
388    println!(
389        "xadd_maxlen {}",
390        db.xadd_maxlen(key, 10, "*", &[("f", "3")])?
391    );
392    println!(
393        "xadd_delay {}",
394        db.xadd_delay(key, 60_000, "*", &[("f", "later")])?
395    );
396    println!("xlen {}", db.xlen(key)?);
397    println!("xrange {}", db.xrange(key, "-", "+", None)?[0].id);
398    println!(
399        "xrevrange {}",
400        db.xrevrange(key, "+", "-", Some(1))?[0].fields[0].1
401    );
402    let read = db.xread(
403        &StreamReadOptions {
404            count: Some(2),
405            ..StreamReadOptions::default()
406        },
407        &[(key, "0")],
408    )?;
409
410    println!("xread {}", read[0].entries.len());
411    db.xgroup_create(key, "g", "0", false)?;
412    db.xgroup_create("{tour}:fresh", "g", "$", true)?;
413    let delivered = db.xreadgroup("g", "c1", &StreamReadOptions::default(), &[(key, ">")])?;
414
415    println!("xreadgroup {}", delivered[0].entries.len());
416    let pending = db.xpending(key, "g", "-", "+", 10, &StreamPendingFilter::default())?;
417
418    println!(
419        "xpending {} summary-array {}",
420        pending.len(),
421        db.xpending_summary(key, "g")?.as_array().is_some()
422    );
423    let claimed = db.xclaim(
424        key,
425        "g",
426        "c2",
427        Duration::ZERO,
428        &[&first],
429        &StreamClaimOptions::default(),
430    )?;
431
432    println!("xclaim {}", claimed[0].id);
433    println!(
434        "xclaim_ids {:?}",
435        db.xclaim_ids(
436            key,
437            "g",
438            "c2",
439            Duration::ZERO,
440            &[&first],
441            &StreamClaimOptions::default()
442        )?
443    );
444    println!("xack {}", db.xack(key, "g", &[&first])?);
445    println!(
446        "xgroup_delconsumer {}",
447        db.xgroup_delconsumer(key, "g", "c1")?
448    );
449    db.xgroup_setid(key, "g", "0")?;
450    println!("xgroup_destroy {}", db.xgroup_destroy(key, "g")?);
451    println!("xdel {}", db.xdel(key, &[&first])?);
452    println!("xtrim {}", db.xtrim_maxlen(key, 1)?);
453
454    Ok(())
455}

Source

pub fn xtrim_minid(&mut self, key: &str, id: &str) -> Result<i64, Error>

Sends XTRIM MINID. Entries below id are removed. ~ is trimmed exactly.

17fn main() -> Result<(), ruvio_client::Error> {
18    let host = std::env::args()
19        .nth(1)
20        .unwrap_or_else(|| "127.0.0.1".to_owned());
21    let port = std::env::args()
22        .nth(2)
23        .and_then(|text| text.parse().ok())
24        .unwrap_or(6379);
25    let mut db = Client::connect(&host, port)?;
26
27    db.on_connection_lost(|notice| {
28        println!(
29            "connection lost {}:{} subscriber={}",
30            notice.host, notice.port, notice.subscriber
31        );
32    });
33
34    db.on_connection_restored(|notice| {
35        println!(
36            "connection restored {}:{} subscriber={}",
37            notice.host, notice.port, notice.subscriber
38        );
39    });
40
41    db.set_reconnect_delay(|attempt| {
42        if attempt >= 8 {
43            None
44        } else {
45            Some(Duration::from_millis(100 * 2u64.pow(attempt - 1)))
46        }
47    });
48
49    println!(
50        "connected cluster={} shards={} slot={}",
51        db.is_cluster(),
52        db.shard_count(),
53        ruvio_client::hash_slot("{tour}")
54    );
55    println!("reconnect armed; the command that sees a drop fails, the next one opens the socket");
56
57    if !db.is_cluster() {
58        db.select(15)?;
59        db.flushdb()?;
60        println!("selected database {}", db.database());
61    }
62
63    strings(&mut db)?;
64    owned(&mut db)?;
65    lists(&mut db)?;
66    sets(&mut db)?;
67    hashes(&mut db)?;
68    sorted_sets(&mut db)?;
69    bloom(&mut db)?;
70    streams(&mut db)?;
71    transactions(&mut db)?;
72    server(&mut db)?;
73    pubsub(&host, port)?;
74
75    println!("tour finished");
76
77    Ok(())
78}

Source

pub fn flushall(&mut self) -> Result<(), Error>

508fn server(db: &mut Client) -> Result<(), ruvio_client::Error> {
509    println!("ping {}", db.ping()?);
510    println!("ping_message {}", db.ping_message("tour")?);
511    println!("info has ruvio {}", db.info(None)?.contains("ruvio"));
512    println!("info server {}", db.info(Some("server"))?.len());
513    println!("config_get {}", db.config_get("databases")?.len());
514    println!("whoami {}", db.acl_whoami()?);
515    println!("acl_users {:?}", db.acl_users()?);
516    println!("acl_list {}", db.acl_list()?.len());
517    println!("acl_cat {}", db.acl_cat()?.len());
518    println!("acl_getuser null {}", db.acl_getuser("default")?.is_null());
519    db.acl_setuser("tour-reader", &["on", "~{tour}:*", "+get"])?;
520    db.client_setname("ruvio-tour")?;
521    println!("client_getname {:?}", db.client_getname()?);
522    db.client_tracking(false)?;
523    println!("cluster_keyslot {}", db.cluster_keyslot("{tour}")?);
524
525    if db.is_cluster() {
526        println!(
527            "cluster_nodes {}",
528            db.cluster_nodes()?.chars().take(40).collect::<String>()
529        );
530        println!(
531            "cluster_slots array {}",
532            db.cluster_slots()?.as_array().is_some()
533        );
534        println!(
535            "cluster_shards array {}",
536            db.cluster_shards()?.as_array().is_some()
537        );
538        println!("cluster_info {}", db.cluster_info()?.len());
539        println!("cluster_myid {}", db.cluster_myid()?);
540        db.readonly()?;
541        db.readwrite()?;
542    }
543
544    db.save()?;
545    db.bgsave()?;
546    println!("hello array {}", db.hello(2)?.as_array().is_some());
547    db.execute_many(&[&["PING"], &["PING"]])?;
548
549    Ok(())
550}

Source

pub fn acl_load(&mut self) -> Result<(), Error>

Sends ACL LOAD.

Source

pub fn acl_save(&mut self) -> Result<(), Error>

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Sends SUBSCRIBE and reads one confirmation per channel. Opens a dedicated Pub/Sub socket so PING and PUBLISH stay on the command connection. Then read deliveries with Self::next_message.

Examples found in repository ?

examples/tour.rs (line 556)

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

pub fn unsubscribe( &mut self, channels: &[&str], ) -> Result<Vec<RespValue>, Error>

Sends UNSUBSCRIBE. No channels drops every exact subscription on this connection.

Examples found in repository ?

examples/tour.rs (line 570)

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

pub fn psubscribe(&mut self, patterns: &[&str]) -> Result<Vec<RespValue>, Error>

Sends PSUBSCRIBE and reads one confirmation per pattern.

Examples found in repository ?

examples/tour.rs (line 557)

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

pub fn punsubscribe( &mut self, patterns: &[&str], ) -> Result<Vec<RespValue>, Error>

Sends PUNSUBSCRIBE. No patterns drops every pattern subscription on this connection.

Examples found in repository ?

examples/tour.rs (line 571)

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

pub fn ssubscribe(&mut self, channels: &[&str]) -> Result<Vec<RespValue>, Error>

Sends SSUBSCRIBE and reads one confirmation per channel.

Examples found in repository ?

examples/tour.rs (line 572)

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

pub fn sunsubscribe( &mut self, channels: &[&str], ) -> Result<Vec<RespValue>, Error>

Sends SUNSUBSCRIBE. No channels drops every sharded subscription on this connection.

Examples found in repository ?

examples/tour.rs (line 575)

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

pub fn next_message(&mut self) -> Result<PubSubMessage, Error>

Reads replies until a message, pmessage, or smessage arrives, skipping subscribe confirmations. Blocks until Self::set_read_timeout passes.

Examples found in repository ?

examples/tour.rs (line 561)

552fn pubsub(host: &str, port: u16) -> Result<(), ruvio_client::Error> {
553    let mut commands = Client::connect(host, port)?;
554    let mut listener = commands.subscriber()?;
555
556    listener.subscribe(&["{tour}:news"])?;
557    listener.psubscribe(&["{tour}:n*"])?;
558    listener.set_read_timeout(Some(Duration::from_secs(2)))?;
559    println!("publish {}", commands.publish("{tour}:news", "hello-tour")?);
560
561    let exact = listener.next_message()?;
562    let pattern = listener.next_message()?;
563
564    println!(
565        "message {} {:?}",
566        exact.channel,
567        String::from_utf8_lossy(&exact.payload)
568    );
569    println!("pmessage {:?}", pattern.pattern);
570    listener.unsubscribe(&["{tour}:news"])?;
571    listener.punsubscribe(&["{tour}:n*"])?;
572    listener.ssubscribe(&["{tour}:shard"])?;
573    println!("spublish {}", commands.spublish("{tour}:shard", "sharded")?);
574    println!("smessage {}", listener.next_message()?.kind);
575    listener.sunsubscribe(&["{tour}:shard"])?;
576    println!("ping after subscribe {}", commands.ping()?);
577
578    Ok(())
579}

Source

fn try_from(value: U) -> Result<T, !>

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct Client Copy item path

Implementations§

impl Client

pub fn connect(host: impl Into<String>, port: u16) -> Result<Self, Error>

pub fn connect_database( host: impl Into<String>, port: u16, database: u32, ) -> Result<Self, Error>

pub fn connect_ip(ip: IpAddr, port: u16, database: u32) -> Result<Self, Error>

pub fn connect_addr(address: SocketAddr, database: u32) -> Result<Self, Error>

pub fn connect_with(options: ClientOptions) -> Result<Self, Error>

pub fn is_cluster(&self) -> bool

pub fn shard_count(&self) -> usize

pub fn ping(&mut self) -> Result<String, Error>

pub fn ping_message(&mut self, message: &str) -> Result<String, Error>

pub fn database(&self) -> u32

pub fn subscriber(&self) -> Result<Self, Error>

pub fn select(&mut self, database: u32) -> Result<(), Error>

pub fn into_database(self, database: u32) -> Result<Self, Error>

pub fn set_read_timeout( &mut self, timeout: Option<Duration>, ) -> Result<(), Error>

pub fn get(&mut self, key: &str) -> Result<Option<Vec<u8>>, Error>

pub fn get_string(&mut self, key: &str) -> Result<Option<String>, Error>

pub fn set(&mut self, key: &str, value: &str) -> Result<bool, Error>

pub fn set_with( &mut self, key: &str, value: &str, expiry: Option<Duration>, mode: SetMode, ) -> Result<bool, Error>

pub fn set_expires_at( &mut self, key: &str, value: &str, expires_at: SystemTime, mode: SetMode, ) -> Result<bool, Error>

pub fn set_keep_ttl( &mut self, key: &str, value: &str, mode: SetMode, ) -> Result<bool, Error>

pub fn set_and_get( &mut self, key: &str, value: &str, expiry: Option<Duration>, mode: SetMode, ) -> Result<Option<String>, Error>

pub fn incr(&mut self, key: &str) -> Result<i64, Error>

pub fn expire(&mut self, key: &str, ttl: Duration) -> Result<bool, Error>

pub fn del_key(&mut self, key: &str) -> Result<i64, Error>

pub fn del(&mut self, keys: &[&str]) -> Result<i64, Error>

pub fn read_message(&mut self) -> Result<RespValue, Error>

pub fn on_connection_lost<F>(&mut self, hook: F)where F: Fn(ConnectionNotice) + Send + Sync + 'static,

pub fn on_connection_restored<F>(&mut self, hook: F)where F: Fn(ConnectionNotice) + Send + Sync + 'static,

pub fn set_reconnect_delay<F>(&mut self, delay: F)where F: Fn(u32) -> Option<Duration> + Send + Sync + 'static,

pub fn reconnect(&mut self) -> Result<(), Error>

pub fn execute(&mut self, arguments: &[&str]) -> Result<RespValue, Error>

pub fn execute_many( &mut self, commands: &[&[&str]], ) -> Result<Vec<RespValue>, Error>

impl Client

pub fn mget(&mut self, keys: &[&str]) -> Result<Vec<Option<String>>, Error>

pub fn limit( &mut self, key: &str, max: u64, window_ms: u64, ) -> Result<Option<i64>, Error>

pub fn once(&mut self, key: &str, ttl_ms: u64) -> Result<i64, Error>

pub fn idempotency_begin( &mut self, key: &str, fingerprint: &str, owner: &str, ttl_ms: u64, ) -> Result<RespValue, Error>

pub fn idempotency_complete( &mut self, key: &str, fingerprint: &str, owner: &str, result: &str, ) -> Result<i64, Error>

pub fn take(&mut self, key: &str, count: i64) -> Result<Option<i64>, Error>

pub fn getex(&mut self, key: &str, ttl_ms: u64) -> Result<Option<String>, Error>

pub fn lease(&mut self, key: &str, ttl_ms: u64) -> Result<Option<i64>, Error>

pub fn semaphore( &mut self, key: &str, max: u64, ttl_ms: u64, ) -> Result<Option<i64>, Error>

pub fn incr_by_max( &mut self, key: &str, delta: i64, limit: i64, ) -> Result<Option<i64>, Error>

pub fn release(&mut self, key: &str, token: u64) -> Result<i64, Error>

pub fn setv( &mut self, key: &str, value: &str, version: Option<u64>, ) -> Result<i64, Error>

pub fn changes_start(&mut self) -> Result<i64, Error>

pub fn changes(&mut self, cursor: u64) -> Result<Vec<(i64, String)>, Error>

pub fn mset(&mut self, pairs: &[(&str, &str)]) -> Result<(), Error>

pub fn getset( &mut self, key: &str, value: &str, ) -> Result<Option<String>, Error>

pub fn append(&mut self, key: &str, value: &str) -> Result<i64, Error>

pub fn strlen(&mut self, key: &str) -> Result<i64, Error>

pub fn decr(&mut self, key: &str) -> Result<i64, Error>

pub fn incr_by(&mut self, key: &str, delta: i64) -> Result<i64, Error>

pub fn decr_by(&mut self, key: &str, delta: i64) -> Result<i64, Error>

pub fn unlink_key(&mut self, key: &str) -> Result<i64, Error>

pub fn unlink(&mut self, keys: &[&str]) -> Result<i64, Error>

pub fn exists_key(&mut self, key: &str) -> Result<i64, Error>

pub fn exists(&mut self, keys: &[&str]) -> Result<i64, Error>

pub fn key_type(&mut self, key: &str) -> Result<String, Error>

pub fn rename(&mut self, key: &str, new_key: &str) -> Result<(), Error>

pub fn scan( &mut self, cursor: u64, pattern: Option<&str>, count: Option<u64>, ) -> Result<ScanPage, Error>

pub fn dbsize(&mut self) -> Result<i64, Error>

pub fn expire_at(&mut self, key: &str, when: SystemTime) -> Result<bool, Error>

pub fn pexpire(&mut self, key: &str, ttl: Duration) -> Result<bool, Error>

pub fn ttl(&mut self, key: &str) -> Result<i64, Error>

pub fn pttl(&mut self, key: &str) -> Result<i64, Error>

pub fn persist(&mut self, key: &str) -> Result<bool, Error>

pub fn lpush(&mut self, key: &str, values: &[&str]) -> Result<i64, Error>

pub fn rpush(&mut self, key: &str, values: &[&str]) -> Result<i64, Error>

pub fn lpop(&mut self, key: &str) -> Result<Option<String>, Error>

pub fn lpop_count( &mut self, key: &str, count: u64, ) -> Result<Vec<String>, Error>

pub fn rpop(&mut self, key: &str) -> Result<Option<String>, Error>

pub fn rpop_count( &mut self, key: &str, count: u64, ) -> Result<Vec<String>, Error>

pub fn llen(&mut self, key: &str) -> Result<i64, Error>

pub fn lindex(&mut self, key: &str, index: i64) -> Result<Option<String>, Error>

pub fn lrange( &mut self, key: &str, start: i64, stop: i64, ) -> Result<Vec<String>, Error>

Struct Client

pub fn on_connection_lost<F>(&mut self, hook: F)
where F: Fn(ConnectionNotice) + Send + Sync + 'static,

pub fn on_connection_restored<F>(&mut self, hook: F)
where F: Fn(ConnectionNotice) + Send + Sync + 'static,

pub fn set_reconnect_delay<F>(&mut self, delay: F)
where F: Fn(u32) -> Option<Duration> + Send + Sync + 'static,