Struct postgres_parser::sys::CaseExpr

#[repr(C)]pub struct CaseExpr {
    pub xpr: Expr,
    pub casetype: Oid,
    pub casecollid: Oid,
    pub arg: *mut Expr,
    pub args: *mut List,
    pub defresult: *mut Expr,
    pub location: c_int,
}

CaseExpr a CASE expression

We support two distinct forms of CASE expression: CASE WHEN boolexpr THEN expr [ WHEN boolexpr THEN expr ... ] CASE testexpr WHEN compexpr THEN expr [ WHEN compexpr THEN expr ... ] These are distinguishable by the "arg" field being NULL in the first case and the testexpr in the second case.

In the raw grammar output for the second form, the condition expressions of the WHEN clauses are just the comparison values. Parse analysis converts these to valid boolean expressions of the form CaseTestExpr '=' compexpr where the CaseTestExpr node is a placeholder that emits the correct value at runtime. This structure is used so that the testexpr need be evaluated only once. Note that after parse analysis, the condition expressions always yield boolean.

Note: we can test whether a CaseExpr has been through parse analysis yet by checking whether casetype is InvalidOid or not.

Fields

xpr: Expr

casetype: Oid

casecollid: Oid

type of expression result

arg: *mut Expr

OID of collation, or InvalidOid if none

args: *mut List

implicit equality comparison argument

defresult: *mut Expr

the arguments (list of WHEN clauses)

location: c_int

the default result (ELSE clause)

Trait Implementations

impl Debug for CaseExpr

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

Formats the value using the given formatter.

impl Default for CaseExpr

fn default() -> Self

Returns the "default value" for a type.

impl Eq for CaseExpr

impl Hash for CaseExpr

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

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

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

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

This method tests for !=.

impl StructuralEq for CaseExpr

impl StructuralPartialEq for CaseExpr