25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(redis): probe HTTL support for binary hash fields
zipgffc2a5b008da
diff --git a/crates/dbx-driver-redis/src/lib.rs b/crates/dbx-driver-redis/src/lib.rsindex 0c12ad1600..ff2eeacacb 100644--- a/crates/dbx-driver-redis/src/lib.rs+++ b/crates/dbx-driver-redis/src/lib.rs@@ -4441,12 +4441,37 @@ wherereturn Ok(());}+ let fields = items+ .iter()+ .map(|item| {+ base64::engine::general_purpose::STANDARD+ .decode(&item.field.raw_base64)+ .map_err(|error| format!("Invalid Redis hash field encoding: {error}"))+ })+ .collect::<Result<Vec<_>, _>>()?;++ // Redis < 7.4 echoes command arguments verbatim in unknown-command errors.+ // Binary arguments can make that RESP error invalid UTF-8 (or inject CRLF),+ // so redis-rs fails to parse it before the optional-error fallback can run.+ // Discover support using ASCII-only arguments before sending unsafe bytes.+ let unsafe_error_arg =+ |bytes: &[u8]| std::str::from_utf8(bytes).is_err() || bytes.windows(2).any(|pair| pair == b"\r\n");+ if unsafe_error_arg(key) || fields.iter().any(|field| unsafe_error_arg(field)) {+ let info: RedisRawValue = match redis::cmd("COMMAND").arg("INFO").arg("HTTL").query_async(con).await {+ Ok(info) => info,+ Err(error) if is_optional_hash_field_expiry_error(&error) => return Ok(()),+ Err(error) => return Err(error.to_string()),+ };+ if matches!(info, RedisRawValue::Nil)+ || matches!(&info, RedisRawValue::Array(commands) if commands.is_empty() || matches!(commands.first(), Some(RedisRawValue::Nil)))+ {+ return Ok(());+ }+ }+let mut command = redis::cmd("HTTL");- command.arg(key).arg("FIELDS").arg(items.len());- for item in items.iter() {- let field = base64::engine::general_purpose::STANDARD- .decode(&item.field.raw_base64)- .map_err(|error| format!("Invalid Redis hash field encoding: {error}"))?;+ command.arg(key).arg("FIELDS").arg(fields.len());+ for field in fields {command.arg(field);}@@ -6795,6 +6820,60 @@ mod tests {assert_eq!(con.command_count("LLEN"), 1);}+ #[tokio::test]+ async fn binary_hash_ttl_discovery_avoids_unsafe_unknown_command_errors() {+ for (key, field) in+ [(b"hash".as_slice(), b"\x03kryo\xf3".as_slice()), (b"hash\xff", b"field"), (b"hash", b"field\r\n")]+ {+ let mut items = vec![RedisHashItem {+ field: redis_blob_from_bytes(field),+ value: redis_blob_from_bytes(b"\x01value\xff"),+ field_ttl: None,+ }];+ let original = items.clone();+ let mut con = FakeRedisConnection::new(vec![RedisRawValue::Array(vec![RedisRawValue::Nil])]);+ super::attach_hash_field_ttls(&mut con, key, &mut items).await.unwrap();+ assert_eq!(items, original);+ assert_eq!(con.command_count("COMMAND"), 1);+ assert_eq!(con.commands.len(), 1);+ assert!(!con.commands[0].contains("\r\nFIELDS\r\n"));+ assert!(con.responses.is_empty());++ let mut con = FakeRedisConnection::new(vec![+ RedisRawValue::Array(vec![RedisRawValue::Array(vec![bulk("httl")])]),+ httl_response(1, 42),+ ]);+ super::attach_hash_field_ttls(&mut con, key, &mut items).await.unwrap();+ assert_eq!(items[0].field_ttl, Some(42));+ assert_eq!(con.commands.len(), 2);+ assert!(con.commands[1].contains("\r\nFIELDS\r\n"));+ assert!(con.responses.is_empty());+ }+ }++ #[tokio::test]+ async fn binary_hash_command_discovery_only_suppresses_optional_errors() {+ let mut items = vec![RedisHashItem {+ field: redis_blob_from_bytes(b"\x03kryo\xf3"),+ value: text_blob("value"),+ field_ttl: None,+ }];+ let mut con = FakeRedisConnection::with_results(vec![Err(noperm("command"))]);+ super::attach_hash_field_ttls(&mut con, b"hash", &mut items).await.unwrap();+ assert_eq!(con.commands.len(), 1);+ assert_eq!(items[0].field_ttl, None);++ let mut con = FakeRedisConnection::with_results(vec![Err(redis::RedisError::from((+ redis::ErrorKind::ResponseError,+ "server error",+ "unrelated discovery failure".to_string(),+ )))]);+ assert!(super::attach_hash_field_ttls(&mut con, b"hash", &mut items)+ .await+ .unwrap_err()+ .contains("unrelated discovery failure"));+ }+#[tokio::test]async fn hash_load_more_attaches_field_ttl_when_supported() {let mut con = FakeRedisConnection::new(vec![diff --git a/crates/dbx-driver-redis/tests/binary_hash_compatibility.rs b/crates/dbx-driver-redis/tests/binary_hash_compatibility.rsnew file mode 100644index 0000000000..2c2197a2c1--- /dev/null+++ b/crates/dbx-driver-redis/tests/binary_hash_compatibility.rs@@ -0,0 +1,64 @@+use base64::Engine;+use dbx_driver_redis::{connect, get_value, load_more_collection, RedisCollectionPage, RedisValueData};+use std::collections::HashMap;+use std::time::{Duration, SystemTime, UNIX_EPOCH};++#[tokio::test]+#[ignore = "requires a disposable server via DBX_TEST_REDIS_URL"]+async fn binary_hash_listing_preserves_bytes_and_connection() {+ let url = std::env::var("DBX_TEST_REDIS_URL").expect("DBX_TEST_REDIS_URL");+ let mut con = connect(&url, Duration::from_secs(5)).await.unwrap();+ let info: Vec<redis::Value> = redis::cmd("COMMAND").arg("INFO").arg("HTTL").query_async(&mut con).await.unwrap();+ let supports_ttl = !matches!(info.first(), None | Some(redis::Value::Nil));+ let nonce = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();+ let prefix = format!("dbx-8585-{}-{nonce}", std::process::id());+ let keys = [prefix.as_bytes().to_vec(), [prefix.as_bytes(), b"\xff\r\n"].concat()];+ let expected: HashMap<Vec<u8>, Vec<u8>> = (0..2563_u32)+ .map(|index| {+ let suffix: &[u8] = if index % 2 == 0 { b"\xf3" } else { b"\r\n" };+ let field = [format!("\x03accu_test{index}.IoStatu").as_bytes(), suffix].concat();+ let value = [b"\x01\x00com.accu.MeasureValueEx\xf4\x01".as_slice(), &index.to_le_bytes()].concat();+ (field, value)+ })+ .collect();+ for key in &keys {+ let mut seed = redis::cmd("HSET");+ seed.arg(key);+ for (field, value) in &expected {+ seed.arg(field).arg(value);+ }+ seed.query_async::<()>(&mut con).await.unwrap();+ redis::cmd("EXPIRE").arg(key).arg(300).query_async::<()>(&mut con).await.unwrap();+ let value = get_value(&mut con, key).await.unwrap();+ let RedisValueData::Hash { items, total, mut scan_cursor } = value.data else { panic!("expected hash") };+ assert_eq!(total, 2563);+ assert!(!items.is_empty() && items.len() <= 200);+ let mut actual = HashMap::new();+ let mut page = items;+ let mut pages = 0;+ loop {+ for item in page {+ assert_eq!(item.field_ttl, supports_ttl.then_some(-1));+ let decode = |blob: &str| base64::engine::general_purpose::STANDARD.decode(blob).unwrap();+ actual.insert(decode(&item.field.raw_base64), decode(&item.value.raw_base64));+ }+ let Some(cursor) = scan_cursor else { break };+ pages += 1;+ assert!(pages < 100);+ let RedisCollectionPage::Hash { items, scan_cursor: next } =+ load_more_collection(&mut con, key, "hash", cursor, 200, None, None).await.unwrap()+ else {+ panic!("expected hash page")+ };+ assert!(items.len() <= 200);+ page = items;+ scan_cursor = next;+ }+ assert!(pages > 0);+ assert_eq!(actual, expected);+ let pong: String = redis::cmd("PING").query_async(&mut con).await.unwrap();+ assert_eq!(pong, "PONG");+ println!("PASS: 2563 binary fields/values, all pages, binary key={}, TTL supported={supports_ttl}, same connection PING", key != &keys[0]);+ }+ redis::cmd("DEL").arg(&keys).query_async::<()>(&mut con).await.unwrap();+}