Struct Array

pub struct Array<'a, T: FromDatum> { /* private fields */ }

An array of some type (eg. TEXT[], int[])

While conceptually similar to a Vec<T>, arrays are lazy.

Using a Vec<T> here means each element of the passed array will be eagerly fetched and converted into a Rust type:

use pgx::prelude::*;

#[pg_extern]
fn with_vec(elems: Vec<String>) {
    // Elements all already converted.
    for elem in elems {
        todo!()
    }
}

Using an array, elements are only fetched and converted into a Rust type on demand:

use pgx::prelude::*;

#[pg_extern]
fn with_vec(elems: Array<String>) {
    // Elements converted one by one
    for maybe_elem in elems {
        let elem = maybe_elem.unwrap();
        todo!()
    }
}

Implementations

impl<'a, T: FromDatum> Array<'a, T>

pub fn into_array_type(self) -> *const ArrayType

pub fn as_slice(&self) -> &[T]

👎Deprecated since 0.5.0: this function cannot be safe and is not generically sound even unsafe fn as_slice(&self) -> &[T] is not sound for all &[T] if you are sure your usage is sound, consider RawArray

pub fn iter(&self) -> ArrayIterator<'_, T>

Return an Iterator of Option over the contained Datums.

pub fn iter_deny_null(&self) -> ArrayTypedIterator<'_, T>

Return an Iterator of the contained Datums (converted to Rust types).

This function will panic when called if the array contains any SQL NULL values.

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn get(&self, i: usize) -> Option<Option<T>>

Trait Implementations

impl<'a, T: FromDatum> Drop for Array<'a, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T: FromDatum> FromDatum for Array<'a, T>

unsafe fn from_polymorphic_datum( datum: Datum, is_null: bool, _typoid: Oid, ) -> Option<Array<'a, T>>

Like from_datum for instantiating polymorphic types which require preserving the dynamic type metadata.

const GET_TYPOID: bool = false

Should a type OID be fetched when calling from_datum?

unsafe fn from_datum(datum: Datum, is_null: bool) -> Option<Self>

where Self: Sized,

Safety

unsafe fn from_datum_in_memory_context( memory_context: PgMemoryContexts, datum: Datum, is_null: bool, typoid: Oid, ) -> Option<Self>

where Self: Sized,

Default implementation switched to the specified memory context and then simply calls FromDatum::from_datum(...) from within that context.

impl<'a, T: FromDatum> IntoIterator for Array<'a, T>

type Item = Option<T>

The type of the elements being iterated over.

type IntoIter = ArrayIntoIterator<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T: FromDatum + Serialize> Serialize for Array<'a, T>

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, T> SqlTranslatable for Array<'a, T>

where T: SqlTranslatable + FromDatum,

fn argument_sql() -> Result<SqlMapping, ArgumentError>

fn return_sql() -> Result<Returns, ReturnsError>

fn type_name() -> &'static str

fn variadic() -> bool

fn optional() -> bool

fn entity() -> FunctionMetadataTypeEntity