Struct postgres_parser::sys::Constraint

#[repr(C)]pub struct Constraint {
    pub type_: NodeTag,
    pub contype: ConstrType,
    pub conname: *mut c_char,
    pub deferrable: bool,
    pub initdeferred: bool,
    pub location: c_int,
    pub is_no_inherit: bool,
    pub raw_expr: *mut Node,
    pub cooked_expr: *mut c_char,
    pub generated_when: c_char,
    pub keys: *mut List,
    pub including: *mut List,
    pub exclusions: *mut List,
    pub options: *mut List,
    pub indexname: *mut c_char,
    pub indexspace: *mut c_char,
    pub reset_default_tblspc: bool,
    pub access_method: *mut c_char,
    pub where_clause: *mut Node,
    pub pktable: *mut RangeVar,
    pub fk_attrs: *mut List,
    pub pk_attrs: *mut List,
    pub fk_matchtype: c_char,
    pub fk_upd_action: c_char,
    pub fk_del_action: c_char,
    pub old_conpfeqop: *mut List,
    pub old_pktable_oid: Oid,
    pub skip_validation: bool,
    pub initially_valid: bool,
}

Fields

type_: NodeTag

contype: ConstrType

conname: *mut c_char

Fields used for most/all constraint types:

deferrable: bool

Constraint name, or NULL if unnamed

initdeferred: bool

DEFERRABLE?

location: c_int

INITIALLY DEFERRED?

is_no_inherit: bool

Fields used for constraints with expressions (CHECK and DEFAULT):

raw_expr: *mut Node

is constraint noninheritable?

cooked_expr: *mut c_char

expr, as untransformed parse tree

generated_when: c_char

expr, as nodeToString representation

keys: *mut List

Fields used for unique constraints (UNIQUE and PRIMARY KEY):

including: *mut List

String nodes naming referenced key column(s)

exclusions: *mut List

Fields used for EXCLUSION constraints:

options: *mut List

Fields used for index constraints (UNIQUE, PRIMARY KEY, EXCLUSION):

indexname: *mut c_char

options from WITH clause

indexspace: *mut c_char

existing index to use; otherwise NULL

reset_default_tblspc: bool

index tablespace; NULL for default

access_method: *mut c_char

reset default_tablespace prior to creating the index */

where_clause: *mut Node

index access method; NULL for default

pktable: *mut RangeVar

Fields used for FOREIGN KEY constraints:

fk_attrs: *mut List

Primary key table

pk_attrs: *mut List

Attributes of foreign key

fk_matchtype: c_char

Corresponding attrs in PK table

fk_upd_action: c_char

FULL, PARTIAL, SIMPLE

fk_del_action: c_char

ON UPDATE action

old_conpfeqop: *mut List

ON DELETE action

old_pktable_oid: Oid

pg_constraint.conpfeqop of my former self

skip_validation: bool

Fields used for constraints that allow a NOT VALID specification

initially_valid: bool

skip validation of existing rows?

Trait Implementations

impl Debug for Constraint

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

Formats the value using the given formatter.

impl Default for Constraint

fn default() -> Self

Returns the "default value" for a type.

impl Eq for Constraint

impl Hash for Constraint

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

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

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

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

This method tests for !=.

impl StructuralEq for Constraint

impl StructuralPartialEq for Constraint