Make &FlatArray<Text> serializable to JSON

* Text varlena element for FlatArray
* Serialize FlatArray<Text>
* cover mixed-stride + empty edge cases for FlatArray<Text>

Author: isdaniel

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

@@ -11,7 +11,7 @@
 use core::ffi::CStr;
 use pgrx::Json;
 use pgrx::PostgresEnum;
-use pgrx::array::{FlatArray, RawArray};
+use pgrx::array::{FlatArray, RawArray, Text};
 use pgrx::memcx::MemCx;
 use pgrx::nullable::Nullable;
 use pgrx::palloc::PBox;
@@ -68,11 +68,10 @@ fn borrow_optional_array_with_default(
     values.unwrap().iter().map(|v| v.into_option().copied().unwrap_or(0)).sum()
 }
 
-// FIXME: replace with Text
-// #[pg_extern]
-// fn borrow_serde_serialize_array<'dat>(values: &FlatArray<'dat, &'dat str>) -> Json {
-//     Json(json! { { "values": values } })
-// }
+#[pg_extern]
+fn borrow_serde_serialize_array(values: &FlatArray<'_, pgrx::array::Text>) -> Json {
+    Json(json! { { "values": values } })
+}
 
 #[pg_extern]
 fn borrow_serde_serialize_array_i32(values: &FlatArray<'_, i32>) -> Json {
@@ -265,16 +264,36 @@ mod tests {
         assert_eq!(sum, Ok(Some(6f32)));
     }
 
-    // TODO: fix this test by redesigning SPI.
-    // #[pg_test]
-    // fn borrow_test_serde_serialize_array() -> Result<(), pgrx::spi::Error> {
-    //     let json = Spi::get_one::<Json>(
-    //         "SELECT borrow_serde_serialize_array(ARRAY['one', null, 'two', 'three'])",
-    //     )?
-    //     .expect("returned json was null");
-    //     assert_eq!(json.0, json! {{"values": ["one", null, "two", "three"]}});
-    //     Ok(())
-    // }
+    #[pg_test]
+    fn borrow_test_serde_serialize_array() -> Result<(), pgrx::spi::Error> {
+        let json = Spi::get_one::<Json>(
+            "SELECT borrow_serde_serialize_array(ARRAY['one', null, 'two', 'three'])",
+        )?
+        .expect("returned json was null");
+        assert_eq!(json.0, json! {{"values": ["one", null, "two", "three"]}});
+        Ok(())
+    }
+
+    #[pg_test]
+    fn borrow_test_serde_serialize_array_mixed() -> Result<(), pgrx::spi::Error> {
+        // Stride stress: empty string, null, multibyte, and a >127-byte element
+        // (forces a 4-byte varlena header next to 1-byte ones). Mis-stride corrupts tail.
+        let long = "x".repeat(200);
+        let json = Spi::get_one::<Json>(&format!(
+            "SELECT borrow_serde_serialize_array(ARRAY['', null, '日本語', '{long}', 'z'])"
+        ))?
+        .expect("returned json was null");
+        assert_eq!(json.0, json! {{"values": ["", null, "日本語", long, "z"]}});
+        Ok(())
+    }
+
+    #[pg_test]
+    fn borrow_test_serde_serialize_array_empty() -> Result<(), pgrx::spi::Error> {
+        let json = Spi::get_one::<Json>("SELECT borrow_serde_serialize_array(ARRAY[]::text[])")?
+            .expect("returned json was null");
+        assert_eq!(json.0, json! {{"values": []}});
+        Ok(())
+    }
 
     #[pg_test]
     fn borrow_test_optional_array_with_default() {

pgrx/src/array.rs

@@ -31,6 +31,7 @@ mod element;
 mod flat_array;
 mod port;
 
+pub use crate::datum::Text;
 pub use element::Element;
 pub use flat_array::{ArrayAllocError, FlatArray};
 

pgrx/src/array/flat_array.rs

@@ -395,6 +395,12 @@ where
     }
 }
 
+impl serde::Serialize for FlatArray<'_, super::Text> {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        s.collect_seq(self.iter().map(|n| n.into_option().map(|t| t.as_str())))
+    }
+}
+
 impl<'arr, T> ExactSizeIterator for ArrayIter<'arr, T> where T: ?Sized + Element {}
 impl<'arr, T> FusedIterator for ArrayIter<'arr, T> where T: ?Sized + Element {}
 

pgrx/src/datum/borrow.rs

@@ -140,3 +140,46 @@ unsafe impl Element for ffi::CStr {
         unsafe { ffi::CStr::from_ptr(char_ptr) }
     }
 }
+
+/// A borrowed Postgres `text` varlena, usable as a `FlatArray` element.
+#[repr(transparent)]
+pub struct Text([u8]);
+
+impl Text {
+    /// The string contents (UTF-8), excluding the varlena header.
+    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()) }
+    }
+}
+
+unsafe impl DatumPass for Text {
+    const PASS: PassBy = PassBy::Ref;
+}
+unsafe impl Element for Text {
+    unsafe fn point_from(ptr: ptr::NonNull<u8>) -> ptr::NonNull<Self> {
+        // full varlena size so size_of_val == storage, keeping ArrayIter stride sound
+        let len = unsafe { crate::varlena::varsize_any(ptr.as_ptr().cast()) };
+        unsafe {
+            ptr::NonNull::new_unchecked(
+                ptr::slice_from_raw_parts_mut(ptr.as_ptr(), len) as *mut Self
+            )
+        }
+    }
+}
+
+unsafe impl pgrx_sql_entity_graph::metadata::SqlTranslatable for Text {
+    const TYPE_IDENT: &'static str = "Text";
+    const TYPE_ORIGIN: pgrx_sql_entity_graph::metadata::TypeOrigin =
+        pgrx_sql_entity_graph::metadata::TypeOrigin::External;
+    const ARGUMENT_SQL: Result<
+        pgrx_sql_entity_graph::metadata::SqlMappingRef,
+        pgrx_sql_entity_graph::metadata::ArgumentError,
+    > = Ok(pgrx_sql_entity_graph::metadata::SqlMappingRef::literal("text"));
+    const RETURN_SQL: Result<
+        pgrx_sql_entity_graph::metadata::ReturnsRef,
+        pgrx_sql_entity_graph::metadata::ReturnsError,
+    > = Ok(pgrx_sql_entity_graph::metadata::ReturnsRef::One(
+        pgrx_sql_entity_graph::metadata::SqlMappingRef::literal("text"),
+    ));
+}