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(postgres): decode multi-dimensional arrays as server literals

t8y23b9cd3eec4df
diff --git a/crates/dbx-core/src/db/postgres.rs b/crates/dbx-core/src/db/postgres.rs
index e02eb42788..fb14de32db 100644
--- a/crates/dbx-core/src/db/postgres.rs
+++ b/crates/dbx-core/src/db/postgres.rs
@@ -266,6 +266,199 @@ fn format_pg_money(value: i64) -> String {
}
}
+/// A `FromSql` adapter for PostgreSQL arrays of any dimension. tokio-postgres's
+/// `Vec<T>` rejects arrays with more than one dimension, and a multi-
+/// dimensional column carries the same array OID as its flat counterpart, so
+/// `'{{1,2},{3,4}}'::int[]` fell through every probe in the array chain and
+/// rendered as NULL (#8457). Renders PostgreSQL's own array literal syntax.
+struct PgNdimArrayLiteral(String);
+
+impl<'a> FromSql<'a> for PgNdimArrayLiteral {
+ fn from_sql(_: &Type, raw: &'a [u8]) -> Result<Self, Box<dyn std::error::Error + Sync + Send>> {
+ pg_ndim_array_literal(raw).map(Self).ok_or_else(|| "invalid PostgreSQL array binary value".into())
+ }
+
+ fn accepts(ty: &Type) -> bool {
+ matches!(ty.kind(), Kind::Array(_))
+ }
+}
+
+fn pg_ndim_array_literal(raw: &[u8]) -> Option<String> {
+ fn read_i32(raw: &[u8], cursor: &mut usize) -> Option<i32> {
+ let bytes = raw.get(*cursor..*cursor + 4)?.try_into().ok()?;
+ *cursor += 4;
+ Some(i32::from_be_bytes(bytes))
+ }
+
+ let mut cursor = 0usize;
+ let ndim = read_i32(raw, &mut cursor)?;
+ if !(1..=6).contains(&ndim) {
+ return None;
+ }
+ let _null_flags = read_i32(raw, &mut cursor)?;
+ let element_type = Type::from_oid(read_i32(raw, &mut cursor)? as u32);
+ let mut lengths = Vec::with_capacity(ndim as usize);
+ for _ in 0..ndim {
+ let len = read_i32(raw, &mut cursor)?;
+ if len < 0 {
+ return None;
+ }
+ lengths.push(len as usize);
+ let _lower_bound = read_i32(raw, &mut cursor)?;
+ }
+ let total = lengths.iter().try_fold(1usize, |acc, &len| acc.checked_mul(len))?;
+ let mut elements: Vec<Option<&[u8]>> = Vec::with_capacity(total);
+ for _ in 0..total {
+ let len = read_i32(raw, &mut cursor)?;
+ if len < 0 {
+ elements.push(None);
+ } else {
+ let bytes = raw.get(cursor..cursor + len as usize)?;
+ cursor += len as usize;
+ elements.push(Some(bytes));
+ }
+ }
+
+ let mut literal = String::new();
+ pg_ndim_array_group(&lengths, &elements, element_type.as_ref(), &mut literal);
+ Some(literal)
+}
+
+fn pg_ndim_array_group(dims: &[usize], elements: &[Option<&[u8]>], element_type: Option<&Type>, out: &mut String) {
+ out.push('{');
+ if dims.len() == 1 {
+ for (index, element) in elements.iter().enumerate() {
+ if index > 0 {
+ out.push(',');
+ }
+ match element {
+ None => out.push_str("NULL"),
+ Some(bytes) => out.push_str(&pg_ndim_array_element(element_type, bytes)),
+ }
+ }
+ } else {
+ let stride: usize = dims[1..].iter().product();
+ for index in 0..dims[0] {
+ if index > 0 {
+ out.push(',');
+ }
+ pg_ndim_array_group(&dims[1..], &elements[index * stride..(index + 1) * stride], element_type, out);
+ }
+ }
+ out.push('}');
+}
+
+fn pg_ndim_array_element(element_type: Option<&Type>, bytes: &[u8]) -> String {
+ match pg_ndim_array_element_json(element_type, bytes) {
+ serde_json::Value::String(text) => quote_pg_array_element(&text),
+ serde_json::Value::Bool(value) => (if value { "t" } else { "f" }).to_string(),
+ serde_json::Value::Number(number) => number.to_string(),
+ _ => "NULL".to_string(),
+ }
+}
+
+/// Quotes one array element the way `array_out` does: empty strings, NULL-like
+/// text, and anything containing structural characters or whitespace is
+/// double-quoted with embedded quotes and backslashes doubled.
+fn quote_pg_array_element(text: &str) -> String {
+ let needs_quoting = text.is_empty()
+ || text.eq_ignore_ascii_case("null")
+ || text.bytes().any(|b| matches!(b, b'{' | b'}' | b',' | b'"' | b'\\' | b' ' | b'\t' | b'\n' | b'\r'));
+ if !needs_quoting {
+ return text.to_string();
+ }
+ let mut quoted = String::with_capacity(text.len() + 2);
+ quoted.push('"');
+ for ch in text.chars() {
+ if ch == '"' || ch == '\\' {
+ quoted.push(ch);
+ }
+ quoted.push(ch);
+ }
+ quoted.push('"');
+ quoted
+}
+
+// Direct from_sql calls bypass the codec's accepts() gate, so every probe
+// must check the element type itself before decoding.
+fn pg_ndim_array_element_json(element_type: Option<&Type>, bytes: &[u8]) -> serde_json::Value {
+ let ty = match element_type {
+ Some(ty) => ty,
+ None => return serde_json::Value::String(String::from_utf8_lossy(bytes).into_owned()),
+ };
+ if <bool as FromSql>::accepts(ty) {
+ if let Ok(value) = <bool as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::Bool(value);
+ }
+ }
+ if <i8 as FromSql>::accepts(ty) {
+ if let Ok(value) = <i8 as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::Number(value.into());
+ }
+ }
+ if <i16 as FromSql>::accepts(ty) {
+ if let Ok(value) = <i16 as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::Number(value.into());
+ }
+ }
+ if <i32 as FromSql>::accepts(ty) {
+ if let Ok(value) = <i32 as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::Number(value.into());
+ }
+ }
+ if <i64 as FromSql>::accepts(ty) {
+ if let Ok(value) = <i64 as FromSql>::from_sql(ty, bytes) {
+ return super::safe_i64_to_json(value);
+ }
+ }
+ if <f32 as FromSql>::accepts(ty) {
+ if let Ok(value) = <f32 as FromSql>::from_sql(ty, bytes) {
+ return pg_float_number(value as f64);
+ }
+ }
+ if <f64 as FromSql>::accepts(ty) {
+ if let Ok(value) = <f64 as FromSql>::from_sql(ty, bytes) {
+ return pg_float_number(value);
+ }
+ }
+ if *ty == Type::NUMERIC {
+ if let Some(text) = decode_pg_numeric_bytes(bytes) {
+ return serde_json::Value::String(text);
+ }
+ }
+ if <uuid::Uuid as FromSql>::accepts(ty) {
+ if let Ok(value) = <uuid::Uuid as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::String(value.to_string());
+ }
+ }
+ if <chrono::NaiveDate as FromSql>::accepts(ty) {
+ if let Ok(value) = <chrono::NaiveDate as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::String(value.to_string());
+ }
+ }
+ if <chrono::NaiveTime as FromSql>::accepts(ty) {
+ if let Ok(value) = <chrono::NaiveTime as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::String(value.to_string());
+ }
+ }
+ if <chrono::NaiveDateTime as FromSql>::accepts(ty) {
+ if let Ok(value) = <chrono::NaiveDateTime as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::String(value.to_string());
+ }
+ }
+ if <chrono::DateTime<chrono::Utc> as FromSql>::accepts(ty) {
+ if let Ok(value) = <chrono::DateTime<chrono::Utc> as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::String(value.to_rfc3339());
+ }
+ }
+ if <String as FromSql>::accepts(ty) {
+ if let Ok(value) = <String as FromSql>::from_sql(ty, bytes) {
+ return serde_json::Value::String(value);
+ }
+ }
+ serde_json::Value::String(String::from_utf8_lossy(bytes).into_owned())
+}
+
/// A `FromSql` adapter that accepts any PostgreSQL type and returns the raw
/// bytes unchanged. Used to decode custom types like pgvector whose binary
/// format we handle ourselves.
@@ -668,6 +861,11 @@ fn pg_array_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
if let Ok(values) = row.try_get::<_, Vec<Option<PgAnyString>>>(idx) {
return Some(pg_optional_array_to_json(values, |v| serde_json::Value::String(v.0)));
}
+ // Multi-dimensional arrays share the array OID with flat ones but fail
+ // every Vec<T> probe above; fall back to the server's own literal form.
+ if let Ok(literal) = row.try_get::<_, PgNdimArrayLiteral>(idx) {
+ return Some(serde_json::Value::String(literal.0));
+ }
None
}
@@ -8489,6 +8687,68 @@ mod tests {
raw
}
+ fn postgres_ndim_array_binary(elem_type: &Type, dims: &[i32], elements: &[Option<Vec<u8>>]) -> Vec<u8> {
+ assert_eq!(dims.iter().map(|&len| len as usize).product::<usize>(), elements.len());
+ let mut raw = Vec::new();
+ raw.extend_from_slice(&i32::try_from(dims.len()).unwrap().to_be_bytes());
+ raw.extend_from_slice(&i32::from(elements.iter().any(Option::is_none)).to_be_bytes());
+ raw.extend_from_slice(&elem_type.oid().to_be_bytes());
+ for len in dims {
+ raw.extend_from_slice(&len.to_be_bytes());
+ raw.extend_from_slice(&1_i32.to_be_bytes());
+ }
+ for element in elements {
+ if let Some(element) = element {
+ raw.extend_from_slice(&i32::try_from(element.len()).unwrap().to_be_bytes());
+ raw.extend_from_slice(element);
+ } else {
+ raw.extend_from_slice(&(-1_i32).to_be_bytes());
+ }
+ }
+ raw
+ }
+
+ fn int4_bytes(value: i32) -> Vec<u8> {
+ value.to_be_bytes().to_vec()
+ }
+
+ fn text_bytes(value: &str) -> Vec<u8> {
+ value.as_bytes().to_vec()
+ }
+
+ #[test]
+ fn ndim_array_decodes_two_dimensional_integers_as_server_literal() {
+ // `SELECT '{{1,2,3},{4,5,6},{7,8,9}}'::int[]` — same _int4 OID as a
+ // flat array, but tokio-postgres's Vec<T> rejects ndim > 1 (#8457).
+ let raw = postgres_ndim_array_binary(
+ &Type::INT4,
+ &[3, 3],
+ &[1, 2, 3, 4, 5, 6, 7, 8, 9].iter().map(|&v| Some(int4_bytes(v))).collect::<Vec<_>>(),
+ );
+ let decoded = PgNdimArrayLiteral::from_sql(&Type::INT4_ARRAY, &raw).unwrap();
+ assert_eq!(decoded.0, "{{1,2,3},{4,5,6},{7,8,9}}");
+ }
+
+ #[test]
+ fn ndim_array_quotes_text_elements_and_renders_nulls() {
+ let raw = postgres_ndim_array_binary(
+ &Type::TEXT,
+ &[2, 2],
+ &[Some(text_bytes("a b")), Some(text_bytes("c,d")), Some(text_bytes("")), None],
+ );
+ let decoded = PgNdimArrayLiteral::from_sql(&Type::TEXT_ARRAY, &raw).unwrap();
+ assert_eq!(decoded.0, r#"{{"a b","c,d"},{"",NULL}}"#);
+ }
+
+ #[test]
+ fn ndim_array_renders_bool_and_double_scalars() {
+ let bool_raw = postgres_ndim_array_binary(&Type::BOOL, &[2], &[Some(vec![1]), Some(vec![0])]);
+ assert_eq!(PgNdimArrayLiteral::from_sql(&Type::BOOL_ARRAY, &bool_raw).unwrap().0, "{t,f}");
+
+ let float_raw = postgres_ndim_array_binary(&Type::FLOAT8, &[2], &[Some(1.5f64.to_be_bytes().to_vec()), None]);
+ assert_eq!(PgNdimArrayLiteral::from_sql(&Type::FLOAT8_ARRAY, &float_raw).unwrap().0, "{1.5,NULL}");
+ }
+
#[test]
fn postgres_numeric_binary_values_preserve_arbitrary_precision() {
assert_eq!(decode_pg_numeric_bytes(&postgres_numeric_binary(0, 0x0000, 0, &[])).as_deref(), Some("0"));