diff --git a/crates/dbx-core/src/db/postgres.rs b/crates/dbx-core/src/db/postgres.rs index fa29a66b0d..5dedfe838f 100644 --- a/crates/dbx-core/src/db/postgres.rs +++ b/crates/dbx-core/src/db/postgres.rs @@ -134,6 +134,118 @@ fn pg_float_number(v: f64) -> serde_json::Value { serde_json::Number::from_f64(v).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null) } +fn decode_pg_network_address_bytes(raw: &[u8], force_cidr_output: bool) -> Option { + let family = *raw.first()?; + let bits = *raw.get(1)?; + let is_cidr = *raw.get(2)? != 0; + let addr_len = *raw.get(3)? as usize; + let addr = raw.get(4..)?; + if addr.len() != addr_len { + return None; + } + + let (address, host_bits) = match (family, addr_len) { + (2, 4) => { + let bytes: [u8; 4] = addr.try_into().ok()?; + (std::net::IpAddr::V4(std::net::Ipv4Addr::from(bytes)).to_string(), 32) + } + (3, 16) => { + let bytes: [u8; 16] = addr.try_into().ok()?; + (std::net::IpAddr::V6(std::net::Ipv6Addr::from(bytes)).to_string(), 128) + } + _ => return None, + }; + + if bits > host_bits { + return None; + } + + if force_cidr_output || is_cidr || bits != host_bits { + Some(format!("{address}/{bits}")) + } else { + Some(address) + } +} + +fn decode_pg_macaddr_bytes(raw: &[u8]) -> Option { + if !matches!(raw.len(), 6 | 8) { + return None; + } + Some(raw.iter().map(|byte| format!("{byte:02x}")).collect::>().join(":")) +} + +fn decode_pg_bit_string_bytes(raw: &[u8]) -> Option { + let mut cursor = 0; + let bit_len = read_i32_be(raw, &mut cursor)?; + if bit_len < 0 { + return None; + } + let bit_len = bit_len as usize; + let data = raw.get(cursor..)?; + if data.len() != bit_len.div_ceil(8) { + return None; + } + + let mut bits = String::with_capacity(bit_len); + for index in 0..bit_len { + let byte = data[index / 8]; + let bit = (byte >> (7 - (index % 8))) & 1; + bits.push(if bit == 1 { '1' } else { '0' }); + } + Some(bits) +} + +fn pg_network_address_to_json_value(row: &Row, idx: usize, force_cidr_output: bool) -> Option { + row.try_get::<_, PgRawBytes>(idx) + .ok() + .and_then(|raw| decode_pg_network_address_bytes(&raw.0, force_cidr_output)) + .map(serde_json::Value::String) +} + +fn pg_macaddr_to_json_value(row: &Row, idx: usize) -> Option { + row.try_get::<_, PgRawBytes>(idx) + .ok() + .and_then(|raw| decode_pg_macaddr_bytes(&raw.0)) + .map(serde_json::Value::String) +} + +fn pg_bit_string_to_json_value(row: &Row, idx: usize) -> Option { + row.try_get::<_, PgRawBytes>(idx) + .ok() + .and_then(|raw| decode_pg_bit_string_bytes(&raw.0)) + .map(serde_json::Value::String) +} + +fn pg_network_address_array_to_json_value(row: &Row, idx: usize, force_cidr_output: bool) -> Option { + row.try_get::<_, Vec>>(idx).ok().map(|values| { + pg_optional_array_to_json(values, |raw| { + decode_pg_network_address_bytes(&raw.0, force_cidr_output) + .map(serde_json::Value::String) + .unwrap_or_else(|| super::binary_value_to_json(&raw.0)) + }) + }) +} + +fn pg_macaddr_array_to_json_value(row: &Row, idx: usize) -> Option { + row.try_get::<_, Vec>>(idx).ok().map(|values| { + pg_optional_array_to_json(values, |raw| { + decode_pg_macaddr_bytes(&raw.0) + .map(serde_json::Value::String) + .unwrap_or_else(|| super::binary_value_to_json(&raw.0)) + }) + }) +} + +fn pg_bit_string_array_to_json_value(row: &Row, idx: usize) -> Option { + row.try_get::<_, Vec>>(idx).ok().map(|values| { + pg_optional_array_to_json(values, |raw| { + decode_pg_bit_string_bytes(&raw.0) + .map(serde_json::Value::String) + .unwrap_or_else(|| super::binary_value_to_json(&raw.0)) + }) + }) +} + fn pg_array_to_json_value(row: &Row, idx: usize) -> Option { if let Ok(values) = row.try_get::<_, Vec>>(idx) { return Some(pg_optional_array_to_json(values, serde_json::Value::String)); @@ -239,6 +351,18 @@ fn pg_value_to_json(row: &Row, idx: usize, type_name: &str) -> serde_json::Value .unwrap_or(serde_json::Value::Null); } + if matches!(upper.as_str(), "INET" | "CIDR") { + return pg_network_address_to_json_value(row, idx, upper == "CIDR").unwrap_or(serde_json::Value::Null); + } + + if matches!(upper.as_str(), "MACADDR" | "MACADDR8") { + return pg_macaddr_to_json_value(row, idx).unwrap_or(serde_json::Value::Null); + } + + if matches!(upper.as_str(), "BIT" | "VARBIT") { + return pg_bit_string_to_json_value(row, idx).unwrap_or(serde_json::Value::Null); + } + if upper == "TSVECTOR" { return row .try_get::<_, PgRawBytes>(idx) @@ -252,6 +376,18 @@ fn pg_value_to_json(row: &Row, idx: usize, type_name: &str) -> serde_json::Value return pg_system_u32_to_json(row, idx).unwrap_or(serde_json::Value::Null); } + if matches!(upper.as_str(), "_INET" | "_CIDR") { + return pg_network_address_array_to_json_value(row, idx, upper == "_CIDR").unwrap_or(serde_json::Value::Null); + } + + if matches!(upper.as_str(), "_MACADDR" | "_MACADDR8") { + return pg_macaddr_array_to_json_value(row, idx).unwrap_or(serde_json::Value::Null); + } + + if matches!(upper.as_str(), "_BIT" | "_VARBIT") { + return pg_bit_string_array_to_json_value(row, idx).unwrap_or(serde_json::Value::Null); + } + if upper.starts_with('_') { return pg_array_to_json_value(row, idx).unwrap_or(serde_json::Value::Null); } @@ -2235,6 +2371,65 @@ mod tests { (0..hex.len()).step_by(2).map(|idx| u8::from_str_radix(&hex[idx..idx + 2], 16).unwrap()).collect() } + #[test] + fn decodes_postgres_inet_binary_output() { + assert_eq!( + decode_pg_network_address_bytes(&decode_hex("02200004c0a8010a"), false).as_deref(), + Some("192.168.1.10") + ); + assert_eq!( + decode_pg_network_address_bytes(&decode_hex("0310001020010db8abcd00120000000000000001"), false).as_deref(), + Some("2001:db8:abcd:12::1/16") + ); + assert_eq!( + decode_pg_network_address_bytes(&decode_hex("0340001020010db8abcd00120000000000000001"), false).as_deref(), + Some("2001:db8:abcd:12::1/64") + ); + } + + #[test] + fn decodes_postgres_cidr_binary_output() { + assert_eq!( + decode_pg_network_address_bytes(&decode_hex("02180104c0a80100"), true).as_deref(), + Some("192.168.1.0/24") + ); + assert_eq!( + decode_pg_network_address_bytes(&decode_hex("02200104c0a8010a"), true).as_deref(), + Some("192.168.1.10/32") + ); + assert_eq!( + decode_pg_network_address_bytes(&decode_hex("0380011000000000000000000000000000000001"), true).as_deref(), + Some("::1/128") + ); + } + + #[test] + fn rejects_invalid_postgres_network_binary_output() { + assert_eq!(decode_pg_network_address_bytes(&[], false), None); + assert_eq!(decode_pg_network_address_bytes(&decode_hex("04200004c0a8010a"), false), None); + assert_eq!(decode_pg_network_address_bytes(&decode_hex("02210004c0a8010a"), false), None); + assert_eq!(decode_pg_network_address_bytes(&decode_hex("02200004c0a801"), false), None); + } + + #[test] + fn decodes_postgres_macaddr_binary_output() { + assert_eq!(decode_pg_macaddr_bytes(&decode_hex("08002b010203")).as_deref(), Some("08:00:2b:01:02:03")); + assert_eq!( + decode_pg_macaddr_bytes(&decode_hex("08002bfffe010203")).as_deref(), + Some("08:00:2b:ff:fe:01:02:03") + ); + assert_eq!(decode_pg_macaddr_bytes(&decode_hex("08002b")), None); + } + + #[test] + fn decodes_postgres_bit_string_binary_output() { + assert_eq!(decode_pg_bit_string_bytes(&decode_hex("00000005a8")).as_deref(), Some("10101")); + assert_eq!(decode_pg_bit_string_bytes(&decode_hex("00000009a880")).as_deref(), Some("101010001")); + assert_eq!(decode_pg_bit_string_bytes(&decode_hex("00000000")).as_deref(), Some("")); + assert_eq!(decode_pg_bit_string_bytes(&decode_hex("00000005a8ff")), None); + assert_eq!(decode_pg_bit_string_bytes(&decode_hex("ffffffff")), None); + } + #[test] fn ewkb_point_with_srid_formats_as_wkt() { let raw = decode_hex("0101000020E6100000C520B07268195D404E62105839F44340");