Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

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.rs
index 0c12ad1600..ff2eeacacb 100644
--- a/crates/dbx-driver-redis/src/lib.rs
+++ b/crates/dbx-driver-redis/src/lib.rs
@@ -4441,12 +4441,37 @@ where
return 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.rs
new file mode 100644
index 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();
+}