Struct datafusion_sql::unparser::Unparser

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

Convert a DataFusion Expr to sqlparser::ast::Expr

See expr_to_sql for background. Unparser allows greater control of the conversion, but with a more complicated API.

To get more human-readable output, see Self::with_pretty

Example

use datafusion_expr::{col, lit};
use datafusion_sql::unparser::Unparser;
let expr = col("a").gt(lit(4)); // form an expression `a > 4`
let unparser = Unparser::default();
let sql = unparser.expr_to_sql(&expr).unwrap();// convert to AST
// use the Display impl to convert to SQL text
assert_eq!(sql.to_string(), "(a > 4)");
// now convert to pretty sql
let unparser = unparser.with_pretty(true);
let sql = unparser.expr_to_sql(&expr).unwrap();
assert_eq!(sql.to_string(), "a > 4"); // note lack of parenthesis

Implementations

impl Unparser<'_>

pub fn expr_to_sql(&self, expr: &Expr) -> Result<Expr>

pub fn expr_to_unparsed(&self, expr: &Expr) -> Result<Unparsed>

This function can convert more Expr types than expr_to_sql, returning an Unparsed like Sort expressions to OrderByExpr expressions.

impl Unparser<'_>

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

impl<'a> Unparser<'a>

pub fn new(dialect: &'a dyn Dialect) -> Self

pub fn with_pretty(self, pretty: bool) -> Self

Create pretty SQL output, better suited for human consumption

See example on the struct level documentation

Pretty Output

By default, Unparser generates SQL text that will parse back to the same parsed Expr, which is useful for creating machine readable expressions to send to other systems. However, the resulting expressions are not always nice to read for humans.

For example

((a + 4) > 5)

This method removes parenthesis using to the precedence rules of DataFusion. If the output is reparsed, the resulting Expr produces same value as the original in DataFusion, but with a potentially different order of operations.

Note that this setting may create invalid SQL for other SQL query engines with different precedence rules

Example

use datafusion_expr::{col, lit};
use datafusion_sql::unparser::Unparser;
let expr = col("a").gt(lit(4)).and(col("b").lt(lit(5))); // form an expression `a > 4 AND b < 5`
let unparser = Unparser::default().with_pretty(true);
let sql = unparser.expr_to_sql(&expr).unwrap();
assert_eq!(sql.to_string(), "a > 4 AND b < 5"); // note lack of parenthesis

Trait Implementations

impl<'a> Default for Unparser<'a>

fn default() -> Self

Returns the “default value” for a type.