Struct datafusion_jit::api::CodeBlock

pub struct CodeBlock<'a> { /* private fields */ }

Code block consists of statements and acts as anonymous namespace scope for items and variable declarations.

Implementations

impl<'a> CodeBlock<'a>

pub fn build(&mut self) -> GeneratedFunction

pub fn declare(&mut self, name: impl Into<String>, ty: JITType) -> Result<()>

Declare variable name of a type.

pub fn assign(&mut self, name: impl Into<String>, expr: Expr) -> Result<()>

Assignment statement. Assign a expression value to a variable.

pub fn declare_as(&mut self, name: impl Into<String>, expr: Expr) -> Result<()>

Declare variable with initialization.

pub fn call_stmt(
    &mut self,
    name: impl Into<String>,
    args: Vec<Expr>
) -> Result<()>

Call external function for side effect only.

pub fn if_block<C, T, E>(
    &mut self,
    cond: C,
    then_blk: T,
    else_blk: E
) -> Result<()> where
    C: FnMut(&mut CodeBlock<'_>) -> Result<Expr>,
    T: FnMut(&mut CodeBlock<'_>) -> Result<()>,
    E: FnMut(&mut CodeBlock<'_>) -> Result<()>, 

Construct a if-then-else block with each part provided.

E.g. if n == 0 { r = 0 } else { r = 1} could be write as: x.if_block( |cond| cond.eq(cond.id(“n”)?, cond.lit_i(0)), |t| { t.assign(“r”, t.lit_i(0))?; Ok(()) }, |e| t.assign(“r”, t.lit_i(1))?; Ok(()) }, )?;

pub fn while_block<C, B>(&mut self, cond: C, body_blk: B) -> Result<()> where
    C: FnMut(&mut CodeBlock<'_>) -> Result<Expr>,
    B: FnMut(&mut CodeBlock<'_>) -> Result<()>, 

Construct a while block with each part provided.

E.g. while n != 0 { n = n - 1;} could be write as: x.while_block( |cond| cond.ne(cond.id(“n”)?, cond.lit_i(0)), |w| { w.assign(“n”, w.sub(w.id(“n”)?, w.lit_i(1))?)?; Ok(()) }, )?;

pub fn lit(&self, val: impl Into<String>, ty: JITType) -> Expr

Create a literal val of ty type.

pub fn lit_i(&self, val: impl Into<i64>) -> Expr

Shorthand to create i64 literal

pub fn lit_f(&self, val: f32) -> Expr

Shorthand to create f32 literal

pub fn lit_d(&self, val: f64) -> Expr

Shorthand to create f64 literal

pub fn lit_b(&self, val: bool) -> Expr

Shorthand to create boolean literal

pub fn id(&self, name: impl Into<String>) -> Result<Expr>

Create a reference to an already defined variable.

pub fn eq(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary comparison expression: lhs == rhs

pub fn ne(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary comparison expression: lhs != rhs

pub fn lt(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary comparison expression: lhs < rhs

pub fn le(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary comparison expression: lhs <= rhs

pub fn gt(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary comparison expression: lhs > rhs

pub fn ge(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary comparison expression: lhs >= rhs

pub fn add(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary arithmetic expression: lhs + rhs

pub fn sub(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary arithmetic expression: lhs - rhs

pub fn mul(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary arithmetic expression: lhs * rhs

pub fn div(&self, lhs: Expr, rhs: Expr) -> Result<Expr>

Binary arithmetic expression: lhs / rhs

pub fn call(&self, name: impl Into<String>, params: Vec<Expr>) -> Result<Expr>

Call external function name with parameters

pub fn load(&self, ptr: Expr, ty: JITType) -> Result<Expr>

Return the value pointed to by the ptr stored in ptr

pub fn store(&mut self, value: Expr, ptr: Expr) -> Result<()>

Store the value in value to the address in ptr