use crate::connection::{AppState, PoolKind}; use crate::db::redis_driver::{self, RedisCommandResult, RedisScanResult, RedisValue}; pub async fn redis_list_databases_core(state: &AppState, connection_id: &str) -> Result, String> { let connections = state.connections.read().await; let pool = connections.get(connection_id).ok_or("Connection not found")?; match pool { PoolKind::Redis(con) => { let mut con = con.lock().await; redis_driver::list_databases(&mut con).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_scan_keys_core( state: &AppState, connection_id: &str, db: u32, cursor: u64, pattern: &str, count: usize, ) -> Result { let connections = state.connections.read().await; let pool = connections.get(connection_id).ok_or("Connection not found")?; match pool { PoolKind::Redis(con) => { let mut con = con.lock().await; redis_driver::select_db(&mut con, db).await?; redis_driver::scan_keys_page(&mut con, cursor, pattern, count).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_get_value_core(state: &AppState, connection_id: &str, key: &str) -> Result { redis_get_value_in_db_core(state, connection_id, 0, key).await } pub async fn redis_get_value_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, ) -> Result { let connections = state.connections.read().await; let pool = connections.get(connection_id).ok_or("Connection not found")?; match pool { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::get_value(&mut con, &key).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_set_string_core( state: &AppState, connection_id: &str, key: &str, value: &str, ttl: Option, ) -> Result<(), String> { redis_set_string_in_db_core(state, connection_id, 0, key, value, ttl).await } pub async fn redis_set_string_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, value: &str, ttl: Option, ) -> Result<(), String> { let connections = state.connections.read().await; let pool = connections.get(connection_id).ok_or("Connection not found")?; match pool { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::set_string(&mut con, &key, value, ttl).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_delete_key_core(state: &AppState, connection_id: &str, key: &str) -> Result<(), String> { redis_delete_key_in_db_core(state, connection_id, 0, key).await } pub async fn redis_delete_key_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, ) -> Result<(), String> { let connections = state.connections.read().await; let pool = connections.get(connection_id).ok_or("Connection not found")?; match pool { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::delete_key(&mut con, &key).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_hash_set_core( state: &AppState, connection_id: &str, key: &str, field: &str, value: &str, ) -> Result<(), String> { redis_hash_set_in_db_core(state, connection_id, 0, key, field, value).await } pub async fn redis_hash_set_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, field: &str, value: &str, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::hash_set(&mut con, &key, field, value).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_hash_del_core(state: &AppState, connection_id: &str, key: &str, field: &str) -> Result<(), String> { redis_hash_del_in_db_core(state, connection_id, 0, key, field).await } pub async fn redis_hash_del_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, field: &str, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::hash_del(&mut con, &key, field).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_list_push_core(state: &AppState, connection_id: &str, key: &str, value: &str) -> Result<(), String> { redis_list_push_in_db_core(state, connection_id, 0, key, value).await } pub async fn redis_list_push_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, value: &str, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::list_push(&mut con, &key, value).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_list_set_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, index: i64, value: &str, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::list_set(&mut con, &key, index, value).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_list_remove_core( state: &AppState, connection_id: &str, key: &str, index: i64, ) -> Result<(), String> { redis_list_remove_in_db_core(state, connection_id, 0, key, index).await } pub async fn redis_list_remove_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, index: i64, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::list_remove(&mut con, &key, index).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_set_add_core(state: &AppState, connection_id: &str, key: &str, member: &str) -> Result<(), String> { redis_set_add_in_db_core(state, connection_id, 0, key, member).await } pub async fn redis_set_add_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, member: &str, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::set_add(&mut con, &key, member).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_set_remove_core( state: &AppState, connection_id: &str, key: &str, member: &str, ) -> Result<(), String> { redis_set_remove_in_db_core(state, connection_id, 0, key, member).await } pub async fn redis_set_remove_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, member: &str, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::set_remove(&mut con, &key, member).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_zadd_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, member: &str, score: f64, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::zadd(&mut con, &key, member, score).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_zrem_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, member: &str, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::zrem(&mut con, &key, member).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_set_ttl_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, ttl: i64, ) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::set_ttl(&mut con, &key, ttl).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_delete_keys_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raws: &[String], ) -> Result { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; redis_driver::select_db(&mut con, db).await?; let keys: Result>, String> = key_raws.iter().map(|k| redis_driver::redis_key_raw_to_bytes(k)).collect(); redis_driver::delete_keys(&mut con, &keys?).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_flush_db_core(state: &AppState, connection_id: &str, db: u32) -> Result<(), String> { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; redis_driver::select_db(&mut con, db).await?; redis_driver::flush_db(&mut con).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_execute_command_core( state: &AppState, connection_id: &str, db: u32, command: &str, ) -> Result { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; redis_driver::select_db(&mut con, db).await?; redis_driver::execute_command(&mut con, command).await } _ => Err("Not a Redis connection".to_string()), } } pub async fn redis_load_more_in_db_core( state: &AppState, connection_id: &str, db: u32, key_raw: &str, key_type: &str, cursor: u64, count: usize, ) -> Result { let connections = state.connections.read().await; match connections.get(connection_id).ok_or("Not found")? { PoolKind::Redis(con) => { let mut con = con.lock().await; let key = redis_driver::redis_key_raw_to_bytes(key_raw)?; redis_driver::select_db(&mut con, db).await?; redis_driver::load_more_collection(&mut con, &key, key_type, cursor, count).await } _ => Err("Not a Redis connection".to_string()), } }