use super::*;
pub struct ProjectionExec {
pub(crate) input: Box<dyn Executor>,
pub(crate) expr: Vec<Arc<dyn PhysicalExpr>>,
pub(crate) has_windows: bool,
pub(crate) input_schema: SchemaRef,
#[cfg(test)]
pub(crate) schema: SchemaRef,
}
impl ProjectionExec {
fn execute_impl(
&mut self,
state: &mut ExecutionState,
df: DataFrame,
) -> PolarsResult<DataFrame> {
#[allow(clippy::let_and_return)]
let df = evaluate_physical_expressions(&df, &self.expr, state, self.has_windows);
#[cfg(test)]
#[allow(unused_must_use)]
{
df.as_ref().map(|df| {
for (l, r) in df.iter().zip(self.schema.iter_names()) {
assert_eq!(l.name(), r);
}
});
}
df
}
}
impl Executor for ProjectionExec {
fn execute(&mut self, state: &mut ExecutionState) -> PolarsResult<DataFrame> {
#[cfg(debug_assertions)]
{
if state.verbose() {
println!("run ProjectionExec")
}
}
let df = self.input.execute(state)?;
let profile_name = if state.has_node_timer() {
let by = self
.expr
.iter()
.map(|s| Ok(s.to_field(&self.input_schema)?.name))
.collect::<PolarsResult<Vec<_>>>()?;
let name = column_delimited("projection".to_string(), &by);
Cow::Owned(name)
} else {
Cow::Borrowed("")
};
if state.has_node_timer() {
let new_state = state.clone();
new_state.record(|| self.execute_impl(state, df), profile_name)
} else {
self.execute_impl(state, df)
}
}
}