Fix error message to include Text as a valid type for FlatArray

Add function to calculate total length of non-null Text elements in FlatArray and add more tests for serializing FlatArray<Text>

Author: isdaniel

pgrx-unit-tests/src/tests/array_borrowed.rs

@@ -79,6 +79,12 @@ fn borrow_serde_serialize_array_i32(values: &FlatArray<'_, i32>) -> Json {
     Json(json! { { "values": values } })
 }
 
+// Exercises `Text::as_str` directly (not via serde): sum of UTF-8 byte lengths of the non-null elements. Verifies the varlena header is excluded from the data.
+#[pg_extern]
+fn borrow_text_total_len(values: &FlatArray<'_, pgrx::array::Text>) -> i64 {
+    values.iter().filter_map(|n| n.into_option()).map(|t| t.as_str().len() as i64).sum()
+}
+
 #[pg_extern]
 fn borrow_return_text_array() -> Vec<&'static str> {
     vec!["a", "b", "c", "d"]
@@ -295,6 +301,73 @@ mod tests {
         Ok(())
     }
 
+    #[pg_test]
+    fn borrow_test_serde_serialize_array_no_nulls() -> Result<(), pgrx::spi::Error> {
+        // No nulls => Postgres omits the null bitmap, exercising the None-bitmap iterator branch.
+        let json = Spi::get_one::<Json>("SELECT borrow_serde_serialize_array(ARRAY['a','b','c'])")?
+            .expect("returned json was null");
+        assert_eq!(json.0, json! {{"values": ["a", "b", "c"]}});
+        Ok(())
+    }
+
+    #[pg_test]
+    fn borrow_test_serde_serialize_array_all_nulls() -> Result<(), pgrx::spi::Error> {
+        let json = Spi::get_one::<Json>(
+            "SELECT borrow_serde_serialize_array(ARRAY[null,null,null]::text[])",
+        )?
+        .expect("returned json was null");
+        assert_eq!(json.0, json! {{"values": [null, null, null]}});
+        Ok(())
+    }
+
+    #[pg_test]
+    fn borrow_test_serde_serialize_array_json_special_chars() -> Result<(), pgrx::spi::Error> {
+        // Quote, backslash, newline, and tab must be serde-escaped, not emitted raw.
+        let json = Spi::get_one::<Json>(
+            r#"SELECT borrow_serde_serialize_array(ARRAY[E'a"b\\c', E'line1\nline2', E'\t'])"#,
+        )?
+        .expect("returned json was null");
+        assert_eq!(json.0, json! {{"values": ["a\"b\\c", "line1\nline2", "\t"]}});
+        Ok(())
+    }
+
+    #[pg_test]
+    fn borrow_test_serde_serialize_array_header_boundary() -> Result<(), pgrx::spi::Error> {
+        // Postgres switches from a 1-byte to a 4-byte varlena header at ~126 bytes.
+        // Place elements on both sides of that boundary adjacent to each other so a
+        // wrong stride would corrupt the following element.
+        let s125 = "a".repeat(125);
+        let s126 = "b".repeat(126);
+        let s127 = "c".repeat(127);
+        let json = Spi::get_one::<Json>(&format!(
+            "SELECT borrow_serde_serialize_array(ARRAY['{s125}','{s126}','{s127}','z'])"
+        ))?
+        .expect("returned json was null");
+        assert_eq!(json.0, json! {{"values": [s125, s126, s127, "z"]}});
+        Ok(())
+    }
+
+    #[pg_test]
+    fn borrow_test_text_as_str_len() {
+        // 'ab' (2) + null (skipped) + '日本語' (9 UTF-8 bytes) = 11; header excluded.
+        let len = Spi::get_one::<i64>(
+            "SELECT borrow_text_total_len(ARRAY['ab', null, '日本語']::text[])",
+        );
+        assert_eq!(len, Ok(Some(11)));
+    }
+
+    #[pg_test]
+    fn borrow_test_text_as_str_len_empty_and_all_null() {
+        assert_eq!(
+            Spi::get_one::<i64>("SELECT borrow_text_total_len(ARRAY[]::text[])"),
+            Ok(Some(0))
+        );
+        assert_eq!(
+            Spi::get_one::<i64>("SELECT borrow_text_total_len(ARRAY[null,null]::text[])"),
+            Ok(Some(0))
+        );
+    }
+
     #[pg_test]
     fn borrow_test_optional_array_with_default() {
         let sum = Spi::get_one::<i32>("SELECT borrow_optional_array_with_default(ARRAY[1,2,3])");

pgrx-unit-tests/tests/compile-fail/no-arrays-of-arrays.stderr

@@ -9,10 +9,10 @@ error[E0277]: the trait bound `FlatArray<'_, i32>: pgrx::array::Element` is not
             Date
             Oid
             Point
+            Text
             Time
             TimeWithTimeZone
             Timestamp
-            TimestampWithTimeZone
           and $N others
   = note: required for `FlatArray<'_, FlatArray<'_, i32>>` to implement `SqlTranslatable`
   = note: 1 redundant requirement hidden

pgrx/src/datum/borrow.rs

@@ -146,10 +146,12 @@ unsafe impl Element for ffi::CStr {
 pub struct Text([u8]);
 
 impl Text {
-    /// The string contents (UTF-8), excluding the varlena header.
+    /// The string contents, excluding the varlena header.
+    ///
+    /// Uses pgrx's encoding-aware conversion: when the database encoding isn't guaranteed UTF-8 (e.g. `SQL_ASCII`), the bytes are validated and this panics on non-UTF-8 data — same behavior as reading a `text` datum as `&str`.
     pub fn as_str(&self) -> &str {
-        // SAFETY: tail is a valid varlena; Postgres text is UTF-8 in pgrx's server encodings
-        unsafe { crate::varlena::text_to_rust_str_unchecked(self.0.as_ptr().cast()) }
+        // SAFETY: tail is a valid varlena
+        unsafe { crate::datum::from::convert_varlena_to_str_memoized(self.0.as_ptr().cast()) }
     }
 }
 

pgrx/src/datum/from.rs

@@ -386,7 +386,9 @@ impl<'a> FromDatum for &'a str {
 
 // This is not marked inline on purpose, to allow it to be in a single code section
 // which is then branch-predicted on every time by the CPU.
-unsafe fn convert_varlena_to_str_memoized<'a>(varlena: *const pg_sys::varlena) -> &'a str {
+pub(crate) unsafe fn convert_varlena_to_str_memoized<'a>(
+    varlena: *const pg_sys::varlena,
+) -> &'a str {
     match *crate::UTF8DATABASE {
         crate::Utf8Compat::Yes => varlena::text_to_rust_str_unchecked(varlena),
         crate::Utf8Compat::Maybe => varlena::text_to_rust_str(varlena)