Struct CreateConstraintTrigger 

pub struct CreateConstraintTrigger<'a> {

    pub create_span: Span,
    pub constraint_trigger_span: Span,
    pub name: Identifier<'a>,
    pub after_span: Span,
    pub after_events: Vec<AfterEvent>,
    pub on_span: Span,
    pub table_name: Identifier<'a>,
    pub referenced_table_name: Option<Identifier<'a>>,
    pub deferrable: Option<Deferrable>,
    pub initially: Option<Initially>,
    pub for_each_row_span: Span,
    pub when_condition: Option<(Span, Expression<'a>)>,
    pub execute_procedure_span: Span,
    pub function_name: Identifier<'a>,
    pub function_args: Vec<Expression<'a>>,
}

Represent a create constraint trigger statement

Fields

create_span: Span

The span of the entire CREATE keyword

constraint_trigger_span: Span

The span of the CONSTRAINT TRIGGER keywords

name: Identifier<'a>

The name of the constraint trigger

after_span: Span

The events that fire the trigger (AFTER INSERT, AFTER UPDATE, AFTER DELETE)

after_events: Vec<AfterEvent>

on_span: Span

The table the trigger is on

table_name: Identifier<'a>

referenced_table_name: Option<Identifier<'a>>

The referenced table for the trigger (optional, used for referencing foreign keys)

deferrable: Option<Deferrable>

Whether the trigger is deferrable or not (optional, PostgreSQL specific)

initially: Option<Initially>

The initial timing of the trigger (optional, PostgreSQL specific)

for_each_row_span: Span

The span of the FOR EACH ROW keywords

when_condition: Option<(Span, Expression<'a>)>

The WHEN condition for the trigger (optional, PostgreSQL specific)

execute_procedure_span: Span

The span of the EXECUTE PROCEDURE keywords

function_name: Identifier<'a>

The name of the function to execute when the trigger fires

function_args: Vec<Expression<'a>>

The arguments to the function (optional)

Trait Implementations

impl<'a> Clone for CreateConstraintTrigger<'a>

fn clone(&self) -> CreateConstraintTrigger<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CreateConstraintTrigger<'a>

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

Formats the value using the given formatter.

impl<'a> Spanned for CreateConstraintTrigger<'a>

fn span(&self) -> Span

Compute byte span of an ast fragment

fn join_span(&self, other: &impl OptSpanned) -> Span

Compute the minimal span containing both self and other