Struct CreateProcedure 

pub struct CreateProcedure {
    pub name: TableRef,
    pub parameters: Vec<FunctionParameter>,
    pub body: Option<FunctionBody>,
    pub or_replace: bool,
    pub if_not_exists: bool,
    pub language: Option<String>,
    pub security: Option<FunctionSecurity>,
    pub return_type: Option<DataType>,
    pub execute_as: Option<String>,
    pub with_options: Vec<String>,
    pub has_parens: bool,
    pub use_proc_keyword: bool,
}

CREATE PROCEDURE statement

Fields

name: TableRef

parameters: Vec<FunctionParameter>

body: Option<FunctionBody>

or_replace: bool

if_not_exists: bool

language: Option<String>

security: Option<FunctionSecurity>

return_type: Option<DataType>

Return type (Snowflake: RETURNS OBJECT, RETURNS VARCHAR, etc.)

execute_as: Option<String>

Execution context (EXECUTE AS CALLER, EXECUTE AS OWNER)

with_options: Vec<String>

TSQL WITH options (ENCRYPTION, RECOMPILE, SCHEMABINDING, etc.)

has_parens: bool

Whether the parameter list had parentheses (false for TSQL procedures without parens)

use_proc_keyword: bool

Whether the short form PROC was used (instead of PROCEDURE)

Implementations

impl CreateProcedure

pub fn new(name: impl Into<String>) -> Self

Trait Implementations

impl Clone for CreateProcedure

fn clone(&self) -> CreateProcedure

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CreateProcedure

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CreateProcedure

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CreateProcedure

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CreateProcedure

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CreateProcedure