Struct ProjectionPlan 

pub struct ProjectionPlan {
    pub physical_projection: Projection,
    pub must_add_row_offset: bool,
    pub requested_output_expr: Vec<OutputColumn>,
}

Fields

physical_projection: Projection

The physical schema that must be loaded from the dataset

must_add_row_offset: bool

Needs the row address converted into a row offset

requested_output_expr: Vec<OutputColumn>

The desired output columns

Implementations

impl ProjectionPlan

pub fn from_expressions( base: Arc<dyn Projectable>, columns: &[(impl AsRef<str>, impl AsRef<str>)], blob_version: BlobVersion, ) -> Result<Self>

Set the projection from SQL expressions

pub fn from_schema( base: Arc<dyn Projectable>, projection: &Schema, blob_version: BlobVersion, ) -> Result<Self>

Set the projection from a schema

This plan will have no complex expressions, the schema must be a subset of the dataset schema.

With this approach it is possible to refer to portions of nested fields.

For example, if the schema is:

{
  "metadata": {
    "location": {
      "x": f32,
      "y": f32,
    },
    "age": i32,
  }
}

It is possible to project a partial schema that drops y like:

{
  "metadata": {
    "location": {
      "x": f32,
    },
    "age": i32,
  }
}

This is something that cannot be done easily using expressions.

pub fn full( base: Arc<dyn Projectable>, blob_version: BlobVersion, ) -> Result<Self>

pub fn to_physical_exprs( &self, current_schema: &ArrowSchema, ) -> Result<Vec<(Arc<dyn PhysicalExpr>, String)>>

Convert the projection to a list of physical expressions

This is used to apply the final projection (including dynamic expressions) to the data.

pub fn include_row_id(&mut self)

Include the row id in the output

pub fn include_row_addr(&mut self)

Include the row address in the output

pub fn has_output_cols(&self) -> bool

Check if the projection has any output columns

This doesn’t mean there is a physical projection. For example, we may someday support something like SELECT 1 AS foo which would have an output column (foo) but no physical projection

pub fn output_schema(&self) -> Result<ArrowSchema>

pub async fn project_batch(&self, batch: RecordBatch) -> Result<RecordBatch>

Trait Implementations

impl Clone for ProjectionPlan

fn clone(&self) -> ProjectionPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProjectionPlan

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

Formats the value using the given formatter.