fn from(create: PyCreateFunction) -> Self {

create.create

}

fn from(create: CreateFunction) -> PyCreateFunction {

PyCreateFunction { create }

}

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

write!(f, "CreateFunction: name {:?}", self.create.name)

}

Immutable,

Stable,

Volatile,

pub fn language(&self) -> Option<String> {

self.body

.language

.as_ref()

.map(|language| language.to_string())

}

pub fn behavior(&self) -> Option<PyVolatility> {

self.body.behavior.as_ref().map(|behavior| match behavior {

Volatility::Immutable => PyVolatility::Immutable,

Volatility::Stable => PyVolatility::Stable,

Volatility::Volatile => PyVolatility::Volatile,

})

}

pub fn function_body(&self) -> Option<PyExpr> {

self.body

.function_body

.as_ref()

.map(|function_body| function_body.clone().into())

}

#[new]

#[pyo3(signature = (or_replace, temporary, name, params, schema, return_type=None, args=None))]

pub fn new(

or_replace: bool,

temporary: bool,

name: String,

params: PyCreateFunctionBody,

schema: PyDFSchema,

return_type: Option<PyDataType>,

args: Option<Vec<PyOperateFunctionArg>>,

) -> Self {

PyCreateFunction {

create: CreateFunction {

or_replace,

temporary,

name,

args: args.map(|args| args.into_iter().map(|arg| arg.arg).collect()),

return_type: return_type.map(|return_type| return_type.data_type),

params: params.body,

schema: Arc::new(schema.into()),

},

}

}

pub fn or_replace(&self) -> bool {

self.create.or_replace

}

pub fn temporary(&self) -> bool {

self.create.temporary

}

pub fn name(&self) -> String {

self.create.name.clone()

}

pub fn params(&self) -> PyCreateFunctionBody {

PyCreateFunctionBody {

body: self.create.params.clone(),

}

}

pub fn schema(&self) -> PyDFSchema {

(*self.create.schema).clone().into()

}

pub fn return_type(&self) -> Option<PyDataType> {

self.create

.return_type

.as_ref()

.map(|return_type| return_type.clone().into())

}

pub fn args(&self) -> Option<Vec<PyOperateFunctionArg>> {

self.create.args.as_ref().map(|args| {

args.iter()

.map(|arg| PyOperateFunctionArg { arg: arg.clone() })

.collect()

})

}

fn __repr__(&self) -> PyResult<String> {

Ok(format!("CreateFunction({self})"))

}

fn __name__(&self) -> PyResult<String> {

Ok("CreateFunction".to_string())

}

fn inputs(&self) -> Vec<PyLogicalPlan> {

vec![]

}

fn to_variant<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {

self.clone().into_bound_py_any(py)

}