Struct postgres_parser::sys::RowExpr

#[repr(C)]pub struct RowExpr {
    pub xpr: Expr,
    pub args: *mut List,
    pub row_typeid: Oid,
    pub row_format: CoercionForm,
    pub colnames: *mut List,
    pub location: c_int,
}

RowExpr a ROW() expression

Note: the list of fields must have a oneforone correspondence with physical fields of the associated rowtype, although it is okay for it to be shorter than the rowtype. That is, the N'th list element must match up with the N'th physical field. When the N'th physical field is a dropped column (attisdropped) then the N'th list element can just be a NULL constant. (This case can only occur for named composite types, not RECORD types, since those are built from the RowExpr itself rather than vice versa.) It is important not to assume that length(args) is the same as the number of columns logically present in the rowtype.

colnames provides field names in cases where the names can't easily be obtained otherwise. Names must be provided if row_typeid is RECORDOID. If row_typeid identifies a known composite type, colnames can be NIL to indicate the type's cataloged field names apply. Note that colnames can be nonNIL even for a composite type, and typically is when the RowExpr was created by expanding a wholerow Var. This is so that we can retain the column alias names of the RTE that the Var referenced (which would otherwise be very difficult to extract from the parsetree). Like the args list, colnames is oneforone with physical fields of the rowtype.

Fields

xpr: Expr

args: *mut List

row_typeid: Oid

the fields

row_format: CoercionForm

row_typeid cannot be a domain over composite, only plain composite. To create a composite domain value, apply CoerceToDomain to the RowExpr.

Note: we deliberately do NOT store a typmod. Although a typmod will be associated with specific RECORD types at runtime, it will differ for different backends, and so cannot safely be stored in stored parsetrees. We must assume typmod 1 for a RowExpr node.

We don't need to store a collation either. The result type is necessarily composite, and composite types never have a collation.

colnames: *mut List

how to display this node

location: c_int

list of String, or NIL

Trait Implementations

impl Debug for RowExpr

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

Formats the value using the given formatter.

impl Default for RowExpr

fn default() -> Self

Returns the "default value" for a type.

impl Eq for RowExpr

impl Hash for RowExpr

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<RowExpr> for RowExpr

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

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

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

This method tests for !=.

impl StructuralEq for RowExpr

impl StructuralPartialEq for RowExpr