Struct datafusion::execution::context::ExecutionContext

pub struct ExecutionContext { /* fields omitted */ }

Execution context for registering data sources and executing queries

Implementations

impl ExecutionContext

pub fn new() -> Self

Create a new execution context for in-memory queries

pub fn sql(&mut self, sql: &str, batch_size: usize) -> Result<Vec<RecordBatch>>

Execute a SQL query and produce a Relation (a schema-aware iterator over a series of RecordBatch instances)

pub fn collect_plan(
    &mut self,
    plan: &LogicalPlan,
    batch_size: usize
) -> Result<Vec<RecordBatch>>

Executes a logical plan and produce a Relation (a schema-aware iterator over a series of RecordBatch instances)

pub fn create_logical_plan(&mut self, sql: &str) -> Result<LogicalPlan>

Creates a logical plan

pub fn register_udf(&mut self, f: ScalarFunction)

Register a scalar UDF

pub fn scalar_functions(&self) -> &HashMap<String, Box<ScalarFunction>>

Get a reference to the registered scalar functions

pub fn register_csv(
    &mut self,
    name: &str,
    filename: &str,
    options: CsvReadOptions
) -> Result<()>

Register a CSV file as a table so that it can be queried from SQL

pub fn register_parquet(&mut self, name: &str, filename: &str) -> Result<()>

Register a Parquet file as a table so that it can be queried from SQL

pub fn register_table(
    &mut self,
    name: &str,
    provider: Box<dyn TableProvider + Send + Sync>
)

Register a table so that it can be queried from SQL

pub fn table(&mut self, table_name: &str) -> Result<Arc<dyn Table>>

Get a table by name

pub fn tables(&self) -> HashSet<String>

The set of available tables. Use table to get a specific table.

pub fn optimize(&self, plan: &LogicalPlan) -> Result<LogicalPlan>

Optimize the logical plan by applying optimizer rules

pub fn create_physical_plan(
    &self,
    logical_plan: &LogicalPlan,
    batch_size: usize
) -> Result<Arc<dyn ExecutionPlan>>

Create a physical plan from a logical plan

pub fn create_physical_expr(
    &self,
    e: &Expr,
    input_schema: &Schema
) -> Result<Arc<dyn PhysicalExpr>>

Create a physical expression from a logical expression

pub fn create_aggregate_expr(
    &self,
    e: &Expr,
    input_schema: &Schema
) -> Result<Arc<dyn AggregateExpr>>

Create an aggregate expression from a logical expression

pub fn create_physical_sort_expr(
    &self,
    e: &Expr,
    input_schema: &Schema,
    options: SortOptions
) -> Result<PhysicalSortExpr>

Create an aggregate expression from a logical expression

pub fn collect(&self, plan: &dyn ExecutionPlan) -> Result<Vec<RecordBatch>>

Execute a physical plan and collect the results in memory

pub fn write_csv(&self, plan: &dyn ExecutionPlan, path: &str) -> Result<()>

Execute a query and write the results to a partitioned CSV file