fn from(explain: PyExplain) -> Self {

explain.explain

}

fn from(explain: Explain) -> PyExplain {

PyExplain { explain }

}

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

write!(

f,

"Explain

&self.explain.verbose,

&self.explain.plan,

&self.explain.stringified_plans,

&self.explain.schema,

&self.explain.logical_optimization_succeeded

)

}

fn explain_string(&self) -> PyResult<Vec<String>> {

let mut string_plans: Vec<String> = Vec::new();

for stringified_plan in &self.explain.stringified_plans {

string_plans.push((*stringified_plan.plan).clone());

}

Ok(string_plans)

}

fn verbose(&self) -> bool {

self.explain.verbose

}

fn plan(&self) -> PyResult<PyLogicalPlan> {

Ok(PyLogicalPlan::from((*self.explain.plan).clone()))

}

fn schema(&self) -> PyDFSchema {

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

}

fn logical_optimization_succceeded(&self) -> bool {

self.explain.logical_optimization_succeeded

}

type Error = PyErr;

fn try_from(logical_plan: LogicalPlan) -> Result<Self, Self::Error> {

match logical_plan {

LogicalPlan::Explain(explain) => Ok(PyExplain { explain }),

_ => Err(py_type_err("unexpected plan")),

}

}

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)

}