Struct sql_parse::CreateFunction

pub struct CreateFunction<'a> {
    pub create_span: Span,
    pub create_options: Vec<CreateOption<'a>>,
    pub function_span: Span,
    pub if_not_exists: Option<Span>,
    pub name: Identifier<'a>,
    pub params: Vec<(Option<FunctionParamDirection>, Identifier<'a>, DataType<'a>)>,
    pub returns_span: Span,
    pub return_type: DataType<'a>,
    pub characteristics: Vec<FunctionCharacteristic<'a>>,
    pub return_: Option<Box<Statement<'a>>>,
}

Representation of Create Function Statement

This is not fully implemented yet

let sql = "DELIMITER $$
CREATE FUNCTION add_func3(IN a INT, IN b INT, OUT c INT) RETURNS INT
BEGIN
    SET c = 100;
    RETURN a + b;
END;
$$
DELIMITER ;";
let mut stmts = parse_statements(sql, &mut issues, &options);

assert!(issues.is_empty());
let create: CreateFunction = match stmts.pop() {
    Some(Statement::CreateFunction(c)) => c,
    _ => panic!("We should get an create function statement")
};

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

Fields

create_span: Span

Span of “CREATE”

create_options: Vec<CreateOption<'a>>

Options after “CREATE”

function_span: Span

Span of “FUNCTION”

if_not_exists: Option<Span>

Span of “IF NOT EXISTS” if specified

name: Identifier<'a>

Name o created function

params: Vec<(Option<FunctionParamDirection>, Identifier<'a>, DataType<'a>)>

Names and types of function arguments

returns_span: Span

Span of “RETURNS”

return_type: DataType<'a>

Type of return value

characteristics: Vec<FunctionCharacteristic<'a>>

Characteristics of created function

return_: Option<Box<Statement<'a>>>

Statement computing return value

Trait Implementations

impl<'a> Clone for CreateFunction<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CreateFunction<'a>

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

Formats the value using the given formatter.

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