Struct ProjectedCaseBody 

struct ProjectedCaseBody {
    projection: Vec<usize>,
    body: CaseBody,
}

A derived case body that can be used to evaluate a case expression after projecting record batches using a projection vector.

This is used to avoid filtering columns that are not used in the input RecordBatch when progressively evaluating a CASE expression’s remainder batches. Filtering these columns is wasteful since for a record batch of n rows, filtering requires at worst a copy of n - 1 values per array. If these filtered values will never be accessed, the time spent producing them is better avoided.

For example, if we are evaluating the following case expression that only references columns B and D:

SELECT CASE WHEN B > 10 THEN D ELSE NULL END FROM (VALUES (...)) T(A, B, C, D)

Of the 4 input columns [A, B, C, D], the CASE expression only access B and D. Filtering A and C would be unnecessary and wasteful.

If we only retain columns B and D using RecordBatch::project and the projection vector [1, 3], the indices of these two columns will change to [0, 1]. To evaluate the case expression, it will need to be rewritten from CASE WHEN B@1 > 10 THEN D@3 ELSE NULL END to CASE WHEN B@0 > 10 THEN D@1 ELSE NULL END.

The projection vector and the rewritten expression (which only differs from the original in column reference indices) are held in a ProjectedCaseBody.

Fields

projection: Vec<usize>

body: CaseBody

Trait Implementations

impl Debug for ProjectedCaseBody

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

Formats the value using the given formatter.

impl Hash for ProjectedCaseBody

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 ProjectedCaseBody

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

impl StructuralPartialEq for ProjectedCaseBody