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): allow hash operations on Kvrocks legacy encoding
t8y22a0242ec1d7f
diff --git a/crates/dbx-driver-redis/src/lib.rs b/crates/dbx-driver-redis/src/lib.rsindex 67148a23e2..306c073808 100644--- a/crates/dbx-driver-redis/src/lib.rs+++ b/crates/dbx-driver-redis/src/lib.rs@@ -3433,7 +3433,10 @@ wherelocal source_ttl = -2local ttl_reply = redis.pcall('HTTL', key, 'FIELDS', 1, old_field)if type(ttl_reply) == 'table' and ttl_reply.err ~= nil then- if not optional_expiry_error(ttl_reply) then+ local detail = string.lower(ttl_reply.err)+ if not optional_expiry_error(ttl_reply)+ and detail ~= 'invalid argument: hash field expiration is not supported by legacy hash encoding'+ and detail ~= 'err invalid argument: hash field expiration is not supported by legacy hash encoding' thenreturn -3endelseif type(ttl_reply) == 'table' and ttl_reply[1] ~= nil then@@ -4499,6 +4502,7 @@ fn is_optional_hash_field_expiry_error(error: &redis::RedisError) -> bool {|| detail.contains("syntax error")|| detail.contains("noperm")|| detail.contains("no permission")+ || detail == "invalid argument: hash field expiration is not supported by legacy hash encoding"}fn blob_matches_query(blob: &RedisBlob, lowered_query: &str) -> bool {@@ -6858,6 +6862,337 @@ mod tests {assert_eq!(con.command_count("HEXPIRE"), 1);}+ fn legacy_hash_expiry_error() -> redis::RedisError {+ redis::parse_redis_value(+ b"-ERR Invalid argument: hash field expiration is not supported by legacy hash encoding\r\n",+ )+ .unwrap()+ .extract_error()+ .unwrap_err()+ }++ #[tokio::test]+ async fn legacy_hash_value_keeps_bounded_pages_and_key_ttl() {+ let pairs = (0..201).map(|index| (format!("f{index}"), format!("v{index}"))).collect();+ let mut con = FakeRedisConnection::with_results(vec![+ Ok(bulk("hash")),+ Ok(RedisRawValue::Int(73)),+ Ok(RedisRawValue::Int(201)),+ Ok(hscan_response_owned("0", pairs)),+ Err(legacy_hash_expiry_error()),+ Err(legacy_hash_expiry_error()),+ ]);++ let value = super::get_value(&mut con, b"legacy-paged-hash").await.unwrap();+ assert_eq!(value.ttl, 73);+ let RedisValueData::Hash { items, total, scan_cursor } = value.data else {+ panic!("expected hash");+ };+ assert_eq!(total, 201);+ assert_eq!(items.len(), 200);+ assert!(items.iter().all(|item| item.field_ttl.is_none()));+ assert_eq!(items[199].field, text_blob("f199"));+ let page =+ super::load_more_collection(&mut con, b"legacy-paged-hash", "hash", scan_cursor.unwrap(), 200, None, None)+ .await+ .unwrap();+ let RedisCollectionPage::Hash { items, scan_cursor } = page else {+ panic!("expected hash page");+ };+ assert_eq!(items, vec![RedisHashItem { field: text_blob("f200"), value: text_blob("v200"), field_ttl: None }]);+ assert_eq!(scan_cursor, None);+ assert_eq!(con.command_count("HSCAN"), 1);+ assert_eq!(con.command_count("HTTL"), 2);+ assert!(con.commands[4].contains("\r\n200\r\n"));+ assert!(!con.commands[4].contains("\r\nf200\r\n"));+ assert!(con.responses.is_empty());+ }++ #[tokio::test]+ async fn legacy_hash_load_more_does_not_disable_ttl_for_other_hashes() {+ let mut con = FakeRedisConnection::with_results(vec![+ Ok(hscan_response("17", vec![("field", "value")])),+ Err(legacy_hash_expiry_error()),+ Ok(hscan_response("0", vec![("field", "value")])),+ Ok(httl_response(1, 42)),+ ]);+ for (key, cursor, expected_ttl) in [(b"legacy".as_slice(), Some(17), None), (b"modern", None, Some(42))] {+ let page = super::load_more_collection(&mut con, key, "hash", 0, 1, None, None).await.unwrap();+ let RedisCollectionPage::Hash { items, scan_cursor } = page else {+ panic!("expected hash page");+ };+ assert_eq!(scan_cursor, cursor);+ assert_eq!(+ items,+ vec![RedisHashItem { field: text_blob("field"), value: text_blob("value"), field_ttl: expected_ttl }]+ );+ }+ assert_eq!(con.command_count("HTTL"), 2);+ assert!(con.responses.is_empty());+ }++ #[tokio::test]+ async fn legacy_hash_set_does_not_disable_ttl_for_other_hashes() {+ let mut con = FakeRedisConnection::with_results(vec![+ Err(legacy_hash_expiry_error()),+ Ok(RedisRawValue::Okay),+ Ok(httl_response(1, 42)),+ Ok(RedisRawValue::Okay),+ Ok(httl_response(1, 1)),+ ]);+ super::hash_set(&mut con, b"legacy", "field", "value", None).await.unwrap();+ super::hash_set(&mut con, b"modern", "field", "value", None).await.unwrap();+ assert_eq!(con.command_count("HTTL"), 2);+ assert_eq!(con.command_count("HSET"), 2);+ assert_eq!(con.command_count("HEXPIRE"), 1);+ assert_eq!(con.command_count("EXPIRE"), 0);+ assert!(con.commands[4].contains("\r\nmodern\r\n$2\r\n42\r\n"));+ assert!(con.responses.is_empty());+ }++ #[tokio::test]+ async fn hash_ttl_discovery_keeps_unrelated_errors_fatal() {+ for detail in [+ "operation not supported",+ "Invalid argument: hash field expiration is not supported by another encoding",+ "WRONGTYPE Operation against a key holding the wrong kind of value",+ "Invalid argument: hash field expiration is not supported by legacy hash encoding: extra failure",+ ] {+ let error =+ || redis::RedisError::from((redis::ErrorKind::ResponseError, "server error", detail.to_string()));+ let mut con = FakeRedisConnection::with_results(vec![Err(error())]);+ assert!(super::hash_set(&mut con, b"hash", "field", "value", None).await.unwrap_err().contains(detail));+ assert_eq!(con.command_count("HSET"), 0);+ let mut con =+ FakeRedisConnection::with_results(vec![Ok(hscan_response("0", vec![("f", "v")])), Err(error())]);+ assert!(super::load_more_collection(&mut con, b"hash", "hash", 0, 1, None, None)+ .await+ .unwrap_err()+ .contains(detail));+ }+ let disconnected =+ || redis::RedisError::from(std::io::Error::new(std::io::ErrorKind::ConnectionReset, "connection reset"));+ let mut con = FakeRedisConnection::with_results(vec![Err(disconnected())]);+ assert!(super::hash_set(&mut con, b"hash", "field", "value", None).await.is_err());+ assert_eq!(con.command_count("HSET"), 0);+ let mut con =+ FakeRedisConnection::with_results(vec![Ok(hscan_response("0", vec![("f", "v")])), Err(disconnected())]);+ assert!(super::load_more_collection(&mut con, b"hash", "hash", 0, 1, None, None).await.is_err());+ }++ #[tokio::test]+ async fn legacy_hash_explicit_expiry_errors_remain_visible() {+ let mut con = FakeRedisConnection::with_results(vec![+ Err(legacy_hash_expiry_error()),+ Err(legacy_hash_expiry_error()),+ Err(legacy_hash_expiry_error()),+ ]);+ assert!(super::set_hash_field_ttl(&mut con, b"hash", "field", 60).await.is_err());+ assert!(super::set_hash_field_ttl(&mut con, b"hash", "field", -1).await.is_err());+ assert!(super::set_hash_field_expire_at(&mut con, b"hash", "field", 1_735_689_600).await.is_err());+ assert_eq!(con.command_count("HEXPIRE"), 1);+ assert_eq!(con.command_count("HPERSIST"), 1);+ assert_eq!(con.command_count("HEXPIREAT"), 1);+ }++ #[tokio::test]+ async fn hash_set_keeps_explicit_key_ttl_and_missing_field_behavior() {+ for ttl in [Some(60), Some(0), Some(-1)] {+ let mut con = FakeRedisConnection::new(vec![RedisRawValue::Okay, RedisRawValue::Okay]);+ super::hash_set(&mut con, b"hash", "field", "value", ttl).await.unwrap();+ assert_eq!(con.command_count("HTTL"), 0);+ assert_eq!(con.command_count("HSET"), 1);+ assert_eq!(con.command_count("EXPIRE"), usize::from(ttl == Some(60)));+ }+ for response in [httl_response(1, -2), httl_response(1, -1), httl_response(0, -2)] {+ let mut con = FakeRedisConnection::new(vec![response, RedisRawValue::Okay]);+ super::hash_set(&mut con, b"hash", "field", "value", None).await.unwrap();+ assert_eq!(con.command_count("HSET"), 1);+ assert_eq!(con.command_count("HEXPIRE"), 0);+ }+ let mut con = FakeRedisConnection::new(vec![hscan_response("0", vec![])]);+ let page = super::load_more_collection(&mut con, b"hash", "hash", 0, 1, None, None).await.unwrap();+ assert!(matches!(page, RedisCollectionPage::Hash { items, scan_cursor: None } if items.is_empty()));+ assert_eq!(con.command_count("HTTL"), 0);+ }++ #[tokio::test]+ async fn legacy_hash_update_handles_encoding_only_in_discovery() {+ let mut con = FakeRedisConnection::new(vec![RedisRawValue::Int(2)]);+ super::hash_field_update(&mut con, b"hash", "old", "new", "value").await.unwrap();+ assert_eq!(con.commands.len(), 1);+ assert_eq!(con.command_count("EVAL"), 1);+ let script = &con.commands[0];+ let discovery =+ script.split("local ttl_reply =").nth(1).unwrap().split("local function restore_source").next().unwrap();+ assert!(discovery.contains("hash field expiration is not supported by legacy hash encoding"));+ let writes = script.split("local function restore_source").nth(1).unwrap();+ assert!(!writes.contains("legacy hash encoding"));+ }++ #[tokio::test]+ async fn legacy_hash_pages_keep_byte_and_sparse_scan_limits() {+ let value = "v".repeat(super::COLLECTION_PAGE_MAX_BYTES / 2);+ let mut con = FakeRedisConnection::with_results(vec![+ Ok(hscan_response("0", vec![("first", &value), ("second", &value)])),+ Err(legacy_hash_expiry_error()),+ Err(legacy_hash_expiry_error()),+ ]);+ let mut cursor = 0;+ for field in ["first", "second"] {+ let page = super::load_more_collection(&mut con, b"legacy-byte-limit", "hash", cursor, 200, None, None)+ .await+ .unwrap();+ let RedisCollectionPage::Hash { items, scan_cursor } = page else {+ panic!("expected hash page");+ };+ assert_eq!(items.len(), 1);+ assert_eq!(items[0].field, text_blob(field));+ assert_eq!(items[0].value, text_blob(&value));+ assert!(items[0].field_ttl.is_none());+ assert!(super::hash_item_page_bytes(&items[0]) <= super::COLLECTION_PAGE_MAX_BYTES);+ cursor = scan_cursor.unwrap_or(0);+ }+ assert_eq!(cursor, 0);+ assert_eq!(con.command_count("HSCAN"), 1);+ assert_eq!(con.command_count("HTTL"), 2);++ let mut responses = (1..=super::COLLECTION_FILTER_SCAN_MAX_ITERATIONS)+ .map(|cursor| Ok(hscan_response(&cursor.to_string(), vec![("field", "unmatched")])))+ .collect::<Vec<_>>();+ *responses.last_mut().unwrap() = Ok(hscan_response("10", vec![("field", "wanted")]));+ responses.push(Err(legacy_hash_expiry_error()));+ let mut con = FakeRedisConnection::with_results(responses);+ let page =+ super::load_more_collection(&mut con, b"legacy-sparse", "hash", 0, 20, Some("wanted"), None).await.unwrap();+ let RedisCollectionPage::Hash { items, scan_cursor } = page else {+ panic!("expected hash page");+ };+ assert_eq!(items.len(), 1);+ assert_eq!(items[0].value, text_blob("wanted"));+ assert!(items[0].field_ttl.is_none());+ assert_eq!(scan_cursor, Some(10));+ assert_eq!(con.command_count("HSCAN"), 10);+ assert_eq!(con.command_count("HTTL"), 1);+ }++ #[tokio::test]+ async fn hash_ttl_discovery_preserves_rust_permission_fallback() {+ let mut con = FakeRedisConnection::with_results(vec![+ Err(noperm("httl")),+ Ok(RedisRawValue::Okay),+ Ok(hscan_response("0", vec![("f", "v")])),+ Err(noperm("httl")),+ ]);+ super::hash_set(&mut con, b"hash", "field", "value", None).await.unwrap();+ let page = super::load_more_collection(&mut con, b"hash", "hash", 0, 1, None, None).await.unwrap();+ assert!(matches!(page, RedisCollectionPage::Hash { items, .. } if items[0].field_ttl.is_none()));+ assert_eq!(con.command_count("HTTL"), 2);+ assert_eq!(con.command_count("HSET"), 1);+ }++ #[tokio::test]+ async fn legacy_hash_fallback_keeps_write_and_scan_errors_visible() {+ let mut con = FakeRedisConnection::with_results(vec![Err(legacy_hash_expiry_error()), Err(noperm("hset"))]);+ assert!(super::hash_set(&mut con, b"hash", "field", "value", None).await.is_err());+ assert_eq!(con.command_count("HSET"), 1);+ assert_eq!(con.commands.len(), 2);+ let mut con = FakeRedisConnection::with_results(vec![+ Ok(httl_response(1, 42)),+ Ok(RedisRawValue::Okay),+ Err(legacy_hash_expiry_error()),+ ]);+ assert!(super::hash_set(&mut con, b"hash", "field", "value", None).await.is_err());+ assert_eq!(con.command_count("HEXPIRE"), 1);+ let mut con = FakeRedisConnection::with_results(vec![+ Ok(bulk("hash")),+ Ok(RedisRawValue::Int(-1)),+ Ok(RedisRawValue::Int(1)),+ Err(noperm("hscan")),+ ]);+ assert!(super::get_value(&mut con, b"hash").await.is_err());+ assert_eq!(con.command_count("HTTL"), 0);+ }++ #[tokio::test]+ #[ignore = "requires disposable Redis via DBX_TEST_REDIS_URL; injects Kvrocks HTTL replies into production Lua"]+ async fn hash_field_update_lua_legacy_encoding_regression() {+ let mut trace = FakeRedisConnection::new(vec![RedisRawValue::Int(2)]);+ super::hash_field_update(&mut trace, b"hash", "old", "new", "after").await.unwrap();+ let RedisRawValue::Array(args) = redis::parse_redis_value(trace.commands[0].as_bytes()).unwrap() else {+ panic!("expected EVAL arguments");+ };+ let script = String::from_utf8(redis_value_to_bytes(args[1].clone()).unwrap()).unwrap();+ let probe = "redis.pcall('HTTL', key, 'FIELDS', 1, old_field)";+ assert_eq!(script.matches(probe).count(), 1);+ let url = std::env::var("DBX_TEST_REDIS_URL").expect("DBX_TEST_REDIS_URL");+ let mut con = super::connect(&url, std::time::Duration::from_secs(5)).await.unwrap();+ let nonce = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();+ let key = format!("dbx-10948-{}-{nonce}", std::process::id());+ for (reply, success) in [+ ("Invalid argument: hash field expiration is not supported by legacy hash encoding", true),+ ("ERR Invalid argument: hash field expiration is not supported by legacy hash encoding", true),+ ("NOPERM no permission to run HTTL", false),+ ("WRONGTYPE Operation against a key holding the wrong kind of value", false),+ ("ERR operation not supported", false),+ (+ "ERR Invalid argument: hash field expiration is not supported by legacy hash encoding: extra failure",+ false,+ ),+ ] {+ let injected = script.replace(probe, &format!("{{err = '{reply}'}}"));+ for destination in ["old", "new"] {+ redis::cmd("DEL").arg(&key).query_async::<()>(&mut con).await.unwrap();+ redis::cmd("HSET")+ .arg(&key)+ .arg("old")+ .arg("before")+ .arg("keeper")+ .arg("keep")+ .query_async::<()>(&mut con)+ .await+ .unwrap();+ redis::cmd("EXPIRE").arg(&key).arg(60).query_async::<()>(&mut con).await.unwrap();+ let result: i64 = redis::cmd("EVAL")+ .arg(&injected)+ .arg(1)+ .arg(&key)+ .arg("old")+ .arg(destination)+ .arg("after")+ .query_async(&mut con)+ .await+ .unwrap();+ assert_eq!(+ result,+ if success {+ if destination == "old" {+ 1+ } else {+ 2+ }+ } else {+ -3+ },+ "{reply}"+ );+ let fields: HashMap<String, String> =+ redis::cmd("HGETALL").arg(&key).query_async(&mut con).await.unwrap();+ let expected = if success { (destination, "after") } else { ("old", "before") };+ assert_eq!(+ fields,+ HashMap::from([+ (expected.0.to_string(), expected.1.to_string()),+ ("keeper".to_string(), "keep".to_string()),+ ])+ );+ let ttl: i64 = redis::cmd("TTL").arg(&key).query_async(&mut con).await.unwrap();+ assert!((1..=60).contains(&ttl));+ }+ }+ redis::cmd("DEL").arg(&key).query_async::<()>(&mut con).await.unwrap();+ }+#[tokio::test]async fn hash_set_degrades_when_field_ttl_is_rejected_as_unknown_redis_command() {let unsupported = redis::RedisError::from((diff --git a/crates/dbx-driver-redis/tests/hash_compatibility.rs b/crates/dbx-driver-redis/tests/hash_compatibility.rsnew file mode 100644index 0000000000..4c0096034a--- /dev/null+++ b/crates/dbx-driver-redis/tests/hash_compatibility.rs@@ -0,0 +1,218 @@+use base64::Engine;+use dbx_driver_redis::{+ connect, get_value, hash_field_update, hash_set, load_more_collection, set_hash_field_expire_at,+ set_hash_field_ttl, RedisCollectionPage, RedisHashItem, RedisValueData,+};+use redis::aio::MultiplexedConnection;+use std::collections::HashMap;+use std::time::{Duration, SystemTime, UNIX_EPOCH};++fn fields(items: Vec<RedisHashItem>, expected_ttl: Option<i64>) -> HashMap<String, String> {+ items+ .into_iter()+ .map(|item| {+ assert_eq!(item.field_ttl, expected_ttl);+ let decode = |value: &str| {+ String::from_utf8(base64::engine::general_purpose::STANDARD.decode(value).unwrap()).unwrap()+ };+ (decode(&item.field.raw_base64), decode(&item.value.raw_base64))+ })+ .collect()+}++async fn snapshot(con: &mut MultiplexedConnection, key: &str) -> HashMap<String, String> {+ redis::cmd("HGETALL").arg(key).query_async(con).await.unwrap()+}++async fn field_ttl(con: &mut MultiplexedConnection, key: &str, field: &str) -> i64 {+ let ttls: Vec<i64> = redis::cmd("HTTL").arg(key).arg("FIELDS").arg(1).arg(field).query_async(con).await.unwrap();+ ttls[0]+}++async fn seed(con: &mut MultiplexedConnection, keys: &[String], kvrocks: bool) -> redis::RedisResult<()> {+ if kvrocks {+ redis::cmd("CONFIG").arg("SET").arg("hash-encoding-mode").arg("legacy").query_async::<()>(con).await?;+ }+ let mut command = redis::cmd("HSET");+ command.arg(&keys[0]);+ for index in 0..401 {+ command.arg(format!("f{index}")).arg(format!("v{index}"));+ }+ command.query_async::<()>(con).await?;+ if kvrocks {+ redis::cmd("CONFIG")+ .arg("SET")+ .arg("hash-encoding-mode")+ .arg("field-expiration")+ .query_async::<()>(con)+ .await?;+ }+ redis::cmd("HSET").arg(&keys[1]).arg("expiring").arg("before").query_async::<()>(con).await?;+ Ok(())+}++async fn exercise(mut con: MultiplexedConnection, keys: Vec<String>, flavor: String) {+ let key = &keys[0];+ let modern = &keys[1];+ let missing = &keys[2];+ let wrong_type = &keys[3];+ let expected_ttl = (flavor == "redis74").then_some(-1);+ redis::cmd("EXPIRE").arg(key).arg(300).query_async::<()>(&mut con).await.unwrap();+ let value = get_value(&mut con, key.as_bytes()).await.unwrap();+ assert!((1..=300).contains(&value.ttl));+ let RedisValueData::Hash { items, total, mut scan_cursor } = value.data else {+ panic!("expected hash");+ };+ assert_eq!(total, 401);+ assert!(!items.is_empty() && items.len() <= 200);+ let mut actual = fields(items, expected_ttl);+ let mut pages = 0;+ while let Some(cursor) = scan_cursor {+ pages += 1;+ assert!(pages < 100, "pagination failed to finish");+ let page = load_more_collection(&mut con, key.as_bytes(), "hash", cursor, 200, None, None).await.unwrap();+ let RedisCollectionPage::Hash { items, scan_cursor: next } = page else {+ panic!("expected hash page");+ };+ assert!(items.len() <= 200);+ actual.extend(fields(items, expected_ttl));+ scan_cursor = next;+ }+ assert!(pages > 0);+ assert_eq!(actual, (0..401).map(|index| (format!("f{index}"), format!("v{index}"))).collect());+ println!("PASS production listing/load-more: 401 fields, bounded pages, key TTL");++ hash_set(&mut con, key.as_bytes(), "added", "value", None).await.unwrap();+ hash_field_update(&mut con, key.as_bytes(), "f0", "f0", "edited").await.unwrap();+ assert_eq!(snapshot(&mut con, key).await["f0"], "edited");+ hash_field_update(&mut con, key.as_bytes(), "f0", "renamed", "moved").await.unwrap();+ let after = snapshot(&mut con, key).await;+ assert_eq!(after["added"], "value");+ assert_eq!(after["renamed"], "moved");+ assert!(!after.contains_key("f0"));+ assert!(hash_field_update(&mut con, key.as_bytes(), "f1", "f2", "collision").await.is_err());+ assert!(hash_field_update(&mut con, key.as_bytes(), "absent", "new", "missing").await.is_err());+ assert_eq!(snapshot(&mut con, key).await, after);+ let ttl: i64 = redis::cmd("TTL").arg(key).query_async(&mut con).await.unwrap();+ assert!((1..=300).contains(&ttl));+ println!("PASS production add/edit/rename/source deletion/collision/missing field/key TTL");++ if flavor != "redis74" {+ for result in [+ set_hash_field_ttl(&mut con, key.as_bytes(), "added", 120).await,+ set_hash_field_ttl(&mut con, key.as_bytes(), "added", -1).await,+ set_hash_field_expire_at(&mut con, key.as_bytes(), "added", 4_000_000_000).await,+ ] {+ let error = result.unwrap_err();+ if flavor == "kvrocks" {+ assert!(error.contains("hash field expiration is not supported by legacy hash encoding"), "{error}");+ } else {+ assert!(error.to_ascii_lowercase().contains("unknown command"), "{error}");+ }+ }+ assert_eq!(snapshot(&mut con, key).await, after);+ println!("PASS production explicit HEXPIRE/HPERSIST/HEXPIREAT errors remain visible");+ }++ if flavor != "redis72" {+ set_hash_field_ttl(&mut con, modern.as_bytes(), "expiring", 180).await.unwrap();+ for (old, new, value) in [("expiring", "expiring", "edited"), ("expiring", "renamed", "moved")] {+ let before = field_ttl(&mut con, modern, old).await;+ hash_set(&mut con, key.as_bytes(), "added", "legacy still works", None).await.unwrap();+ hash_set(&mut con, modern.as_bytes(), old, "overwrite", None).await.unwrap();+ let overwritten = field_ttl(&mut con, modern, old).await;+ assert!((1..=before).contains(&overwritten));+ hash_field_update(&mut con, modern.as_bytes(), old, new, value).await.unwrap();+ let remaining = field_ttl(&mut con, modern, new).await;+ assert!((1..=overwritten).contains(&remaining));+ assert_eq!(snapshot(&mut con, modern).await, HashMap::from([(new.to_string(), value.to_string())]));+ let RedisValueData::Hash { items, .. } = get_value(&mut con, modern.as_bytes()).await.unwrap().data else {+ panic!("expected hash");+ };+ assert_eq!(items.len(), 1);+ assert!(items[0].field_ttl.is_some_and(|ttl| (1..=remaining).contains(&ttl)));+ let RedisCollectionPage::Hash { items, .. } =+ load_more_collection(&mut con, modern.as_bytes(), "hash", 0, 200, None, None).await.unwrap()+ else {+ panic!("expected hash page");+ };+ assert_eq!(items.len(), 1);+ assert!(items[0].field_ttl.is_some_and(|ttl| (1..=remaining).contains(&ttl)));+ let RedisCollectionPage::Hash { items, .. } =+ load_more_collection(&mut con, key.as_bytes(), "hash", 0, 1, None, None).await.unwrap()+ else {+ panic!("expected hash page");+ };+ assert_eq!(items[0].field_ttl, expected_ttl);+ }+ set_hash_field_ttl(&mut con, modern.as_bytes(), "renamed", -1).await.unwrap();+ assert_eq!(field_ttl(&mut con, modern, "renamed").await, -1);+ let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs() as i64;+ set_hash_field_expire_at(&mut con, modern.as_bytes(), "renamed", now + 180).await.unwrap();+ assert!((1..=180).contains(&field_ttl(&mut con, modern, "renamed").await));+ println!("PASS production per-key TTL capability coexistence, remaining TTL on overwrite/edit/rename, explicit expiry");+ }++ assert!(hash_field_update(&mut con, missing.as_bytes(), "absent", "new", "value").await.is_err());+ let exists: bool = redis::cmd("EXISTS").arg(missing).query_async(&mut con).await.unwrap();+ assert!(!exists);+ let page = load_more_collection(&mut con, missing.as_bytes(), "hash", 0, 200, None, None).await.unwrap();+ assert!(matches!(page, RedisCollectionPage::Hash { items, scan_cursor: None } if items.is_empty()));+ hash_set(&mut con, missing.as_bytes(), "created", "value", None).await.unwrap();+ assert!(matches!(+ get_value(&mut con, missing.as_bytes()).await.unwrap().data,+ RedisValueData::Hash { total: 1, .. }+ ));+ hash_set(&mut con, missing.as_bytes(), "created", "value", Some(60)).await.unwrap();+ let ttl: i64 = redis::cmd("TTL").arg(missing).query_async(&mut con).await.unwrap();+ assert!((1..=60).contains(&ttl));+ println!("PASS production missing/empty hash, create, explicit key TTL");++ redis::cmd("SET").arg(wrong_type).arg("string").query_async::<()>(&mut con).await.unwrap();+ assert!(hash_set(&mut con, wrong_type.as_bytes(), "field", "value", None).await.is_err());+ assert!(load_more_collection(&mut con, wrong_type.as_bytes(), "hash", 0, 200, None, None).await.is_err());+ assert!(hash_field_update(&mut con, wrong_type.as_bytes(), "field", "new", "value").await.is_err());+ let value: String = redis::cmd("GET").arg(wrong_type).query_async(&mut con).await.unwrap();+ assert_eq!(value, "string");+ println!("PASS production WRONGTYPE errors preserve data");+}++#[tokio::test]+#[ignore = "requires disposable server via DBX_TEST_REDIS_URL and DBX_TEST_REDIS_FLAVOR=kvrocks|redis74|redis72"]+async fn production_hash_compatibility() {+ let url = std::env::var("DBX_TEST_REDIS_URL").expect("DBX_TEST_REDIS_URL");+ let flavor = std::env::var("DBX_TEST_REDIS_FLAVOR").expect("DBX_TEST_REDIS_FLAVOR");+ assert!(["kvrocks", "redis74", "redis72"].contains(&flavor.as_str()));+ let mut con = connect(&url, Duration::from_secs(5)).await.unwrap();+ let info: String = redis::cmd("INFO").arg("server").query_async(&mut con).await.unwrap();+ println!(+ "{}",+ info.lines()+ .filter(|line| line.contains("version:") || line.contains("git_sha1:"))+ .collect::<Vec<_>>()+ .join("\n")+ );+ let nonce = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();+ let keys: Vec<_> = (0..4).map(|index| format!("dbx-10948-{}-{nonce}-{index}", std::process::id())).collect();+ let kvrocks = flavor == "kvrocks";+ let original: Option<HashMap<String, String>> = if kvrocks {+ Some(redis::cmd("CONFIG").arg("GET").arg("hash-encoding-mode").query_async(&mut con).await.unwrap())+ } else {+ None+ };+ let seeded = seed(&mut con, &keys, kvrocks).await;+ if let Some(original) = original {+ redis::cmd("CONFIG")+ .arg("SET")+ .arg("hash-encoding-mode")+ .arg(&original["hash-encoding-mode"])+ .query_async::<()>(&mut con)+ .await+ .unwrap();+ }+ let outcome =+ if seeded.is_ok() { Some(tokio::spawn(exercise(con.clone(), keys.clone(), flavor)).await) } else { None };+ redis::cmd("DEL").arg(&keys).query_async::<()>(&mut con).await.unwrap();+ seeded.unwrap();+ outcome.unwrap().unwrap();+}