Struct datafusion::execution::context::SessionState

pub struct SessionState {
    pub session_id: String,
    pub optimizer: Optimizer,
    pub physical_optimizers: Vec<Arc<dyn PhysicalOptimizerRule + Send + Sync>>,
    pub query_planner: Arc<dyn QueryPlanner + Send + Sync>,
    pub catalog_list: Arc<dyn CatalogList>,
    pub scalar_functions: HashMap<String, Arc<ScalarUDF>>,
    pub aggregate_functions: HashMap<String, Arc<AggregateUDF>>,
    pub config: SessionConfig,
    pub execution_props: ExecutionProps,
    pub runtime_env: Arc<RuntimeEnv>,
}

Execution context for registering data sources and executing queries

Fields

session_id: String

Uuid for the session

optimizer: Optimizer

Responsible for optimizing a logical plan

physical_optimizers: Vec<Arc<dyn PhysicalOptimizerRule + Send + Sync>>

Responsible for optimizing a physical execution plan

query_planner: Arc<dyn QueryPlanner + Send + Sync>

Responsible for planning LogicalPlans, and ExecutionPlan

catalog_list: Arc<dyn CatalogList>

Collection of catalogs containing schemas and ultimately TableProviders

scalar_functions: HashMap<String, Arc<ScalarUDF>>

Scalar functions that are registered with the context

aggregate_functions: HashMap<String, Arc<AggregateUDF>>

Aggregate functions registered in the context

config: SessionConfig

Session configuration

execution_props: ExecutionProps

Execution properties

runtime_env: Arc<RuntimeEnv>

Runtime environment

Implementations

impl SessionState

pub fn with_config_rt(config: SessionConfig, runtime: Arc<RuntimeEnv>) -> Self

Returns new SessionState using the provided configuration and runtime

pub fn with_query_planner(
    self,
    query_planner: Arc<dyn QueryPlanner + Send + Sync>
) -> Self

Replace the default query planner

pub fn with_optimizer_rules(
    self,
    rules: Vec<Arc<dyn OptimizerRule + Send + Sync>>
) -> Self

Replace the optimizer rules

pub fn with_physical_optimizer_rules(
    self,
    physical_optimizers: Vec<Arc<dyn PhysicalOptimizerRule + Send + Sync>>
) -> Self

Replace the physical optimizer rules

pub fn add_optimizer_rule(
    self,
    optimizer_rule: Arc<dyn OptimizerRule + Send + Sync>
) -> Self

Adds a new OptimizerRule

pub fn add_physical_optimizer_rule(
    self,
    optimizer_rule: Arc<dyn PhysicalOptimizerRule + Send + Sync>
) -> Self

Adds a new PhysicalOptimizerRule

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

Optimizes the logical plan by applying optimizer rules.

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

Creates a physical plan from a logical plan.

pub fn config_options(&self) -> Arc<RwLock<ConfigOptions>>

return the configuration options

Trait Implementations

impl Clone for SessionState

fn clone(&self) -> SessionState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ContextProvider for SessionState

fn get_table_provider(
    &self,
    name: TableReference<'_>
) -> Result<Arc<dyn TableSource>>

Getter for a datasource

fn get_function_meta(&self, name: &str) -> Option<Arc<ScalarUDF>>

Getter for a UDF description

fn get_aggregate_meta(&self, name: &str) -> Option<Arc<AggregateUDF>>

Getter for a UDAF description

fn get_variable_type(&self, variable_names: &[String]) -> Option<DataType>

Getter for system/user-defined variable type

fn get_config_option(&self, variable: &str) -> Option<ScalarValue>

Getter for config_options

impl Debug for SessionState

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

Formats the value using the given formatter.

impl From<&SessionState> for TaskContext

Create a new task context instance from SessionState

fn from(state: &SessionState) -> Self

Converts to this type from the input type.

impl FunctionRegistry for SessionState

fn udfs(&self) -> HashSet<String>

Set of all available udfs.

fn udf(&self, name: &str) -> Result<Arc<ScalarUDF>>

Returns a reference to the udf named name.

fn udaf(&self, name: &str) -> Result<Arc<AggregateUDF>>

Returns a reference to the udaf named name.