Struct Union 

pub struct Union {
    pub inputs: Vec<Arc<LogicalPlan>>,
    pub schema: DFSchemaRef,
}

Union multiple inputs

Fields

inputs: Vec<Arc<LogicalPlan>>

Inputs to merge

schema: DFSchemaRef

Union schema. Should be the same for all inputs.

Implementations

impl Union

pub fn try_new(inputs: Vec<Arc<LogicalPlan>>) -> Result<Self>

Constructs new Union instance deriving schema from inputs. Schema data types must match exactly.

pub fn try_new_with_loose_types(inputs: Vec<Arc<LogicalPlan>>) -> Result<Self>

Constructs new Union instance deriving schema from inputs. Inputs do not have to have matching types and produced schema will take type from the first input.

pub fn try_new_by_name(inputs: Vec<Arc<LogicalPlan>>) -> Result<Self>

Constructs a new Union instance that combines rows from different tables by name, instead of by position. This means that the specified inputs need not have schemas that are all the same width.

fn rewrite_inputs_from_schema( schema: &Arc<DFSchema>, inputs: Vec<Arc<LogicalPlan>>, ) -> Result<Vec<Arc<LogicalPlan>>>

When constructing a UNION BY NAME, we need to wrap inputs in an additional Projection to account for absence of columns in input schemas or differing projection orders.

fn derive_schema_from_inputs( inputs: &[Arc<LogicalPlan>], loose_types: bool, by_name: bool, ) -> Result<DFSchemaRef>

Constructs new Union instance deriving schema from inputs.

If loose_types is true, inputs do not need to have matching types and the produced schema will use the type from the first input. TODO (https://github.com/apache/datafusion/issues/14380): This is not necessarily reasonable behavior.

If by_name is true, input schemas need not be the same width. That is, the constructed schema follows UNION BY NAME semantics.

fn derive_schema_from_inputs_by_name( inputs: &[Arc<LogicalPlan>], loose_types: bool, ) -> Result<DFSchemaRef>

fn derive_schema_from_inputs_by_position( inputs: &[Arc<LogicalPlan>], loose_types: bool, ) -> Result<DFSchemaRef>

Trait Implementations

impl Clone for Union

fn clone(&self) -> Union

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Union

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

Formats the value using the given formatter.

impl Hash for Union

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Union

fn eq(&self, other: &Union) -> 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 PartialOrd for Union

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for Union

impl StructuralPartialEq for Union