Struct sql_parse::CreateTrigger

pub struct CreateTrigger<'a> {
    pub create_span: Span,
    pub create_options: Vec<CreateOption<'a>>,
    pub trigger_span: Span,
    pub if_not_exists: Option<Span>,
    pub name: Identifier<'a>,
    pub trigger_time: TriggerTime,
    pub trigger_event: TriggerEvent,
    pub on_span: Span,
    pub table: Identifier<'a>,
    pub for_each_row_span: Span,
    pub statement: Box<Statement<'a>>,
}

Represent a create trigger statement

let sql = "DROP TRIGGER IF EXISTS `my_trigger`;
DELIMITER $$
CREATE TRIGGER `my_trigger` AFTER DELETE ON `things` FOR EACH ROW BEGIN
    IF OLD.`value` IS NOT NULL THEN
        UPDATE `t2` AS `j`
            SET
            `j`.`total_items` = `total_items` - 1
            WHERE `j`.`id`=OLD.`value` AND NOT `j`.`frozen`;
        END IF;
    INSERT INTO `updated_things` (`thing`) VALUES (OLD.`id`);
END
$$
DELIMITER ;";
let mut stmts = parse_statements(sql, &mut issues, &options);

let create: CreateTrigger = match stmts.pop() {
    Some(Statement::CreateTrigger(c)) => c,
    _ => panic!("We should get an create trigger statement")
};

assert!(create.name.as_str() == "my_trigger");
println!("{:#?}", create.statement)

Fields

create_span: Span

Span of “CREATE”

create_options: Vec<CreateOption<'a>>

Options after “CREATE”

trigger_span: Span

Span of “TRIGGER”

if_not_exists: Option<Span>

Span of “IF NOT EXISTS” if specified

name: Identifier<'a>

Name of the created trigger

trigger_time: TriggerTime

Should the trigger be fired before or after the event

trigger_event: TriggerEvent

What event should the trigger be fired on

on_span: Span

Span of “ON”

table: Identifier<'a>

Name of table to create the trigger on

for_each_row_span: Span

Span of “FOR EACH ROW”

statement: Box<Statement<'a>>

Statement to execute

Trait Implementations

impl<'a> Clone for CreateTrigger<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CreateTrigger<'a>

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

Formats the value using the given formatter.

impl<'a> Spanned for CreateTrigger<'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