Struct postgres_parser::sys::SubscriptingRef

#[repr(C)]pub struct SubscriptingRef {
    pub xpr: Expr,
    pub refcontainertype: Oid,
    pub refelemtype: Oid,
    pub reftypmod: int32,
    pub refcollid: Oid,
    pub refupperindexpr: *mut List,
    pub reflowerindexpr: *mut List,
    pub refexpr: *mut Expr,
    pub refassgnexpr: *mut Expr,
}

SubscriptingRef: describes a subscripting operation over a container (array, etc).

A SubscriptingRef can describe fetching a single element from a container, fetching a part of container (e.g. array slice), storing a single element into a container, or storing a slice. The "store" cases work with an initial container value and a source value that is inserted into the appropriate part of the container; the result of the operation is an entire new modified container value.

If reflowerindexpr = NIL, then we are fetching or storing a single container element at the subscripts given by refupperindexpr. Otherwise we are fetching or storing a container slice, that is a rectangular subcontainer with lower and upper bounds given by the index expressions. reflowerindexpr must be the same length as refupperindexpr when it is not NIL.

In the slice case, individual expressions in the subscript lists can be NULL, meaning "substitute the array's current lower or upper bound".

Note: the result datatype is the element type when fetching a single element; but it is the array type when doing subarray fetch or either type of store.

Note: for the cases where a container is returned, if refexpr yields a R/W expanded container, then the implementation is allowed to modify that object inplace and return the same object.)

Fields

xpr: Expr

refcontainertype: Oid

refelemtype: Oid

type of the container proper

reftypmod: int32

type of the container elements

refcollid: Oid

typmod of the container (and elements too)

refupperindexpr: *mut List

OID of collation, or InvalidOid if none

reflowerindexpr: *mut List

expressions that evaluate to upper container indexes

refexpr: *mut Expr

expressions that evaluate to lower container indexes, or NIL for single container element

refassgnexpr: *mut Expr

the expression that evaluates to a container value

Trait Implementations

impl Debug for SubscriptingRef

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

Formats the value using the given formatter.

impl Default for SubscriptingRef

fn default() -> Self

Returns the "default value" for a type.

impl Eq for SubscriptingRef

impl Hash for SubscriptingRef

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<SubscriptingRef> for SubscriptingRef

fn eq(&self, other: &SubscriptingRef) -> bool

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

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

This method tests for !=.

impl StructuralEq for SubscriptingRef

impl StructuralPartialEq for SubscriptingRef