Struct pgrx::stringinfo::StringInfo

pub struct StringInfo<AllocatedBy: WhoAllocated = AllocatedByRust> { /* private fields */ }

StringInfoData holds information about an extensible string that is allocated by Postgres’ memory system, but generally follows Rust’s drop semantics

Implementations

impl StringInfo<AllocatedByRust>

pub fn new() -> Self

Construct a new StringInfo of its default size, allocated in CurrentMemoryContext

Note that Postgres can only represent up to 1 gigabyte of data in a StringInfo

pub fn with_capacity(len: i32) -> Self

Construct a new StringInfo, allocated by Postgres in CurrentMemoryContext, ensuring it has a capacity of the specified len.

Note that Postgres can only represent up to 1 gigabyte of data in a StringInfo

impl StringInfo<AllocatedByPostgres>

pub unsafe fn from_pg(sid: StringInfo) -> Option<Self>

Construct a StringInfo from a Postgres-allocated pg_sys::StringInfo.

The backing pg_sys::StringInfo structure will be freed whenever the memory context in which it was originally allocated is reset.

Safety

This function is unsafe as it cannot confirm the provided pg_sys::StringInfo pointer is valid

impl<AllocatedBy: WhoAllocated> StringInfo<AllocatedBy>

pub fn len(&self) -> usize

What is the length, excluding the trailing null byte

pub fn is_empty(&self) -> bool

Do we have any characters?

pub fn push(&mut self, ch: char)

Push a Rust character onto the end. A Rust char could be 4 bytes in total, so it is converted into a String first to ensure unicode correctness

pub fn push_str(&mut self, s: &str)

Push a String reference onto the end

pub fn push_bytes(&mut self, bytes: &[u8])

Push arbitrary bytes onto the end. Any byte sequence is allowed, including those with embedded NULLs

Panics

This function will panic if the length of bytes is larger than an i32

pub unsafe fn push_raw(&mut self, ptr: *const c_char, len: i32)

Push the bytes behind a raw pointer of a given length onto the end

Safety

This function is unsafe as we cannot ensure the specified ptr and len arguments are what you say that are and otherwise in agreement

pub fn reset(&mut self)

Reset the size of the StringInfo back to zero-length. This does/// not* free any previously-allocated memory

pub fn enlarge(&mut self, needed: i32)

Ensure that this StringInfo is at least needed bytes long

pub fn as_str(&self) -> Result<&str, Utf8Error>

A &str representation.

Errors

If the contained bytes aren’t valid UTF8, a [UTF8Error] is returned. Postgres StringInfo is allowed to contain non-UTF8 byte sequences, so this is a real possibility.

pub fn as_ptr(&self) -> *const c_char

A pointer to the backing bytes

pub fn as_mut_ptr(&self) -> *mut c_char

A mutable pointer to the backing bytes

pub fn as_bytes(&self) -> &[u8]

A &[u8] byte slice representation

pub fn as_bytes_mut(&mut self) -> &mut [u8]

A mutable &[u8] byte slice representation

pub fn into_pg(self) -> *mut StringInfoData

Convert this StringInfo into one that is wholly owned and now managed by Postgres

pub fn into_char_ptr(self) -> *const c_char

Convert this StringInfo into a "char *" that is wholly owned and now managed by Postgres

Trait Implementations

impl Default for StringInfo<AllocatedByRust>

fn default() -> Self

Returns the “default value” for a type.

impl<AllocatedBy: WhoAllocated> Display for StringInfo<AllocatedBy>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Convert this StringInfo into a Rust string. This uses String::from_utf8_lossy as it’s fine for a Postgres StringInfo to contain null bytes and also not even be proper UTF8.

impl<AllocatedBy: WhoAllocated> Drop for StringInfo<AllocatedBy>

fn drop(&mut self)

Executes the destructor for this type.

impl From<&[u8]> for StringInfo<AllocatedByRust>

fn from(v: &[u8]) -> Self

Converts to this type from the input type.

impl From<&str> for StringInfo<AllocatedByRust>

fn from(s: &str) -> Self

Converts to this type from the input type.

impl From<String> for StringInfo<AllocatedByRust>

fn from(s: String) -> Self

Converts to this type from the input type.

impl<AllocatedBy: WhoAllocated> From<StringInfo<AllocatedBy>> for &'static CStr

fn from(val: StringInfo<AllocatedBy>) -> Self

Converts to this type from the input type.

impl From<Vec<u8, Global>> for StringInfo<AllocatedByRust>

fn from(v: Vec<u8>) -> Self

Converts to this type from the input type.

impl<AllocatedBy: WhoAllocated> Write for StringInfo<AllocatedBy>

fn write(&mut self, buf: &[u8]) -> Result<usize, Error>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<(), Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl<AllocatedBy: WhoAllocated> Write for StringInfo<AllocatedBy>

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.