Struct Environment

pub struct Environment {
    pub schema: Schema,
    pub std_signatures: HashMap<&'static str, Signature>,
    pub std_functions: HashMap<&'static str, Function>,
    pub aggregation_signatures: HashMap<&'static str, Signature>,
    pub aggregation_functions: HashMap<&'static str, Aggregation>,
    pub globals: HashMap<String, Box<dyn Value>>,
    pub globals_types: HashMap<String, Box<dyn DataType>>,
    pub scopes: HashMap<String, Box<dyn DataType>>,
}

Environment that track schema, functions, scopes and types to be used in different places in the query engine

Fields

schema: Schema

Data schema information contains table, fields names and types

std_signatures: HashMap<&'static str, Signature>

Standard function signatures

std_functions: HashMap<&'static str, Function>

Standard function references

aggregation_signatures: HashMap<&'static str, Signature>

Aggregation function signatures

aggregation_functions: HashMap<&'static str, Aggregation>

Aggregation function references

globals: HashMap<String, Box<dyn Value>>

All Global Variables values that can life for this program session

globals_types: HashMap<String, Box<dyn DataType>>

All Global Variables Types that can life for this program session

scopes: HashMap<String, Box<dyn DataType>>

Local variables types in the current scope, later will be multi layer scopes

Implementations

impl Environment

pub fn new(schema: Schema) -> Self

Create new Environment instance with Data Schema

pub fn with_standard_functions( &mut self, signatures: &HashMap<&'static str, Signature>, functions: &HashMap<&'static str, Function>, )

Register standard functions signatures and references

pub fn with_aggregation_functions( &mut self, signatures: &HashMap<&'static str, Signature>, aggregation: &HashMap<&'static str, Aggregation>, )

Register aggregation functions signatures and references

pub fn is_std_function(&self, str: &str) -> bool

Return true if this name is a valid standard function

pub fn std_signature(&self, str: &str) -> Option<&Signature>

Return Standard function signature by name

pub fn std_function(&self, str: &str) -> Option<&Function>

Return Standard function reference by name

pub fn is_aggregation_function(&self, str: &str) -> bool

Return true if this name is a valid aggregation function

pub fn aggregation_signature(&self, str: &str) -> Option<&Signature>

Return Aggregation function signature by name

pub fn aggregation_function(&self, str: &str) -> Option<&Aggregation>

Return Aggregation function reference by name

pub fn define(&mut self, str: String, data_type: Box<dyn DataType>)

Define in the current scope

pub fn define_global(&mut self, str: String, data_type: Box<dyn DataType>)

Define in the global scope

pub fn contains(&self, str: &String) -> bool

Returns true if local or global scopes has contains field

pub fn resolve_type(&self, str: &String) -> Option<&Box<dyn DataType>>

Resolve Global or Local type using symbol name

pub fn clear_session(&mut self)

Clear all locals scopes and only save globals