Type Alias datafusion::logical_expr::function::StateTypeFunction

pub type StateTypeFunction = Arc<dyn Fn(&DataType) -> Result<Arc<Vec<DataType, Global>, Global>, DataFusionError> + Sync + Send, Global>;

Factory that returns the types used by an aggregator to serialize its state, given its return datatype.

Aliased Type

struct StateTypeFunction { /* private fields */ }

Trait Implementations

impl<T> DataPtr for Arc<T, Global>where T: ?Sized,

fn data_ptr(this: &Arc<T, Global>) -> *const ()

Returns a raw pointer to the data, stripping away all metadata.

fn data_ptr_eq(this: &Self, other: &Self) -> bool

Check if two pointers point to the same data.

impl<T, A> Deref for Arc<T, A>where A: Allocator, T: ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> TreeNode for Arc<T, Global>where T: DynTreeNode + ?Sized,

Blanket implementation for Arc for any tye that implements DynTreeNode (such as Arc<dyn PhysicalExpr>)

fn apply_children<F>( &self, op: &mut F ) -> Result<VisitRecursion, DataFusionError>where F: FnMut(&Arc<T, Global>) -> Result<VisitRecursion, DataFusionError>,

Apply the closure F to the node’s children

fn map_children<F>( self, transform: F ) -> Result<Arc<T, Global>, DataFusionError>where F: FnMut(Arc<T, Global>) -> Result<Arc<T, Global>, DataFusionError>,

Apply transform F to the node’s children, the transform F might have a direction(Preorder or Postorder)

fn apply<F>(&self, op: &mut F) -> Result<VisitRecursion, DataFusionError>where F: FnMut(&Self) -> Result<VisitRecursion, DataFusionError>,

Use preorder to iterate the node on the tree so that we can stop fast for some cases.

fn visit<V>(&self, visitor: &mut V) -> Result<VisitRecursion, DataFusionError>where V: TreeNodeVisitor<N = Self>,

Visit the tree node using the given TreeNodeVisitor It performs a depth first walk of an node and its children.

fn transform<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given op to the node tree. When op does not apply to a given node, it is left unchanged. The default tree traversal direction is transform_up(Postorder Traversal).

fn transform_down<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given ‘op’ to the node and all of its children(Preorder Traversal). When the op does not apply to a given node, it is left unchanged.

fn transform_up<F>(self, op: &F) -> Result<Self, DataFusionError>where F: Fn(Self) -> Result<Transformed<Self>, DataFusionError>,

Convenience utils for writing optimizers rule: recursively apply the given ‘op’ first to all of its children and then itself(Postorder Traversal). When the op does not apply to a given node, it is left unchanged.

fn rewrite<R>(self, rewriter: &mut R) -> Result<Self, DataFusionError>where R: TreeNodeRewriter<N = Self>,

Transform the tree node using the given TreeNodeRewriter It performs a depth first walk of an node and its children.