use bytes::Bytes;
use futures::Stream;
use redis_tower_commands::{HScan, SScan, Scan, ZScan};
use redis_tower_core::{RedisConnection, RedisError};
pub struct ScanStream;
impl ScanStream {
pub fn scan<'a>(
conn: &'a mut RedisConnection,
pattern: impl Into<String>,
) -> impl Stream<Item = Result<Bytes, RedisError>> + 'a {
let pattern = pattern.into();
async_stream::try_stream! {
let mut cursor = "0".to_string();
loop {
let result = conn.execute(
Scan::new().match_pattern(&pattern).cursor(&cursor)
).await?;
cursor = result.cursor;
for key in result.results {
let item: Bytes = key;
yield item;
}
if cursor == "0" {
break;
}
}
}
}
pub fn scan_with_count<'a>(
conn: &'a mut RedisConnection,
pattern: impl Into<String>,
count: u64,
) -> impl Stream<Item = Result<Bytes, RedisError>> + 'a {
let pattern = pattern.into();
async_stream::try_stream! {
let mut cursor = "0".to_string();
loop {
let result = conn.execute(
Scan::new()
.match_pattern(&pattern)
.cursor(&cursor)
.count(count)
).await?;
cursor = result.cursor;
for key in result.results {
let item: Bytes = key;
yield item;
}
if cursor == "0" {
break;
}
}
}
}
pub fn hscan<'a>(
conn: &'a mut RedisConnection,
key: impl Into<String>,
pattern: impl Into<String>,
) -> impl Stream<Item = Result<(Bytes, Bytes), RedisError>> + 'a {
let key = key.into();
let pattern = pattern.into();
async_stream::try_stream! {
let mut cursor = "0".to_string();
loop {
let result = conn.execute(
HScan::new(&key).match_pattern(&pattern).cursor(&cursor)
).await?;
cursor = result.cursor;
for pair in result.results {
let item: (Bytes, Bytes) = pair;
yield item;
}
if cursor == "0" {
break;
}
}
}
}
pub fn sscan<'a>(
conn: &'a mut RedisConnection,
key: impl Into<String>,
pattern: impl Into<String>,
) -> impl Stream<Item = Result<Bytes, RedisError>> + 'a {
let key = key.into();
let pattern = pattern.into();
async_stream::try_stream! {
let mut cursor = "0".to_string();
loop {
let result = conn.execute(
SScan::new(&key).match_pattern(&pattern).cursor(&cursor)
).await?;
cursor = result.cursor;
for member in result.results {
let item: Bytes = member;
yield item;
}
if cursor == "0" {
break;
}
}
}
}
pub fn zscan<'a>(
conn: &'a mut RedisConnection,
key: impl Into<String>,
pattern: impl Into<String>,
) -> impl Stream<Item = Result<(Bytes, f64), RedisError>> + 'a {
let key = key.into();
let pattern = pattern.into();
async_stream::try_stream! {
let mut cursor = "0".to_string();
loop {
let result = conn.execute(
ZScan::new(&key).match_pattern(&pattern).cursor(&cursor)
).await?;
cursor = result.cursor;
for entry in result.results {
let item: (Bytes, f64) = entry;
yield item;
}
if cursor == "0" {
break;
}
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[allow(dead_code, unused_variables)]
fn assert_stream_types(conn: &mut RedisConnection) {
fn assert_stream<S: Stream>(_s: S) {}
let s = ScanStream::scan(conn, "*");
assert_stream::<_>(s);
}
}