Struct toql_core::sql_expr::resolver::Resolver

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

The resolver may hold values for placeholder tokens from SqlExpr and replace those.

It will replace placeholder tokens from SqlExpr with concret values as good as it can.

This is a typical use:

use toql_core::{sql_expr::SqlExpr, alias_format::AliasFormat};
use toql_core::{alias_translator::AliasTranslator, sql_expr::resolver::Resolver};

let sql_expr = SqlExpr::self_alias();
let mut alias_translator = AliasTranslator::new(AliasFormat::TinyIndex);
let resolver = Resolver::new().with_self_alias("t1");

let sql = resolver.to_sql(&sql_expr, &mut alias_translator).unwrap();
assert_eq!("t1", sql.to_unsafe_string());

Implementations

impl<'a> Resolver<'a>

pub fn new() -> Self

pub fn with_self_alias(self, alias: &'a str) -> Self

Replace self alias placeholders with this alias.

pub fn with_other_alias(self, alias: &'a str) -> Self

Replace other alias placeholders with this alias.

pub fn with_aux_params(self, aux_params: &'a ParameterMap<'a>) -> Self

Replace aux param placeholders with values from this map.

pub fn with_arguments(self, arguments: &'a [SqlArg]) -> Self

Replace argument placeholder with values from this argument list.

pub fn replace_aux_params(
    sql_expr: SqlExpr,
    aux_params_exprs: &HashMap<String, SqlExpr>
) -> SqlExpr

Replace aux param palceholders with SQL expressions. Skips placeholders that can’t be replaced.

pub fn resolve_aux_params(
    sql_expr: SqlExpr,
    aux_params: &ParameterMap<'_>
) -> SqlExpr

Resolve aux params placeholders with value from parameter map. Skips placeholders that cannot be resolved.

pub fn resolve(&self, sql_expr: &'a SqlExpr) -> Result<SqlExpr, ResolverError>

pub fn alias_to_literals(
    &self,
    sql_expr: &'a SqlExpr
) -> Result<SqlExpr, ResolverError>

Resolve all aliases to literal strings.

pub fn to_sql(
    &self,
    sql_expr: &SqlExpr,
    alias_translator: &mut AliasTranslator
) -> Result<Sql, ResolverError>

Resolve all placeholder tokens and translate aliases with the AliasTranslator. This turns an SqlExpr into Sql, if all placeholder tokens can be resolved and fail otherwise.

pub fn token_to_sql(
    token: &SqlExprToken,
    alias_translator: &mut AliasTranslator,
    stmt: &mut String,
    args: &mut Vec<SqlArg>
) -> Result<(), ResolverError>

Trait Implementations

impl Default for Resolver<'_>

fn default() -> Self

Returns the “default value” for a type.