Struct postgres_array::Array

pub struct Array<T> { /* private fields */ }

A multi-dimensional array.

Implementations

impl<T> Array<T>

pub fn from_parts(data: Vec<T>, dimensions: Vec<Dimension>) -> Array<T>

Creates a new Array from its underlying components.

The data array should be provided in the higher-dimensional equivalent of row-major order.

Panics

Panics if the number of elements provided does not match the number of elements specified by the dimensions.

pub fn from_vec(data: Vec<T>, lower_bound: i32) -> Array<T>

Creates a new one-dimensional array.

pub fn wrap(&mut self, lower_bound: i32)

Wraps this array in a new dimension of size 1.

For example, the one dimensional array [1, 2] would turn into the two-dimensional array [[1, 2]].

pub fn push(&mut self, other: Array<T>)

Consumes another array, appending it to the top level dimension of this array.

The dimensions of the other array must be the same as the dimensions of this array with the first dimension removed. This includes lower bounds as well as lengths.

For example, if [3, 4] is pushed onto [[1, 2]], the result is [[1, 2], [3, 4]].

Panics

Panics if the dimensions of the two arrays do not match.

pub fn dimensions(&self) -> &[Dimension]

Returns the dimensions of this array.

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

Returns an iterator over references to the elements of the array in the higher-dimensional equivalent of row-major order.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator over mutable references to the elements of the array in the higher-dimensional equivalent of row-major order.

pub fn into_inner(self) -> Vec<T>

Returns the underlying data vector for this Array in the higher-dimensional equivalent of row-major order.

Trait Implementations

impl<T: Clone> Clone for Array<T>

fn clone(&self) -> Array<T>

Returns a copy of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Array<T>

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

Formats the value using the given formatter.

impl<T: Display> Display for Array<T>

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

Formats the value using the given formatter.

impl<'de, T> FromSql<'de> for Array<T>where
    T: FromSql<'de>,

fn from_sql(
    ty: &Type,
    raw: &'de [u8]
) -> Result<Array<T>, Box<dyn Error + Sync + Send>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql_null(
    ty: &Type
) -> Result<Self, Box<dyn Error + Send + Sync + 'static, Global>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable(
    ty: &Type,
    raw: Option<&'a [u8]>
) -> Result<Self, Box<dyn Error + Send + Sync + 'static, Global>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.

impl<T, I: ArrayIndex> Index<I> for Array<T>

Indexes into the Array, retrieving a reference to the contained value.

Since Arrays can be multi-dimensional, the Index trait is implemented for a variety of index types. In the most generic case, a &[i32] can be used. In addition, a bare i32 as well as tuples of up to 10 i32 values may be used for convenience.

Panics

Panics if the index does not correspond to an in-bounds element of the Array.

Examples

let mut array = Array::from_vec(vec![0i32, 1, 2, 3], 0);
assert_eq!(2, array[2]);

array.wrap(0);
array.push(Array::from_vec(vec![4, 5, 6, 7], 0));

assert_eq!(6, array[(1, 2)]);

type Output = T

The returned type after indexing.

fn index(&self, idx: I) -> &T

Performs the indexing (container[index]) operation.

impl<T, I: ArrayIndex> IndexMut<I> for Array<T>

fn index_mut(&mut self, idx: I) -> &mut T

Performs the mutable indexing (container[index]) operation.

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Iter<'a, T>

Creates an iterator from a value.

impl<'a, T: 'a> IntoIterator for &'a mut Array<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IterMut<'a, T>

Creates an iterator from a value.

impl<T> IntoIterator for Array<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> IntoIter<T>

Creates an iterator from a value.

impl<T: PartialEq> PartialEq<Array<T>> for Array<T>

fn eq(&self, other: &Array<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> ToSql for Array<T>where
    T: ToSql,

fn to_sql(
    &self,
    ty: &Type,
    w: &mut BytesMut
) -> Result<IsNull, Box<dyn Error + Sync + Send>>

Converts the value of self into the binary format of the specified Postgres Type, appending it to out.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be converted to the specified Postgres Type.

fn to_sql_checked(
    &self,
    ty: &Type,
    out: &mut BytesMut
) -> Result<IsNull, Box<dyn Error + Sync + Send>>

An adaptor method used internally by Rust-Postgres.

fn encode_format(&self, _ty: &Type) -> Format

Specify the encode format

impl<T: Eq> Eq for Array<T>

impl<T> StructuralEq for Array<T>

impl<T> StructuralPartialEq for Array<T>