Trait VisitorMut 

pub trait VisitorMut {
    type Break;

    // Provided methods
    fn pre_visit_query(
        &mut self,
        _query: &mut Query,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_query(
        &mut self,
        _query: &mut Query,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_select(
        &mut self,
        _select: &mut Select,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_select(
        &mut self,
        _select: &mut Select,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_relation(
        &mut self,
        _relation: &mut ObjectName,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_relation(
        &mut self,
        _relation: &mut ObjectName,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_table_factor(
        &mut self,
        _table_factor: &mut TableFactor,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_table_factor(
        &mut self,
        _table_factor: &mut TableFactor,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_expr(&mut self, _expr: &mut Expr) -> ControlFlow<Self::Break> { ... }
    fn post_visit_expr(&mut self, _expr: &mut Expr) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_statement(
        &mut self,
        _statement: &mut Statement,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_statement(
        &mut self,
        _statement: &mut Statement,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_value(
        &mut self,
        _value: &mut ValueWithSpan,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_value(
        &mut self,
        _value: &mut ValueWithSpan,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_ident(
        &mut self,
        _ident: &mut Ident,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_ident(
        &mut self,
        _ident: &mut Ident,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_order_by(
        &mut self,
        _order_by: &mut OrderBy,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_order_by(
        &mut self,
        _order_by: &mut OrderBy,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_order_by_expr(
        &mut self,
        _order_by_expr: &mut OrderByExpr,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_order_by_expr(
        &mut self,
        _order_by_expr: &mut OrderByExpr,
    ) -> ControlFlow<Self::Break> { ... }
    fn pre_visit_group_by(
        &mut self,
        _group_by: &mut GroupByExpr,
    ) -> ControlFlow<Self::Break> { ... }
    fn post_visit_group_by(
        &mut self,
        _group_by: &mut GroupByExpr,
    ) -> ControlFlow<Self::Break> { ... }
}

A visitor that can be used to mutate an AST tree.

pre_visit_ methods are invoked before visiting all children of the node and post_visit_ methods are invoked after visiting all children of the node.

See also

These methods provide a more concise way of visiting nodes of a certain type:

• visit_relations_mut
• visit_expressions_mut
• visit_statements_mut

Example

// A visitor that replaces "to_replace" with "replaced" in all expressions
struct Replacer;

// Visit each expression after its children have been visited
impl VisitorMut for Replacer {
  type Break = ();

  fn post_visit_expr(&mut self, expr: &mut Expr) -> ControlFlow<Self::Break> {
    if let Expr::Identifier(Ident{ value, ..}) = expr {
        *value = value.replace("to_replace", "replaced")
    }
    ControlFlow::Continue(())
  }
}

let sql = "SELECT to_replace FROM foo where to_replace IN (SELECT to_replace FROM bar)";
let mut statements = Parser::parse_sql(&GenericDialect{}, sql).unwrap();

// Drive the visitor through the AST
statements.visit(&mut Replacer);

assert_eq!(statements[0].to_string(), "SELECT replaced FROM foo WHERE replaced IN (SELECT replaced FROM bar)");

Required Associated Types

type Break

Type returned when the recursion returns early.

Important note: The Break type should be kept as small as possible to prevent stack overflow during recursion. If you need to return an error, consider boxing it with Box to minimize stack usage.

Provided Methods

fn pre_visit_query(&mut self, _query: &mut Query) -> ControlFlow<Self::Break>

Invoked for any queries that appear in the AST before visiting children

fn post_visit_query(&mut self, _query: &mut Query) -> ControlFlow<Self::Break>

Invoked for any queries that appear in the AST after visiting children

fn pre_visit_select(&mut self, _select: &mut Select) -> ControlFlow<Self::Break>

Invoked for any Select that appear in the AST before visiting children

fn post_visit_select( &mut self, _select: &mut Select, ) -> ControlFlow<Self::Break>

Invoked for any Select that appear in the AST after visiting children

fn pre_visit_relation( &mut self, _relation: &mut ObjectName, ) -> ControlFlow<Self::Break>

Invoked for any relations (e.g. tables) that appear in the AST before visiting children

fn post_visit_relation( &mut self, _relation: &mut ObjectName, ) -> ControlFlow<Self::Break>

Invoked for any relations (e.g. tables) that appear in the AST after visiting children

fn pre_visit_table_factor( &mut self, _table_factor: &mut TableFactor, ) -> ControlFlow<Self::Break>

Invoked for any table factors that appear in the AST before visiting children

fn post_visit_table_factor( &mut self, _table_factor: &mut TableFactor, ) -> ControlFlow<Self::Break>

Invoked for any table factors that appear in the AST after visiting children

fn pre_visit_expr(&mut self, _expr: &mut Expr) -> ControlFlow<Self::Break>

Invoked for any expressions that appear in the AST before visiting children

fn post_visit_expr(&mut self, _expr: &mut Expr) -> ControlFlow<Self::Break>

Invoked for any expressions that appear in the AST

fn pre_visit_statement( &mut self, _statement: &mut Statement, ) -> ControlFlow<Self::Break>

Invoked for any statements that appear in the AST before visiting children

fn post_visit_statement( &mut self, _statement: &mut Statement, ) -> ControlFlow<Self::Break>

Invoked for any statements that appear in the AST after visiting children

fn pre_visit_value( &mut self, _value: &mut ValueWithSpan, ) -> ControlFlow<Self::Break>

Invoked for any value that appear in the AST before visiting children

fn post_visit_value( &mut self, _value: &mut ValueWithSpan, ) -> ControlFlow<Self::Break>

Invoked for any statements that appear in the AST after visiting children

fn pre_visit_ident(&mut self, _ident: &mut Ident) -> ControlFlow<Self::Break>

Invoked for any identifiers that appear in the AST before visiting children

fn post_visit_ident(&mut self, _ident: &mut Ident) -> ControlFlow<Self::Break>

Invoked for any identifiers that appear in the AST after visiting children

fn pre_visit_order_by( &mut self, _order_by: &mut OrderBy, ) -> ControlFlow<Self::Break>

Invoked for any ORDER BY clauses that appear in the AST before visiting children

fn post_visit_order_by( &mut self, _order_by: &mut OrderBy, ) -> ControlFlow<Self::Break>

Invoked for any ORDER BY clauses that appear in the AST after visiting children

fn pre_visit_order_by_expr( &mut self, _order_by_expr: &mut OrderByExpr, ) -> ControlFlow<Self::Break>

Invoked for any ORDER BY expressions that appear in the AST before visiting children

fn post_visit_order_by_expr( &mut self, _order_by_expr: &mut OrderByExpr, ) -> ControlFlow<Self::Break>

Invoked for any ORDER BY expressions that appear in the AST after visiting children

fn pre_visit_group_by( &mut self, _group_by: &mut GroupByExpr, ) -> ControlFlow<Self::Break>

Invoked for any GROUP BY clauses that appear in the AST before visiting children

fn post_visit_group_by( &mut self, _group_by: &mut GroupByExpr, ) -> ControlFlow<Self::Break>

Invoked for any GROUP BY clauses that appear in the AST after visiting children

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors