refactor: InfluxQL parser improvements (#7403)

* chore: Simplify insta snapshots

* chore: Extract struct-like enums to structs

This is in line with DataFusion, which also represents many of its
expression types as struct. The change permits explicit visit
methods for these new types.

These changes will be used by rewriting and visitors to treat the
types, such as Call as an atomic unit that can be replaced.

Cargo.lock

@@ -2615,6 +2615,7 @@ dependencies = [
  "nom",
  "num-traits",
  "once_cell",
+ "paste",
  "test_helpers",
  "workspace-hack",
 ]

influxdb_influxql_parser/Cargo.toml

@@ -17,3 +17,4 @@ workspace-hack = { version = "0.1", path = "../workspace-hack" }
 test_helpers = { path = "../test_helpers" }
 assert_matches = "1"
 insta = { version = "1.29.0", features = ["yaml"] }
+paste = "1.0.12"

influxdb_influxql_parser/src/expression/arithmetic.rs

@@ -18,43 +18,101 @@ use num_traits::cast;
 use std::fmt::{Display, Formatter, Write};
 use std::ops::Neg;
 
+/// Reference to a tag or field key.
+#[derive(Clone, Debug, Ord, PartialOrd, Eq, PartialEq)]
+pub struct VarRef {
+    /// The name of the tag or field.
+    pub name: Identifier,
+
+    /// An optional data type selection specified using the `::` operator.
+    ///
+    /// When the `::` operator follows an identifier, it instructs InfluxQL to fetch
+    /// only data of the matching data type.
+    ///
+    /// The `::` operator appears after an [`Identifier`] and may be described using
+    /// the following EBNF:
+    ///
+    /// ```text
+    /// variable_ref ::= identifier ( "::" data_type )?
+    /// data_type    ::= "float" | "integer" | "boolean" | "string" | "tag" | "field"
+    /// ```
+    ///
+    /// For example:
+    ///
+    /// ```text
+    /// SELECT foo::field, host::tag, usage_idle::integer, idle::boolean FROM cpu
+    /// ```
+    ///
+    /// Specifies the following:
+    ///
+    /// * `foo::field` will return a field of any data type named `foo`
+    /// * `host::tag` will return a tag named `host`
+    /// * `usage_idle::integer` will return either a float or integer field named `usage_idle`,
+    ///   and casting it to an `integer`
+    /// * `idle::boolean` will return a field named `idle` that has a matching data type of
+    ///    `boolean`
+    pub data_type: Option<VarRefDataType>,
+}
+
+impl Display for VarRef {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let Self { name, data_type } = self;
+        write!(f, "{name}")?;
+        if let Some(d) = data_type {
+            write!(f, "::{d}")?;
+        }
+        Ok(())
+    }
+}
+
+/// Function call
+#[derive(Clone, Debug, PartialEq)]
+pub struct Call {
+    /// Represents the name of the function call.
+    pub name: String,
+
+    /// Represents the list of arguments to the function call.
+    pub args: Vec<Expr>,
+}
+
+impl Display for Call {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let Self { name, args } = self;
+        write!(f, "{name}(")?;
+        if !args.is_empty() {
+            let args = args.as_slice();
+            write!(f, "{}", args[0])?;
+            for arg in &args[1..] {
+                write!(f, ", {arg}")?;
+            }
+        }
+        write!(f, ")")
+    }
+}
+
+/// Binary operations, such as `1 + 2`.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Binary {
+    /// Represents the left-hand side of the binary expression.
+    pub lhs: Box<Expr>,
+    /// Represents the operator to apply to the binary expression.
+    pub op: BinaryOperator,
+    /// Represents the right-hand side of the binary expression.
+    pub rhs: Box<Expr>,
+}
+
+impl Display for Binary {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let Self { lhs, op, rhs } = self;
+        write!(f, "{lhs} {op} {rhs}")
+    }
+}
+
 /// An InfluxQL arithmetic expression.
 #[derive(Clone, Debug, PartialEq)]
 pub enum Expr {
     /// Reference to a tag or field key.
-    VarRef {
-        /// The name of the tag or field.
-        name: Identifier,
-
-        /// An optional data type selection specified using the `::` operator.
-        ///
-        /// When the `::` operator follows an identifier, it instructs InfluxQL to fetch
-        /// only data of the matching data type.
-        ///
-        /// The `::` operator appears after an [`Identifier`] and may be described using
-        /// the following EBNF:
-        ///
-        /// ```text
-        /// variable_ref ::= identifier ( "::" data_type )?
-        /// data_type    ::= "float" | "integer" | "boolean" | "string" | "tag" | "field"
-        /// ```
-        ///
-        /// For example:
-        ///
-        /// ```text
-        /// SELECT foo::field, host::tag, usage_idle::integer, idle::boolean FROM cpu
-        /// ```
-        ///
-        /// Specifies the following:
-        ///
-        /// * `foo::field` will return a field of any data type named `foo`
-        /// * `host::tag` will return a tag named `host`
-        /// * `usage_idle::integer` will return either a float or integer field named `usage_idle`,
-        ///   and casting it to an `integer`
-        /// * `idle::boolean` will return a field named `idle` that has a matching data type of
-        ///    `boolean`
-        data_type: Option<VarRefDataType>,
-    },
+    VarRef(VarRef),
 
     /// BindParameter identifier
     BindParameter(BindParameter),
@@ -69,23 +127,10 @@ pub enum Expr {
     Distinct(Identifier),
 
     /// Function call
-    Call {
-        /// Represents the name of the function call.
-        name: String,
-
-        /// Represents the list of arguments to the function call.
-        args: Vec<Expr>,
-    },
+    Call(Call),
 
     /// Binary operations, such as `1 + 2`.
-    Binary {
-        /// Represents the left-hand side of the binary expression.
-        lhs: Box<Expr>,
-        /// Represents the operator to apply to the binary expression.
-        op: BinaryOperator,
-        /// Represents the right-hand side of the binary expression.
-        rhs: Box<Expr>,
-    },
+    Binary(Binary),
 
     /// Nested expression, such as (foo = 'bar') or (1)
     Nested(Box<Expr>),
@@ -136,33 +181,16 @@ impl From<i32> for Box<Expr> {
 impl Display for Expr {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::VarRef { name, data_type } => {
-                write!(f, "{name}")?;
-                if let Some(d) = data_type {
-                    write!(f, "::{d}")?;
-                }
-            }
-            Self::BindParameter(v) => write!(f, "{v}")?,
-            Self::Literal(v) => write!(f, "{v}")?,
-            Self::Binary { lhs, op, rhs } => write!(f, "{lhs} {op} {rhs}")?,
-            Self::Nested(e) => write!(f, "({e})")?,
-            Self::Call { name, args } => {
-                write!(f, "{name}(")?;
-                if !args.is_empty() {
-                    let args = args.as_slice();
-                    write!(f, "{}", args[0])?;
-                    for arg in &args[1..] {
-                        write!(f, ", {arg}")?;
-                    }
-                }
-                write!(f, ")")?;
-            }
-            Self::Wildcard(Some(dt)) => write!(f, "*::{dt}")?,
-            Self::Wildcard(None) => f.write_char('*')?,
-            Self::Distinct(ident) => write!(f, "DISTINCT {ident}")?,
+            Self::VarRef(v) => write!(f, "{v}"),
+            Self::BindParameter(v) => write!(f, "{v}"),
+            Self::Literal(v) => write!(f, "{v}"),
+            Self::Binary(v) => write!(f, "{v}"),
+            Self::Nested(v) => write!(f, "({v})"),
+            Self::Call(v) => write!(f, "{v}"),
+            Self::Wildcard(Some(v)) => write!(f, "*::{v}"),
+            Self::Wildcard(None) => f.write_char('*'),
+            Self::Distinct(v) => write!(f, "DISTINCT {v}"),
         }
-
-        Ok(())
     }
 }
 
@@ -386,11 +414,11 @@ where
                 }
             },
             v @ Expr::VarRef { .. } | v @ Expr::Call { .. } | v @ Expr::Nested(..) | v @ Expr::BindParameter(..) => {
-                Expr::Binary {
+                Expr::Binary(Binary {
                     lhs: Box::new(Expr::Literal(Literal::Integer(-1))),
                     op: BinaryOperator::Mul,
                     rhs: Box::new(v),
-                }
+                })
             }
             _ => {
                 return Err(nom::Err::Failure(Error::from_message(
@@ -444,7 +472,7 @@ where
                 cut(preceded(ws0, char(')'))),
             ),
         ),
-        |(name, args)| Expr::Call { name, args },
+        |(name, args)| Expr::Call(Call { name, args }),
     )(i)
 }
 
@@ -512,7 +540,7 @@ pub(crate) fn var_ref(i: &str) -> ParseResult<&str, Expr> {
                 )
             )),
         ),
-        |(name, data_type)| Expr::VarRef { name, data_type },
+        |(name, data_type)| Expr::VarRef(VarRef { name, data_type }),
     )(i)
 }
 
@@ -580,10 +608,12 @@ pub(crate) trait ArithmeticParsers {
 
 /// Folds `expr` and `remainder` into a [Expr::Binary] tree.
 fn reduce_expr(expr: Expr, remainder: Vec<(BinaryOperator, Expr)>) -> Expr {
-    remainder.into_iter().fold(expr, |lhs, val| Expr::Binary {
-        lhs: lhs.into(),
-        op: val.0,
-        rhs: val.1.into(),
+    remainder.into_iter().fold(expr, |lhs, val| {
+        Expr::Binary(Binary {
+            lhs: lhs.into(),
+            op: val.0,
+            rhs: val.1.into(),
+        })
     })
 }
 
@@ -905,18 +935,18 @@ mod test {
     #[test]
     fn test_var_ref_display() {
         assert_eq!(
-            Expr::VarRef {
+            Expr::VarRef(VarRef {
                 name: "foo".into(),
                 data_type: None
-            }
+            })
             .to_string(),
             "foo"
         );
         assert_eq!(
-            Expr::VarRef {
+            Expr::VarRef(VarRef {
                 name: "foo".into(),
                 data_type: Some(VarRefDataType::Field)
-            }
+            })
             .to_string(),
             "foo::field"
         );

influxdb_influxql_parser/src/expression/conditional.rs

@@ -2,6 +2,7 @@ use crate::common::{ws0, ParseError};
 use crate::expression::arithmetic::{
     arithmetic, call_expression, var_ref, ArithmeticParsers, Expr,
 };
+use crate::expression::Call;
 use crate::internal::Error as InternalError;
 use crate::internal::{expect, verify, ParseResult};
 use crate::keywords::keyword;
@@ -63,6 +64,24 @@ impl Display for ConditionalOperator {
     }
 }
 
+/// Conditional binary operations, such as `foo = 'bar'` or `true AND false`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConditionalBinary {
+    /// Represents the left-hand side of the conditional binary expression.
+    pub lhs: Box<ConditionalExpression>,
+    /// Represents the operator to apply to the conditional binary expression.
+    pub op: ConditionalOperator,
+    /// Represents the right-hand side of the conditional binary expression.
+    pub rhs: Box<ConditionalExpression>,
+}
+
+impl Display for ConditionalBinary {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        let Self { lhs, op, rhs } = self;
+        write!(f, "{lhs} {op} {rhs}")
+    }
+}
+
 /// Represents a conditional expression.
 #[derive(Debug, Clone, PartialEq)]
 pub enum ConditionalExpression {
@@ -70,14 +89,7 @@ pub enum ConditionalExpression {
     Expr(Box<Expr>),
 
     /// Binary operations, such as `foo = 'bar'` or `true AND false`.
-    Binary {
-        /// Represents the left-hand side of the conditional binary expression.
-        lhs: Box<ConditionalExpression>,
-        /// Represents the operator to apply to the conditional binary expression.
-        op: ConditionalOperator,
-        /// Represents the right-hand side of the conditional binary expression.
-        rhs: Box<ConditionalExpression>,
-    },
+    Binary(ConditionalBinary),
 
     /// Represents a conditional expression enclosed in parenthesis.
     Grouped(Box<ConditionalExpression>),
@@ -98,7 +110,7 @@ impl Display for ConditionalExpression {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Expr(v) => fmt::Display::fmt(v, f),
-            Self::Binary { lhs, op, rhs } => write!(f, "{lhs} {op} {rhs}"),
+            Self::Binary(v) => fmt::Display::fmt(v, f),
             Self::Grouped(v) => write!(f, "({v})"),
         }
     }
@@ -268,19 +280,19 @@ fn reduce_expr(
     expr: ConditionalExpression,
     remainder: Vec<(ConditionalOperator, ConditionalExpression)>,
 ) -> ConditionalExpression {
-    remainder
-        .into_iter()
-        .fold(expr, |lhs, val| ConditionalExpression::Binary {
+    remainder.into_iter().fold(expr, |lhs, val| {
+        ConditionalExpression::Binary(ConditionalBinary {
             lhs: lhs.into(),
             op: val.0,
             rhs: val.1.into(),
         })
+    })
 }
 
 /// Returns true if `expr` is a valid [`Expr::Call`] expression for the `now` function.
 pub(crate) fn is_valid_now_call(expr: &Expr) -> bool {
     match expr {
-        Expr::Call { name, args } => name.to_lowercase() == "now" && args.is_empty(),
+        Expr::Call(Call { name, args }) => name.to_lowercase() == "now" && args.is_empty(),
         _ => false,
     }
 }

influxdb_influxql_parser/src/expression/snapshots/influxdb_influxql_parser__expression__walk__test__walk_expr-2.snap

@@ -2,6 +2,6 @@
 source: influxdb_influxql_parser/src/expression/walk.rs
 expression: "walk_expr(\"now() + 1h\")"
 ---
-0: Call { name: "now", args: [] }
+0: Call(Call { name: "now", args: [] })
 1: Literal(Duration(Duration(3600000000000)))
-2: Binary { lhs: Call { name: "now", args: [] }, op: Add, rhs: Literal(Duration(Duration(3600000000000))) }
+2: Binary(Binary { lhs: Call(Call { name: "now", args: [] }), op: Add, rhs: Literal(Duration(Duration(3600000000000))) })

influxdb_influxql_parser/src/expression/snapshots/influxdb_influxql_parser__expression__walk__test__walk_expr.snap

@@ -4,4 +4,4 @@ expression: "walk_expr(\"5 + 6\")"
 ---
 0: Literal(Integer(5))
 1: Literal(Integer(6))
-2: Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) }
+2: Binary(Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) })

influxdb_influxql_parser/src/expression/snapshots/influxdb_influxql_parser__expression__walk__test__walk_expr_mut-2.snap

@@ -2,6 +2,6 @@
 source: influxdb_influxql_parser/src/expression/walk.rs
 expression: "walk_expr_mut(\"now() + 1h\")"
 ---
-0: Call { name: "now", args: [] }
+0: Call(Call { name: "now", args: [] })
 1: Literal(Duration(Duration(3600000000000)))
-2: Binary { lhs: Call { name: "now", args: [] }, op: Add, rhs: Literal(Duration(Duration(3600000000000))) }
+2: Binary(Binary { lhs: Call(Call { name: "now", args: [] }), op: Add, rhs: Literal(Duration(Duration(3600000000000))) })

influxdb_influxql_parser/src/expression/snapshots/influxdb_influxql_parser__expression__walk__test__walk_expr_mut.snap

@@ -4,4 +4,4 @@ expression: "walk_expr_mut(\"5 + 6\")"
 ---
 0: Literal(Integer(5))
 1: Literal(Integer(6))
-2: Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) }
+2: Binary(Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) })

influxdb_influxql_parser/src/expression/snapshots/influxdb_influxql_parser__expression__walk__test__walk_expression-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/expression/walk.rs
 expression: "walk_expression(\"time > now() + 1h\")"
 ---
-0: Arithmetic(VarRef { name: Identifier("time"), data_type: None })
-1: Conditional(Expr(VarRef { name: Identifier("time"), data_type: None }))
-2: Arithmetic(Call { name: "now", args: [] })
+0: Arithmetic(VarRef(VarRef { name: Identifier("time"), data_type: None }))
+1: Conditional(Expr(VarRef(VarRef { name: Identifier("time"), data_type: None })))
+2: Arithmetic(Call(Call { name: "now", args: [] }))
 3: Arithmetic(Literal(Duration(Duration(3600000000000))))
-4: Arithmetic(Binary { lhs: Call { name: "now", args: [] }, op: Add, rhs: Literal(Duration(Duration(3600000000000))) })
-5: Conditional(Expr(Binary { lhs: Call { name: "now", args: [] }, op: Add, rhs: Literal(Duration(Duration(3600000000000))) }))
-6: Conditional(Binary { lhs: Expr(VarRef { name: Identifier("time"), data_type: None }), op: Gt, rhs: Expr(Binary { lhs: Call { name: "now", args: [] }, op: Add, rhs: Literal(Duration(Duration(3600000000000))) }) })
+4: Arithmetic(Binary(Binary { lhs: Call(Call { name: "now", args: [] }), op: Add, rhs: Literal(Duration(Duration(3600000000000))) }))
+5: Conditional(Expr(Binary(Binary { lhs: Call(Call { name: "now", args: [] }), op: Add, rhs: Literal(Duration(Duration(3600000000000))) })))
+6: Conditional(Binary(ConditionalBinary { lhs: Expr(VarRef(VarRef { name: Identifier("time"), data_type: None })), op: Gt, rhs: Expr(Binary(Binary { lhs: Call(Call { name: "now", args: [] }), op: Add, rhs: Literal(Duration(Duration(3600000000000))) })) }))

influxdb_influxql_parser/src/expression/snapshots/influxdb_influxql_parser__expression__walk__test__walk_expression.snap

@@ -4,10 +4,10 @@ expression: "walk_expression(\"5 + 6 = 2 + 9\")"
 ---
 0: Arithmetic(Literal(Integer(5)))
 1: Arithmetic(Literal(Integer(6)))
-2: Arithmetic(Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) })
-3: Conditional(Expr(Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) }))
+2: Arithmetic(Binary(Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) }))
+3: Conditional(Expr(Binary(Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) })))
 4: Arithmetic(Literal(Integer(2)))
 5: Arithmetic(Literal(Integer(9)))
-6: Arithmetic(Binary { lhs: Literal(Integer(2)), op: Add, rhs: Literal(Integer(9)) })
-7: Conditional(Expr(Binary { lhs: Literal(Integer(2)), op: Add, rhs: Literal(Integer(9)) }))
-8: Conditional(Binary { lhs: Expr(Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) }), op: Eq, rhs: Expr(Binary { lhs: Literal(Integer(2)), op: Add, rhs: Literal(Integer(9)) }) })
+6: Arithmetic(Binary(Binary { lhs: Literal(Integer(2)), op: Add, rhs: Literal(Integer(9)) }))
+7: Conditional(Expr(Binary(Binary { lhs: Literal(Integer(2)), op: Add, rhs: Literal(Integer(9)) })))
+8: Conditional(Binary(ConditionalBinary { lhs: Expr(Binary(Binary { lhs: Literal(Integer(5)), op: Add, rhs: Literal(Integer(6)) })), op: Eq, rhs: Expr(Binary(Binary { lhs: Literal(Integer(2)), op: Add, rhs: Literal(Integer(9)) })) }))

influxdb_influxql_parser/src/expression/test_util.rs

@@ -4,17 +4,17 @@
 #[macro_export]
 macro_rules! var_ref {
     ($NAME: literal) => {
-        $crate::expression::arithmetic::Expr::VarRef {
+        $crate::expression::Expr::VarRef($crate::expression::VarRef {
             name: $NAME.into(),
             data_type: None,
-        }
+        })
     };
 
     ($NAME: literal, $TYPE: ident) => {
-        $crate::expression::arithmetic::Expr::VarRef {
+        $crate::expression::Expr::VarRef($crate::expression::VarRef {
             name: $NAME.into(),
             data_type: Some($crate::expression::arithmetic::VarRefDataType::$TYPE),
-        }
+        })
     };
 }
 
@@ -62,16 +62,16 @@ macro_rules! nested {
 #[macro_export]
 macro_rules! call {
     ($NAME:literal) => {
-        $crate::expression::arithmetic::Expr::Call {
+        $crate::expression::Expr::Call($crate::expression::Call {
             name: $NAME.into(),
             args: vec![],
-        }
+        })
     };
     ($NAME:literal, $( $ARG:expr ),+) => {
-        $crate::expression::arithmetic::Expr::Call {
+        $crate::expression::Expr::Call($crate::expression::Call {
             name: $NAME.into(),
             args: vec![$( $ARG ),+],
-        }
+        })
     };
 }
 
@@ -105,11 +105,11 @@ macro_rules! wildcard {
 #[macro_export]
 macro_rules! binary_op {
     ($LHS: expr, $OP: ident, $RHS: expr) => {
-        $crate::expression::arithmetic::Expr::Binary {
+        $crate::expression::Expr::Binary($crate::expression::Binary {
             lhs: $LHS.into(),
-            op: $crate::expression::arithmetic::BinaryOperator::$OP,
+            op: $crate::expression::BinaryOperator::$OP,
             rhs: $RHS.into(),
-        }
+        })
     };
 }
 
@@ -117,14 +117,14 @@ macro_rules! binary_op {
 #[macro_export]
 macro_rules! cond_op {
     ($LHS: expr, $OP: ident, $RHS: expr) => {
-        <$crate::expression::conditional::ConditionalExpression as std::convert::Into<
-            Box<$crate::expression::conditional::ConditionalExpression>,
-        >>::into(
-            $crate::expression::conditional::ConditionalExpression::Binary {
+        <$crate::expression::ConditionalExpression as std::convert::Into<
+            Box<$crate::expression::ConditionalExpression>,
+        >>::into($crate::expression::ConditionalExpression::Binary(
+            $crate::expression::ConditionalBinary {
                 lhs: $LHS.into(),
-                op: $crate::expression::conditional::ConditionalOperator::$OP,
+                op: $crate::expression::ConditionalOperator::$OP,
                 rhs: $RHS.into(),
             },
-        )
+        ))
     };
 }

influxdb_influxql_parser/src/expression/walk.rs

@@ -1,4 +1,4 @@
-use crate::expression::{ConditionalExpression, Expr};
+use crate::expression::{Binary, Call, ConditionalBinary, ConditionalExpression, Expr};
 
 /// Expression distinguishes InfluxQL [`ConditionalExpression`] or [`Expr`]
 /// nodes when visiting a [`ConditionalExpression`] tree. See [`walk_expression`].
@@ -27,7 +27,7 @@ pub fn walk_expression<B>(
 ) -> std::ops::ControlFlow<B> {
     match node {
         ConditionalExpression::Expr(n) => walk_expr(n, &mut |n| visit(Expression::Arithmetic(n)))?,
-        ConditionalExpression::Binary { lhs, rhs, .. } => {
+        ConditionalExpression::Binary(ConditionalBinary { lhs, rhs, .. }) => {
             walk_expression(lhs, visit)?;
             walk_expression(rhs, visit)?;
         }
@@ -46,7 +46,7 @@ pub fn walk_expression_mut<B>(
         ConditionalExpression::Expr(n) => {
             walk_expr_mut(n, &mut |n| visit(ExpressionMut::Arithmetic(n)))?
         }
-        ConditionalExpression::Binary { lhs, rhs, .. } => {
+        ConditionalExpression::Binary(ConditionalBinary { lhs, rhs, .. }) => {
             walk_expression_mut(lhs, visit)?;
             walk_expression_mut(rhs, visit)?;
         }
@@ -62,12 +62,12 @@ pub fn walk_expr<B>(
     visit: &mut impl FnMut(&Expr) -> std::ops::ControlFlow<B>,
 ) -> std::ops::ControlFlow<B> {
     match expr {
-        Expr::Binary { lhs, rhs, .. } => {
+        Expr::Binary(Binary { lhs, rhs, .. }) => {
             walk_expr(lhs, visit)?;
             walk_expr(rhs, visit)?;
         }
         Expr::Nested(n) => walk_expr(n, visit)?,
-        Expr::Call { args, .. } => {
+        Expr::Call(Call { args, .. }) => {
             args.iter().try_for_each(|n| walk_expr(n, visit))?;
         }
         Expr::VarRef { .. }
@@ -86,12 +86,12 @@ pub fn walk_expr_mut<B>(
     visit: &mut impl FnMut(&mut Expr) -> std::ops::ControlFlow<B>,
 ) -> std::ops::ControlFlow<B> {
     match expr {
-        Expr::Binary { lhs, rhs, .. } => {
+        Expr::Binary(Binary { lhs, rhs, .. }) => {
             walk_expr_mut(lhs, visit)?;
             walk_expr_mut(rhs, visit)?;
         }
         Expr::Nested(n) => walk_expr_mut(n, visit)?,
-        Expr::Call { args, .. } => {
+        Expr::Call(Call { args, .. }) => {
             args.iter_mut().try_for_each(|n| walk_expr_mut(n, visit))?;
         }
         Expr::VarRef { .. }
@@ -108,8 +108,8 @@ pub fn walk_expr_mut<B>(
 mod test {
     use crate::expression::walk::{walk_expr_mut, walk_expression_mut, ExpressionMut};
     use crate::expression::{
-        arithmetic_expression, conditional_expression, ConditionalExpression, ConditionalOperator,
-        Expr,
+        arithmetic_expression, conditional_expression, ConditionalBinary, ConditionalExpression,
+        ConditionalOperator, Expr, VarRef,
     };
     use crate::literal::Literal;
 
@@ -137,13 +137,13 @@ mod test {
         walk_expression_mut::<()>(expr, &mut |e| {
             match e {
                 ExpressionMut::Arithmetic(n) => match n {
-                    Expr::VarRef { name, .. } => *name = format!("c_{name}").into(),
+                    Expr::VarRef(VarRef { name, .. }) => *name = format!("c_{name}").into(),
                     Expr::Literal(Literal::Integer(v)) => *v *= 10,
                     Expr::Literal(Literal::Regex(v)) => *v = format!("c_{}", v.0).into(),
                     _ => {}
                 },
                 ExpressionMut::Conditional(n) => {
-                    if let ConditionalExpression::Binary { op, .. } = n {
+                    if let ConditionalExpression::Binary(ConditionalBinary { op, .. }) = n {
                         *op = ConditionalOperator::NotEqRegex
                     }
                 }
@@ -194,7 +194,7 @@ mod test {
         let (_, mut expr) = arithmetic_expression("foo + bar + 5").unwrap();
         walk_expr_mut::<()>(&mut expr, &mut |e| {
             match e {
-                Expr::VarRef { name, .. } => *name = format!("c_{name}").into(),
+                Expr::VarRef(VarRef { name, .. }) => *name = format!("c_{name}").into(),
                 Expr::Literal(Literal::Integer(v)) => *v *= 10,
                 _ => {}
             }

influxdb_influxql_parser/src/identifier.rs

@@ -38,7 +38,7 @@ pub(crate) fn unquoted_identifier(i: &str) -> ParseResult<&str, &str> {
 }
 
 /// A type that represents an InfluxQL identifier.
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+#[derive(Clone, Debug, Eq, Hash, PartialEq, Ord, PartialOrd)]
 pub struct Identifier(pub(crate) String);
 
 impl_tuple_clause!(Identifier, String);

influxdb_influxql_parser/src/select.rs

@@ -12,6 +12,7 @@ use crate::expression::arithmetic::{
     arithmetic, call_expression, var_ref, ArithmeticParsers, Expr, WildcardType,
 };
 use crate::expression::conditional::is_valid_now_call;
+use crate::expression::VarRef;
 use crate::identifier::{identifier, Identifier};
 use crate::impl_tuple_clause;
 use crate::internal::{expect, map_fail, verify, ParseResult};
@@ -372,7 +373,7 @@ impl Parser for Dimension {
             map(regex, Self::Regex),
             map(var_ref, |v| {
                 Self::Tag(match v {
-                    Expr::VarRef { name, .. } => name,
+                    Expr::VarRef(VarRef { name, .. }) => name,
                     // var_ref only returns Expr::VarRef
                     _ => unreachable!(),
                 })

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__delete_statement-2.snap

@@ -2,20 +2,22 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"DELETE WHERE 'foo bar' =~ /foo/\")"
 ---
-- "pre_visit_statement: Delete(Where(WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) })))"
-- "pre_visit_delete_statement: Where(WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) }))"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) }"
-- "pre_visit_conditional_expression: Expr(Literal(String(\"foo bar\")))"
-- "pre_visit_expr: Literal(String(\"foo bar\"))"
-- "post_visit_expr: Literal(String(\"foo bar\"))"
-- "post_visit_conditional_expression: Expr(Literal(String(\"foo bar\")))"
-- "pre_visit_conditional_expression: Expr(Literal(Regex(Regex(\"foo\"))))"
-- "pre_visit_expr: Literal(Regex(Regex(\"foo\")))"
-- "post_visit_expr: Literal(Regex(Regex(\"foo\")))"
-- "post_visit_conditional_expression: Expr(Literal(Regex(Regex(\"foo\"))))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) })"
-- "post_visit_delete_statement: Where(WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) }))"
-- "post_visit_statement: Delete(Where(WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) })))"
+- pre_visit_statement
+- pre_visit_delete_statement
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- post_visit_delete_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__delete_statement-3.snap

@@ -2,12 +2,12 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"DELETE FROM cpu\")"
 ---
-- "pre_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }, condition: None })"
-- "pre_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }, condition: None }"
-- "pre_visit_delete_from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_delete_from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }"
-- "post_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }, condition: None }"
-- "post_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }, condition: None })"
+- pre_visit_statement
+- pre_visit_delete_statement
+- pre_visit_delete_from_clause
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_delete_from_clause
+- post_visit_delete_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__delete_statement-4.snap

@@ -2,12 +2,12 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"DELETE FROM /^cpu/\")"
 ---
-- "pre_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }, condition: None })"
-- "pre_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }, condition: None }"
-- "pre_visit_delete_from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }"
-- "pre_visit_measurement_name: Regex(Regex(\"^cpu\"))"
-- "post_visit_measurement_name: Regex(Regex(\"^cpu\"))"
-- "post_visit_delete_from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }"
-- "post_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }, condition: None }"
-- "post_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }, condition: None })"
+- pre_visit_statement
+- pre_visit_delete_statement
+- pre_visit_delete_from_clause
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_delete_from_clause
+- post_visit_delete_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__delete_statement.snap

@@ -2,24 +2,30 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"DELETE FROM a WHERE b = \\\"c\\\"\")"
 ---
-- "pre_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Name(Identifier(\"a\"))] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })) })"
-- "pre_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Name(Identifier(\"a\"))] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })) }"
-- "pre_visit_delete_from: OneOrMore { contents: [Name(Identifier(\"a\"))] }"
-- "pre_visit_measurement_name: Name(Identifier(\"a\"))"
-- "post_visit_measurement_name: Name(Identifier(\"a\"))"
-- "post_visit_delete_from: OneOrMore { contents: [Name(Identifier(\"a\"))] }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"b\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"b\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"b\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"b\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"c\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"c\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"c\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"c\"), data_type: None })"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })"
-- "post_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Name(Identifier(\"a\"))] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })) }"
-- "post_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Name(Identifier(\"a\"))] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })) })"
+- pre_visit_statement
+- pre_visit_delete_statement
+- pre_visit_delete_from_clause
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_delete_from_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- post_visit_delete_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__drop_measurement_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"DROP MEASUREMENT cpu\")"
 ---
-- "pre_visit_statement: DropMeasurement(DropMeasurementStatement { name: Identifier(\"cpu\") })"
-- "pre_visit_drop_measurement_statement: DropMeasurementStatement { name: Identifier(\"cpu\") }"
-- "post_visit_drop_measurement_statement: DropMeasurementStatement { name: Identifier(\"cpu\") }"
-- "post_visit_statement: DropMeasurement(DropMeasurementStatement { name: Identifier(\"cpu\") })"
+- pre_visit_statement
+- pre_visit_drop_measurement_statement
+- post_visit_drop_measurement_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__explain_statement.snap

@@ -2,24 +2,24 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"EXPLAIN SELECT * FROM cpu\")"
 ---
-- "pre_visit_statement: Explain(ExplainStatement { options: None, select: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None } })"
-- "pre_visit_explain_statement: ExplainStatement { options: None, select: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None } }"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }"
-- "pre_visit_select_field: Field { expr: Wildcard(None), alias: None }"
-- "pre_visit_expr: Wildcard(None)"
-- "post_visit_expr: Wildcard(None)"
-- "post_visit_select_field: Field { expr: Wildcard(None), alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_explain_statement: ExplainStatement { options: None, select: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None } }"
-- "post_visit_statement: Explain(ExplainStatement { options: None, select: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None } })"
+- pre_visit_statement
+- pre_visit_explain_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_explain_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__select_statement-2.snap

@@ -2,22 +2,22 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(r#\"SELECT DISTINCT value FROM temp\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }"
-- "pre_visit_select_field: Field { expr: Distinct(Identifier(\"value\")), alias: None }"
-- "pre_visit_expr: Distinct(Identifier(\"value\"))"
-- "post_visit_expr: Distinct(Identifier(\"value\"))"
-- "post_visit_select_field: Field { expr: Distinct(Identifier(\"value\")), alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__select_statement-3.snap

@@ -2,24 +2,28 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(r#\"SELECT COUNT(value) FROM temp\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }"
-- "pre_visit_expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }"
-- "pre_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }"
-- "post_visit_select_field: Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_call
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_call
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__select_statement-4.snap

@@ -2,24 +2,26 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(r#\"SELECT COUNT(DISTINCT value) FROM temp\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }"
-- "pre_visit_expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }"
-- "pre_visit_expr: Distinct(Identifier(\"value\"))"
-- "post_visit_expr: Distinct(Identifier(\"value\"))"
-- "post_visit_expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }"
-- "post_visit_select_field: Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_call
+- pre_visit_expr
+- post_visit_expr
+- post_visit_call
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__select_statement-5.snap

@@ -2,28 +2,28 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(r#\"SELECT * FROM /cpu/, memory\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }"
-- "pre_visit_select_field: Field { expr: Wildcard(None), alias: None }"
-- "pre_visit_expr: Wildcard(None)"
-- "post_visit_expr: Wildcard(None)"
-- "post_visit_select_field: Field { expr: Wildcard(None), alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }"
-- "pre_visit_measurement_name: Regex(Regex(\"cpu\"))"
-- "post_visit_measurement_name: Regex(Regex(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) })"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"memory\"))"
-- "post_visit_measurement_name: Name(Identifier(\"memory\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__select_statement-6.snap

@@ -2,94 +2,114 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(r#\"SELECT value FROM (SELECT usage FROM cpu WHERE host = \"node1\")\n            WHERE region =~ /west/ AND value > 5\n            GROUP BY TIME(5m), host\n            FILL(previous)\n            ORDER BY TIME DESC\n            LIMIT 1 OFFSET 2\n            SLIMIT 3 SOFFSET 4\n            TZ('Australia/Hobart')\n        \"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }, condition: Some(WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })), group_by: Some(ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }), fill: Some(Previous), order_by: Some(Descending), limit: Some(LimitClause(1)), offset: Some(OffsetClause(2)), series_limit: Some(SLimitClause(3)), series_offset: Some(SOffsetClause(4)), timezone: Some(TimeZoneClause(Australia/Hobart)) })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }, condition: Some(WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })), group_by: Some(ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }), fill: Some(Previous), order_by: Some(Descending), limit: Some(LimitClause(1)), offset: Some(OffsetClause(2)), series_limit: Some(SLimitClause(3)), series_offset: Some(SOffsetClause(4)), timezone: Some(TimeZoneClause(Australia/Hobart)) }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }"
-- "pre_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_select_field: Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }"
-- "pre_visit_select_measurement_selection: Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }"
-- "pre_visit_expr: VarRef { name: Identifier(\"usage\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"usage\"), data_type: None }"
-- "post_visit_select_field: Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"node1\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"node1\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"node1\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"node1\"), data_type: None })"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_select_measurement_selection: Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })"
-- "pre_visit_conditional_expression: Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } }"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"region\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"region\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"region\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"region\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(Literal(Regex(Regex(\"west\"))))"
-- "pre_visit_expr: Literal(Regex(Regex(\"west\")))"
-- "post_visit_expr: Literal(Regex(Regex(\"west\")))"
-- "post_visit_conditional_expression: Expr(Literal(Regex(Regex(\"west\"))))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"value\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"value\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(Literal(Integer(5)))"
-- "pre_visit_expr: Literal(Integer(5))"
-- "post_visit_expr: Literal(Integer(5))"
-- "post_visit_conditional_expression: Expr(Literal(Integer(5)))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) }"
-- "post_visit_conditional_expression: Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })"
-- "pre_visit_group_by_clause: ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }"
-- "pre_visit_select_dimension: Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None })"
-- "pre_visit_select_time_dimension: TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }"
-- "pre_visit_expr: Literal(Duration(Duration(300000000000)))"
-- "post_visit_expr: Literal(Duration(Duration(300000000000)))"
-- "post_visit_select_time_dimension: TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }"
-- "post_visit_select_dimension: Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None })"
-- "pre_visit_select_dimension: Tag(Identifier(\"host\"))"
-- "post_visit_select_dimension: Tag(Identifier(\"host\"))"
-- "post_visit_group_by_clause: ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }"
-- "pre_visit_fill_clause: Previous"
-- "post_visit_fill_clause: Previous"
-- "pre_visit_order_by_clause: Descending"
-- "post_visit_order_by_clause: Descending"
-- "pre_visit_limit_clause: LimitClause(1)"
-- "post_visit_limit_clause: LimitClause(1)"
-- "pre_visit_offset_clause: OffsetClause(2)"
-- "post_visit_offset_clause: OffsetClause(2)"
-- "pre_visit_slimit_clause: SLimitClause(3)"
-- "post_visit_slimit_clause: SLimitClause(3)"
-- "pre_visit_soffset_clause: SOffsetClause(4)"
-- "post_visit_soffset_clause: SOffsetClause(4)"
-- "pre_visit_timezone_clause: TimeZoneClause(Australia/Hobart)"
-- "post_visit_timezone_clause: TimeZoneClause(Australia/Hobart)"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }, condition: Some(WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })), group_by: Some(ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }), fill: Some(Previous), order_by: Some(Descending), limit: Some(LimitClause(1)), offset: Some(OffsetClause(2)), series_limit: Some(SLimitClause(3)), series_offset: Some(SOffsetClause(4)), timezone: Some(TimeZoneClause(Australia/Hobart)) }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }, condition: Some(WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })), group_by: Some(ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }), fill: Some(Previous), order_by: Some(Descending), limit: Some(LimitClause(1)), offset: Some(OffsetClause(2)), series_limit: Some(SLimitClause(3)), series_offset: Some(SOffsetClause(4)), timezone: Some(TimeZoneClause(Australia/Hobart)) })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- post_visit_select_statement
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- pre_visit_group_by_clause
+- pre_visit_select_dimension
+- pre_visit_select_time_dimension
+- pre_visit_expr
+- post_visit_expr
+- post_visit_select_time_dimension
+- post_visit_select_dimension
+- pre_visit_select_dimension
+- post_visit_select_dimension
+- post_visit_group_by_clause
+- pre_visit_fill_clause
+- post_visit_fill_clause
+- pre_visit_order_by_clause
+- post_visit_order_by_clause
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- pre_visit_slimit_clause
+- post_visit_slimit_clause
+- pre_visit_soffset_clause
+- post_visit_soffset_clause
+- pre_visit_timezone_clause
+- post_visit_timezone_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__select_statement.snap

@@ -2,22 +2,24 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(r#\"SELECT value FROM temp\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }"
-- "pre_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_select_field: Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_databases_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW DATABASES\")"
 ---
-- "pre_visit_statement: ShowDatabases(ShowDatabasesStatement)"
-- "pre_visit_show_databases_statement: ShowDatabasesStatement"
-- "post_visit_show_databases_statement: ShowDatabasesStatement"
-- "post_visit_statement: ShowDatabases(ShowDatabasesStatement)"
+- pre_visit_statement
+- pre_visit_show_databases_statement
+- post_visit_show_databases_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_field_keys_statement-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW FIELD KEYS ON telegraf\")"
 ---
-- "pre_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: None, limit: None, offset: None })"
-- "pre_visit_show_field_keys_statement: ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: None, limit: None, offset: None }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "post_visit_show_field_keys_statement: ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: None, limit: None, offset: None }"
-- "post_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_field_keys_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- post_visit_show_field_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_field_keys_statement-3.snap

@@ -2,14 +2,14 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW FIELD KEYS FROM cpu\")"
 ---
-- "pre_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: None, from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), limit: None, offset: None })"
-- "pre_visit_show_field_keys_statement: ShowFieldKeysStatement { database: None, from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), limit: None, offset: None }"
-- "pre_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "post_visit_show_field_keys_statement: ShowFieldKeysStatement { database: None, from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), limit: None, offset: None }"
-- "post_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: None, from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_field_keys_statement
+- pre_visit_show_from_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_show_from_clause
+- post_visit_show_field_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_field_keys_statement-4.snap

@@ -2,16 +2,16 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW FIELD KEYS ON telegraf FROM /cpu/\")"
 ---
-- "pre_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }), limit: None, offset: None })"
-- "pre_visit_show_field_keys_statement: ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }), limit: None, offset: None }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }"
-- "pre_visit_measurement_name: Regex(Regex(\"cpu\"))"
-- "post_visit_measurement_name: Regex(Regex(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }"
-- "post_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }"
-- "post_visit_show_field_keys_statement: ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }), limit: None, offset: None }"
-- "post_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }), limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_field_keys_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- pre_visit_show_from_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_show_from_clause
+- post_visit_show_field_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_field_keys_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW FIELD KEYS\")"
 ---
-- "pre_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: None, from: None, limit: None, offset: None })"
-- "pre_visit_show_field_keys_statement: ShowFieldKeysStatement { database: None, from: None, limit: None, offset: None }"
-- "post_visit_show_field_keys_statement: ShowFieldKeysStatement { database: None, from: None, limit: None, offset: None }"
-- "post_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: None, from: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_field_keys_statement
+- post_visit_show_field_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_measurements_statement-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS ON db.rp\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: Some(DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))), with_measurement: None, condition: None, limit: None, offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: Some(DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))), with_measurement: None, condition: None, limit: None, offset: None }"
-- "pre_visit_extended_on_clause: DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))"
-- "post_visit_extended_on_clause: DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: Some(DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))), with_measurement: None, condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: Some(DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))), with_measurement: None, condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_extended_on_clause
+- post_visit_extended_on_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_measurements_statement-3.snap

@@ -2,14 +2,14 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS WITH MEASUREMENT = \\\"cpu\\\"\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: Some(Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })), condition: None, limit: None, offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: Some(Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })), condition: None, limit: None, offset: None }"
-- "pre_visit_with_measurement_clause: Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_with_measurement_clause: Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: Some(Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })), condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: Some(Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })), condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_with_measurement_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_with_measurement_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_measurements_statement-4.snap

@@ -2,20 +2,24 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS WHERE host = 'west'\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: None, offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: None, offset: None }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(Literal(String(\"west\")))"
-- "pre_visit_expr: Literal(String(\"west\"))"
-- "post_visit_expr: Literal(String(\"west\"))"
-- "post_visit_conditional_expression: Expr(Literal(String(\"west\")))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: None, offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_measurements_statement-5.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS LIMIT 5\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: Some(LimitClause(5)), offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: Some(LimitClause(5)), offset: None }"
-- "pre_visit_limit_clause: LimitClause(5)"
-- "post_visit_limit_clause: LimitClause(5)"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: Some(LimitClause(5)), offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: Some(LimitClause(5)), offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_measurements_statement-6.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS OFFSET 10\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: Some(OffsetClause(10)) })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: Some(OffsetClause(10)) }"
-- "pre_visit_offset_clause: OffsetClause(10)"
-- "post_visit_offset_clause: OffsetClause(10)"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: Some(OffsetClause(10)) }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: Some(OffsetClause(10)) })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_measurements_statement-7.snap

@@ -2,32 +2,36 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS ON * WITH MEASUREMENT =~ /foo/ WHERE host = 'west' LIMIT 10 OFFSET 20\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: Some(AllDatabases), with_measurement: Some(Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: Some(LimitClause(10)), offset: Some(OffsetClause(20)) })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: Some(AllDatabases), with_measurement: Some(Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: Some(LimitClause(10)), offset: Some(OffsetClause(20)) }"
-- "pre_visit_extended_on_clause: AllDatabases"
-- "post_visit_extended_on_clause: AllDatabases"
-- "pre_visit_with_measurement_clause: Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) }"
-- "pre_visit_measurement_name: Regex(Regex(\"foo\"))"
-- "post_visit_measurement_name: Regex(Regex(\"foo\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) }"
-- "post_visit_with_measurement_clause: Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(Literal(String(\"west\")))"
-- "pre_visit_expr: Literal(String(\"west\"))"
-- "post_visit_expr: Literal(String(\"west\"))"
-- "post_visit_conditional_expression: Expr(Literal(String(\"west\")))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })"
-- "pre_visit_limit_clause: LimitClause(10)"
-- "post_visit_limit_clause: LimitClause(10)"
-- "pre_visit_offset_clause: OffsetClause(20)"
-- "post_visit_offset_clause: OffsetClause(20)"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: Some(AllDatabases), with_measurement: Some(Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: Some(LimitClause(10)), offset: Some(OffsetClause(20)) }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: Some(AllDatabases), with_measurement: Some(Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: Some(LimitClause(10)), offset: Some(OffsetClause(20)) })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_extended_on_clause
+- post_visit_extended_on_clause
+- pre_visit_with_measurement_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_with_measurement_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_measurements_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: None }"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_retention_policies_statement-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW RETENTION POLICIES ON telegraf\")"
 ---
-- "pre_visit_statement: ShowRetentionPolicies(ShowRetentionPoliciesStatement { database: Some(OnClause(Identifier(\"telegraf\"))) })"
-- "pre_visit_show_retention_policies_statement: ShowRetentionPoliciesStatement { database: Some(OnClause(Identifier(\"telegraf\"))) }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "post_visit_show_retention_policies_statement: ShowRetentionPoliciesStatement { database: Some(OnClause(Identifier(\"telegraf\"))) }"
-- "post_visit_statement: ShowRetentionPolicies(ShowRetentionPoliciesStatement { database: Some(OnClause(Identifier(\"telegraf\"))) })"
+- pre_visit_statement
+- pre_visit_show_retention_policies_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- post_visit_show_retention_policies_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_retention_policies_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW RETENTION POLICIES\")"
 ---
-- "pre_visit_statement: ShowRetentionPolicies(ShowRetentionPoliciesStatement { database: None })"
-- "pre_visit_show_retention_policies_statement: ShowRetentionPoliciesStatement { database: None }"
-- "post_visit_show_retention_policies_statement: ShowRetentionPoliciesStatement { database: None }"
-- "post_visit_statement: ShowRetentionPolicies(ShowRetentionPoliciesStatement { database: None })"
+- pre_visit_statement
+- pre_visit_show_retention_policies_statement
+- post_visit_show_retention_policies_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_tag_keys_statement-2.snap

@@ -2,32 +2,38 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW TAG KEYS ON telegraf FROM cpu WHERE host = \\\"west\\\" LIMIT 5 OFFSET 10\")"
 ---
-- "pre_visit_statement: ShowTagKeys(ShowTagKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) })"
-- "pre_visit_show_tag_keys_statement: ShowTagKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"west\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"west\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"west\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"west\"), data_type: None })"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })"
-- "pre_visit_limit_clause: LimitClause(5)"
-- "post_visit_limit_clause: LimitClause(5)"
-- "pre_visit_offset_clause: OffsetClause(10)"
-- "post_visit_offset_clause: OffsetClause(10)"
-- "post_visit_show_tag_keys_statement: ShowTagKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) }"
-- "post_visit_statement: ShowTagKeys(ShowTagKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) })"
+- pre_visit_statement
+- pre_visit_show_tag_keys_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- pre_visit_show_from_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_show_from_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- post_visit_show_tag_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_tag_keys_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW TAG KEYS\")"
 ---
-- "pre_visit_statement: ShowTagKeys(ShowTagKeysStatement { database: None, from: None, condition: None, limit: None, offset: None })"
-- "pre_visit_show_tag_keys_statement: ShowTagKeysStatement { database: None, from: None, condition: None, limit: None, offset: None }"
-- "post_visit_show_tag_keys_statement: ShowTagKeysStatement { database: None, from: None, condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowTagKeys(ShowTagKeysStatement { database: None, from: None, condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_tag_keys_statement
+- post_visit_show_tag_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_tag_values_statement-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW TAG VALUES WITH KEY =~ /host|region/\")"
 ---
-- "pre_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: EqRegex(Regex(\"host|region\")), condition: None, limit: None, offset: None })"
-- "pre_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: EqRegex(Regex(\"host|region\")), condition: None, limit: None, offset: None }"
-- "pre_visit_with_key_clause: EqRegex(Regex(\"host|region\"))"
-- "post_visit_with_key_clause: EqRegex(Regex(\"host|region\"))"
-- "post_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: EqRegex(Regex(\"host|region\")), condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: EqRegex(Regex(\"host|region\")), condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_tag_values_statement
+- pre_visit_with_key_clause
+- post_visit_with_key_clause
+- post_visit_show_tag_values_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_tag_values_statement-3.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW TAG VALUES WITH KEY IN (host, region)\")"
 ---
-- "pre_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] }), condition: None, limit: None, offset: None })"
-- "pre_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] }), condition: None, limit: None, offset: None }"
-- "pre_visit_with_key_clause: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] })"
-- "post_visit_with_key_clause: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] })"
-- "post_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] }), condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] }), condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_tag_values_statement
+- pre_visit_with_key_clause
+- post_visit_with_key_clause
+- post_visit_show_tag_values_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_tag_values_statement-4.snap

@@ -2,34 +2,40 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW TAG VALUES ON telegraf FROM cpu WITH KEY = host WHERE host = \\\"west\\\" LIMIT 5 OFFSET 10\")"
 ---
-- "pre_visit_statement: ShowTagValues(ShowTagValuesStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), with_key: Eq(Identifier(\"host\")), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) })"
-- "pre_visit_show_tag_values_statement: ShowTagValuesStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), with_key: Eq(Identifier(\"host\")), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_with_key_clause: Eq(Identifier(\"host\"))"
-- "post_visit_with_key_clause: Eq(Identifier(\"host\"))"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"west\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"west\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"west\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"west\"), data_type: None })"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })"
-- "pre_visit_limit_clause: LimitClause(5)"
-- "post_visit_limit_clause: LimitClause(5)"
-- "pre_visit_offset_clause: OffsetClause(10)"
-- "post_visit_offset_clause: OffsetClause(10)"
-- "post_visit_show_tag_values_statement: ShowTagValuesStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), with_key: Eq(Identifier(\"host\")), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) }"
-- "post_visit_statement: ShowTagValues(ShowTagValuesStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), with_key: Eq(Identifier(\"host\")), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) })"
+- pre_visit_statement
+- pre_visit_show_tag_values_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- pre_visit_show_from_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_show_from_clause
+- pre_visit_with_key_clause
+- post_visit_with_key_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- post_visit_show_tag_values_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit__test__show_tag_values_statement.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit.rs
 expression: "visit_statement!(\"SHOW TAG VALUES WITH KEY = host\")"
 ---
-- "pre_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: Eq(Identifier(\"host\")), condition: None, limit: None, offset: None })"
-- "pre_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: Eq(Identifier(\"host\")), condition: None, limit: None, offset: None }"
-- "pre_visit_with_key_clause: Eq(Identifier(\"host\"))"
-- "post_visit_with_key_clause: Eq(Identifier(\"host\"))"
-- "post_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: Eq(Identifier(\"host\")), condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: Eq(Identifier(\"host\")), condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_tag_values_statement
+- pre_visit_with_key_clause
+- post_visit_with_key_clause
+- post_visit_show_tag_values_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__delete_statement-2.snap

@@ -2,20 +2,22 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"DELETE WHERE 'foo bar' =~ /foo/\")"
 ---
-- "pre_visit_statement: Delete(Where(WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) })))"
-- "pre_visit_delete_statement: Where(WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) }))"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) }"
-- "pre_visit_conditional_expression: Expr(Literal(String(\"foo bar\")))"
-- "pre_visit_expr: Literal(String(\"foo bar\"))"
-- "post_visit_expr: Literal(String(\"foo bar\"))"
-- "post_visit_conditional_expression: Expr(Literal(String(\"foo bar\")))"
-- "pre_visit_conditional_expression: Expr(Literal(Regex(Regex(\"foo\"))))"
-- "pre_visit_expr: Literal(Regex(Regex(\"foo\")))"
-- "post_visit_expr: Literal(Regex(Regex(\"foo\")))"
-- "post_visit_conditional_expression: Expr(Literal(Regex(Regex(\"foo\"))))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) })"
-- "post_visit_delete_statement: Where(WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) }))"
-- "post_visit_statement: Delete(Where(WhereClause(Binary { lhs: Expr(Literal(String(\"foo bar\"))), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"foo\")))) })))"
+- pre_visit_statement
+- pre_visit_delete_statement
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- post_visit_delete_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__delete_statement-3.snap

@@ -2,12 +2,12 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"DELETE FROM cpu\")"
 ---
-- "pre_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }, condition: None })"
-- "pre_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }, condition: None }"
-- "pre_visit_delete_from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_delete_from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }"
-- "post_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }, condition: None }"
-- "post_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Name(Identifier(\"cpu\"))] }, condition: None })"
+- pre_visit_statement
+- pre_visit_delete_statement
+- pre_visit_delete_from_clause
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_delete_from_clause
+- post_visit_delete_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__delete_statement-4.snap

@@ -2,12 +2,12 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"DELETE FROM /^cpu/\")"
 ---
-- "pre_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }, condition: None })"
-- "pre_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }, condition: None }"
-- "pre_visit_delete_from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }"
-- "pre_visit_measurement_name: Regex(Regex(\"^cpu\"))"
-- "post_visit_measurement_name: Regex(Regex(\"^cpu\"))"
-- "post_visit_delete_from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }"
-- "post_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }, condition: None }"
-- "post_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Regex(Regex(\"^cpu\"))] }, condition: None })"
+- pre_visit_statement
+- pre_visit_delete_statement
+- pre_visit_delete_from_clause
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_delete_from_clause
+- post_visit_delete_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__delete_statement.snap

@@ -2,24 +2,30 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"DELETE FROM a WHERE b = \\\"c\\\"\")"
 ---
-- "pre_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Name(Identifier(\"a\"))] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })) })"
-- "pre_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Name(Identifier(\"a\"))] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })) }"
-- "pre_visit_delete_from: OneOrMore { contents: [Name(Identifier(\"a\"))] }"
-- "pre_visit_measurement_name: Name(Identifier(\"a\"))"
-- "post_visit_measurement_name: Name(Identifier(\"a\"))"
-- "post_visit_delete_from: OneOrMore { contents: [Name(Identifier(\"a\"))] }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"b\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"b\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"b\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"b\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"c\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"c\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"c\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"c\"), data_type: None })"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })"
-- "post_visit_delete_statement: FromWhere { from: OneOrMore { contents: [Name(Identifier(\"a\"))] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })) }"
-- "post_visit_statement: Delete(FromWhere { from: OneOrMore { contents: [Name(Identifier(\"a\"))] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"b\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"c\"), data_type: None }) })) })"
+- pre_visit_statement
+- pre_visit_delete_statement
+- pre_visit_delete_from_clause
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_delete_from_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- post_visit_delete_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__drop_measurement_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"DROP MEASUREMENT cpu\")"
 ---
-- "pre_visit_statement: DropMeasurement(DropMeasurementStatement { name: Identifier(\"cpu\") })"
-- "pre_visit_drop_measurement_statement: DropMeasurementStatement { name: Identifier(\"cpu\") }"
-- "post_visit_drop_measurement_statement: DropMeasurementStatement { name: Identifier(\"cpu\") }"
-- "post_visit_statement: DropMeasurement(DropMeasurementStatement { name: Identifier(\"cpu\") })"
+- pre_visit_statement
+- pre_visit_drop_measurement_statement
+- post_visit_drop_measurement_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__explain_statement.snap

@@ -2,24 +2,24 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"EXPLAIN SELECT * FROM cpu\")"
 ---
-- "pre_visit_statement: Explain(ExplainStatement { options: None, select: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None } })"
-- "pre_visit_explain_statement: ExplainStatement { options: None, select: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None } }"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }"
-- "pre_visit_select_field: Field { expr: Wildcard(None), alias: None }"
-- "pre_visit_expr: Wildcard(None)"
-- "post_visit_expr: Wildcard(None)"
-- "post_visit_select_field: Field { expr: Wildcard(None), alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_explain_statement: ExplainStatement { options: None, select: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None } }"
-- "post_visit_statement: Explain(ExplainStatement { options: None, select: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None } })"
+- pre_visit_statement
+- pre_visit_explain_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_explain_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__select_statement-2.snap

@@ -2,22 +2,22 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(r#\"SELECT DISTINCT value FROM temp\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }"
-- "pre_visit_select_field: Field { expr: Distinct(Identifier(\"value\")), alias: None }"
-- "pre_visit_expr: Distinct(Identifier(\"value\"))"
-- "post_visit_expr: Distinct(Identifier(\"value\"))"
-- "post_visit_select_field: Field { expr: Distinct(Identifier(\"value\")), alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Distinct(Identifier(\"value\")), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__select_statement-3.snap

@@ -2,24 +2,28 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(r#\"SELECT COUNT(value) FROM temp\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }"
-- "pre_visit_expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }"
-- "pre_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }"
-- "post_visit_select_field: Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [VarRef { name: Identifier(\"value\"), data_type: None }] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_call
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_call
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__select_statement-4.snap

@@ -2,24 +2,26 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(r#\"SELECT COUNT(DISTINCT value) FROM temp\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }"
-- "pre_visit_expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }"
-- "pre_visit_expr: Distinct(Identifier(\"value\"))"
-- "post_visit_expr: Distinct(Identifier(\"value\"))"
-- "post_visit_expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }"
-- "post_visit_select_field: Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Call { name: \"count\", args: [Distinct(Identifier(\"value\"))] }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_call
+- pre_visit_expr
+- post_visit_expr
+- post_visit_call
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__select_statement-5.snap

@@ -2,28 +2,28 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(r#\"SELECT * FROM /cpu/, memory\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }"
-- "pre_visit_select_field: Field { expr: Wildcard(None), alias: None }"
-- "pre_visit_expr: Wildcard(None)"
-- "post_visit_expr: Wildcard(None)"
-- "post_visit_select_field: Field { expr: Wildcard(None), alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }"
-- "pre_visit_measurement_name: Regex(Regex(\"cpu\"))"
-- "post_visit_measurement_name: Regex(Regex(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) })"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"memory\"))"
-- "post_visit_measurement_name: Name(Identifier(\"memory\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: Wildcard(None), alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }), Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"memory\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__select_statement-6.snap

@@ -2,94 +2,114 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(r#\"SELECT value FROM (SELECT usage FROM cpu WHERE host = \"node1\")\n            WHERE region =~ /west/ AND value > 5\n            GROUP BY TIME(5m), host\n            FILL(previous)\n            ORDER BY TIME DESC\n            LIMIT 1 OFFSET 2\n            SLIMIT 3 SOFFSET 4\n            TZ('Australia/Hobart')\n        \"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }, condition: Some(WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })), group_by: Some(ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }), fill: Some(Previous), order_by: Some(Descending), limit: Some(LimitClause(1)), offset: Some(OffsetClause(2)), series_limit: Some(SLimitClause(3)), series_offset: Some(SOffsetClause(4)), timezone: Some(TimeZoneClause(Australia/Hobart)) })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }, condition: Some(WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })), group_by: Some(ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }), fill: Some(Previous), order_by: Some(Descending), limit: Some(LimitClause(1)), offset: Some(OffsetClause(2)), series_limit: Some(SLimitClause(3)), series_offset: Some(SOffsetClause(4)), timezone: Some(TimeZoneClause(Australia/Hobart)) }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }"
-- "pre_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_select_field: Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }"
-- "pre_visit_select_measurement_selection: Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }"
-- "pre_visit_expr: VarRef { name: Identifier(\"usage\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"usage\"), data_type: None }"
-- "post_visit_select_field: Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"node1\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"node1\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"node1\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"node1\"), data_type: None })"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_select_measurement_selection: Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })"
-- "pre_visit_conditional_expression: Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } }"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"region\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"region\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"region\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"region\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(Literal(Regex(Regex(\"west\"))))"
-- "pre_visit_expr: Literal(Regex(Regex(\"west\")))"
-- "post_visit_expr: Literal(Regex(Regex(\"west\")))"
-- "post_visit_conditional_expression: Expr(Literal(Regex(Regex(\"west\"))))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"value\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"value\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(Literal(Integer(5)))"
-- "pre_visit_expr: Literal(Integer(5))"
-- "post_visit_expr: Literal(Integer(5))"
-- "post_visit_conditional_expression: Expr(Literal(Integer(5)))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) }"
-- "post_visit_conditional_expression: Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })"
-- "pre_visit_group_by_clause: ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }"
-- "pre_visit_select_dimension: Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None })"
-- "pre_visit_select_time_dimension: TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }"
-- "pre_visit_expr: Literal(Duration(Duration(300000000000)))"
-- "post_visit_expr: Literal(Duration(Duration(300000000000)))"
-- "post_visit_select_time_dimension: TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }"
-- "post_visit_select_dimension: Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None })"
-- "pre_visit_select_dimension: Tag(Identifier(\"host\"))"
-- "post_visit_select_dimension: Tag(Identifier(\"host\"))"
-- "post_visit_group_by_clause: ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }"
-- "pre_visit_fill_clause: Previous"
-- "post_visit_fill_clause: Previous"
-- "pre_visit_order_by_clause: Descending"
-- "post_visit_order_by_clause: Descending"
-- "pre_visit_limit_clause: LimitClause(1)"
-- "post_visit_limit_clause: LimitClause(1)"
-- "pre_visit_offset_clause: OffsetClause(2)"
-- "post_visit_offset_clause: OffsetClause(2)"
-- "pre_visit_slimit_clause: SLimitClause(3)"
-- "post_visit_slimit_clause: SLimitClause(3)"
-- "pre_visit_soffset_clause: SOffsetClause(4)"
-- "post_visit_soffset_clause: SOffsetClause(4)"
-- "pre_visit_timezone_clause: TimeZoneClause(Australia/Hobart)"
-- "post_visit_timezone_clause: TimeZoneClause(Australia/Hobart)"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }, condition: Some(WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })), group_by: Some(ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }), fill: Some(Previous), order_by: Some(Descending), limit: Some(LimitClause(1)), offset: Some(OffsetClause(2)), series_limit: Some(SLimitClause(3)), series_offset: Some(SOffsetClause(4)), timezone: Some(TimeZoneClause(Australia/Hobart)) }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Subquery(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"usage\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })] }, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"node1\"), data_type: None }) })), group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })] }, condition: Some(WhereClause(Binary { lhs: Binary { lhs: Expr(VarRef { name: Identifier(\"region\"), data_type: None }), op: EqRegex, rhs: Expr(Literal(Regex(Regex(\"west\")))) }, op: And, rhs: Binary { lhs: Expr(VarRef { name: Identifier(\"value\"), data_type: None }), op: Gt, rhs: Expr(Literal(Integer(5))) } })), group_by: Some(ZeroOrMore { contents: [Time(TimeDimension { interval: Literal(Duration(Duration(300000000000))), offset: None }), Tag(Identifier(\"host\"))] }), fill: Some(Previous), order_by: Some(Descending), limit: Some(LimitClause(1)), offset: Some(OffsetClause(2)), series_limit: Some(SLimitClause(3)), series_offset: Some(SOffsetClause(4)), timezone: Some(TimeZoneClause(Australia/Hobart)) })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- post_visit_select_statement
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- pre_visit_group_by_clause
+- pre_visit_select_dimension
+- pre_visit_select_time_dimension
+- pre_visit_expr
+- post_visit_expr
+- post_visit_select_time_dimension
+- post_visit_select_dimension
+- pre_visit_select_dimension
+- post_visit_select_dimension
+- post_visit_group_by_clause
+- pre_visit_fill_clause
+- post_visit_fill_clause
+- pre_visit_order_by_clause
+- post_visit_order_by_clause
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- pre_visit_slimit_clause
+- post_visit_slimit_clause
+- pre_visit_soffset_clause
+- post_visit_soffset_clause
+- pre_visit_timezone_clause
+- post_visit_timezone_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__select_statement.snap

@@ -2,22 +2,24 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(r#\"SELECT value FROM temp\"#)"
 ---
-- "pre_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
-- "pre_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "pre_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_field: Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }"
-- "pre_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"value\"), data_type: None }"
-- "post_visit_select_field: Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }"
-- "post_visit_select_field_list: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }"
-- "pre_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "pre_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_measurement_name: Name(Identifier(\"temp\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) }"
-- "post_visit_select_measurement_selection: Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })"
-- "post_visit_select_from_clause: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }"
-- "post_visit_select_statement: SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None }"
-- "post_visit_statement: Select(SelectStatement { fields: ZeroOrMore { contents: [Field { expr: VarRef { name: Identifier(\"value\"), data_type: None }, alias: None }] }, from: ZeroOrMore { contents: [Name(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"temp\")) })] }, condition: None, group_by: None, fill: None, order_by: None, limit: None, offset: None, series_limit: None, series_offset: None, timezone: None })"
+- pre_visit_statement
+- pre_visit_select_statement
+- pre_visit_select_field_list
+- pre_visit_select_field
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_select_field
+- post_visit_select_field_list
+- pre_visit_select_from_clause
+- pre_visit_select_measurement_selection
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_select_measurement_selection
+- post_visit_select_from_clause
+- post_visit_select_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_databases_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW DATABASES\")"
 ---
-- "pre_visit_statement: ShowDatabases(ShowDatabasesStatement)"
-- "pre_visit_show_databases_statement: ShowDatabasesStatement"
-- "post_visit_show_databases_statement: ShowDatabasesStatement"
-- "post_visit_statement: ShowDatabases(ShowDatabasesStatement)"
+- pre_visit_statement
+- pre_visit_show_databases_statement
+- post_visit_show_databases_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_field_keys_statement-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW FIELD KEYS ON telegraf\")"
 ---
-- "pre_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: None, limit: None, offset: None })"
-- "pre_visit_show_field_keys_statement: ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: None, limit: None, offset: None }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "post_visit_show_field_keys_statement: ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: None, limit: None, offset: None }"
-- "post_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_field_keys_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- post_visit_show_field_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_field_keys_statement-3.snap

@@ -2,14 +2,14 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW FIELD KEYS FROM cpu\")"
 ---
-- "pre_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: None, from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), limit: None, offset: None })"
-- "pre_visit_show_field_keys_statement: ShowFieldKeysStatement { database: None, from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), limit: None, offset: None }"
-- "pre_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "post_visit_show_field_keys_statement: ShowFieldKeysStatement { database: None, from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), limit: None, offset: None }"
-- "post_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: None, from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_field_keys_statement
+- pre_visit_show_from_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_show_from_clause
+- post_visit_show_field_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_field_keys_statement-4.snap

@@ -2,16 +2,16 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW FIELD KEYS ON telegraf FROM /cpu/\")"
 ---
-- "pre_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }), limit: None, offset: None })"
-- "pre_visit_show_field_keys_statement: ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }), limit: None, offset: None }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }"
-- "pre_visit_measurement_name: Regex(Regex(\"cpu\"))"
-- "post_visit_measurement_name: Regex(Regex(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }"
-- "post_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }"
-- "post_visit_show_field_keys_statement: ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }), limit: None, offset: None }"
-- "post_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"cpu\")) }] }), limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_field_keys_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- pre_visit_show_from_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_show_from_clause
+- post_visit_show_field_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_field_keys_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW FIELD KEYS\")"
 ---
-- "pre_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: None, from: None, limit: None, offset: None })"
-- "pre_visit_show_field_keys_statement: ShowFieldKeysStatement { database: None, from: None, limit: None, offset: None }"
-- "post_visit_show_field_keys_statement: ShowFieldKeysStatement { database: None, from: None, limit: None, offset: None }"
-- "post_visit_statement: ShowFieldKeys(ShowFieldKeysStatement { database: None, from: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_field_keys_statement
+- post_visit_show_field_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_measurements_statement-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS ON db.rp\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: Some(DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))), with_measurement: None, condition: None, limit: None, offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: Some(DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))), with_measurement: None, condition: None, limit: None, offset: None }"
-- "pre_visit_extended_on_clause: DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))"
-- "post_visit_extended_on_clause: DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: Some(DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))), with_measurement: None, condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: Some(DatabaseRetentionPolicy(Identifier(\"db\"), Identifier(\"rp\"))), with_measurement: None, condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_extended_on_clause
+- post_visit_extended_on_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_measurements_statement-3.snap

@@ -2,14 +2,14 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS WITH MEASUREMENT = \\\"cpu\\\"\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: Some(Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })), condition: None, limit: None, offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: Some(Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })), condition: None, limit: None, offset: None }"
-- "pre_visit_with_measurement_clause: Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_with_measurement_clause: Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: Some(Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })), condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: Some(Equals(QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) })), condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_with_measurement_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_with_measurement_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_measurements_statement-4.snap

@@ -2,20 +2,24 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS WHERE host = 'west'\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: None, offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: None, offset: None }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(Literal(String(\"west\")))"
-- "pre_visit_expr: Literal(String(\"west\"))"
-- "post_visit_expr: Literal(String(\"west\"))"
-- "post_visit_conditional_expression: Expr(Literal(String(\"west\")))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: None, offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_measurements_statement-5.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS LIMIT 5\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: Some(LimitClause(5)), offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: Some(LimitClause(5)), offset: None }"
-- "pre_visit_limit_clause: LimitClause(5)"
-- "post_visit_limit_clause: LimitClause(5)"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: Some(LimitClause(5)), offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: Some(LimitClause(5)), offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_measurements_statement-6.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS OFFSET 10\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: Some(OffsetClause(10)) })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: Some(OffsetClause(10)) }"
-- "pre_visit_offset_clause: OffsetClause(10)"
-- "post_visit_offset_clause: OffsetClause(10)"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: Some(OffsetClause(10)) }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: Some(OffsetClause(10)) })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_measurements_statement-7.snap

@@ -2,32 +2,36 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS ON * WITH MEASUREMENT =~ /foo/ WHERE host = 'west' LIMIT 10 OFFSET 20\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: Some(AllDatabases), with_measurement: Some(Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: Some(LimitClause(10)), offset: Some(OffsetClause(20)) })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: Some(AllDatabases), with_measurement: Some(Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: Some(LimitClause(10)), offset: Some(OffsetClause(20)) }"
-- "pre_visit_extended_on_clause: AllDatabases"
-- "post_visit_extended_on_clause: AllDatabases"
-- "pre_visit_with_measurement_clause: Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) }"
-- "pre_visit_measurement_name: Regex(Regex(\"foo\"))"
-- "post_visit_measurement_name: Regex(Regex(\"foo\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) }"
-- "post_visit_with_measurement_clause: Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(Literal(String(\"west\")))"
-- "pre_visit_expr: Literal(String(\"west\"))"
-- "post_visit_expr: Literal(String(\"west\"))"
-- "post_visit_conditional_expression: Expr(Literal(String(\"west\")))"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })"
-- "pre_visit_limit_clause: LimitClause(10)"
-- "post_visit_limit_clause: LimitClause(10)"
-- "pre_visit_offset_clause: OffsetClause(20)"
-- "post_visit_offset_clause: OffsetClause(20)"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: Some(AllDatabases), with_measurement: Some(Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: Some(LimitClause(10)), offset: Some(OffsetClause(20)) }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: Some(AllDatabases), with_measurement: Some(Regex(QualifiedMeasurementName { database: None, retention_policy: None, name: Regex(Regex(\"foo\")) })), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(Literal(String(\"west\"))) })), limit: Some(LimitClause(10)), offset: Some(OffsetClause(20)) })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- pre_visit_extended_on_clause
+- post_visit_extended_on_clause
+- pre_visit_with_measurement_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_with_measurement_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_measurements_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW MEASUREMENTS\")"
 ---
-- "pre_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: None })"
-- "pre_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: None }"
-- "post_visit_show_measurements_statement: ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowMeasurements(ShowMeasurementsStatement { on: None, with_measurement: None, condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_measurements_statement
+- post_visit_show_measurements_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_retention_policies_statement-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW RETENTION POLICIES ON telegraf\")"
 ---
-- "pre_visit_statement: ShowRetentionPolicies(ShowRetentionPoliciesStatement { database: Some(OnClause(Identifier(\"telegraf\"))) })"
-- "pre_visit_show_retention_policies_statement: ShowRetentionPoliciesStatement { database: Some(OnClause(Identifier(\"telegraf\"))) }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "post_visit_show_retention_policies_statement: ShowRetentionPoliciesStatement { database: Some(OnClause(Identifier(\"telegraf\"))) }"
-- "post_visit_statement: ShowRetentionPolicies(ShowRetentionPoliciesStatement { database: Some(OnClause(Identifier(\"telegraf\"))) })"
+- pre_visit_statement
+- pre_visit_show_retention_policies_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- post_visit_show_retention_policies_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_retention_policies_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW RETENTION POLICIES\")"
 ---
-- "pre_visit_statement: ShowRetentionPolicies(ShowRetentionPoliciesStatement { database: None })"
-- "pre_visit_show_retention_policies_statement: ShowRetentionPoliciesStatement { database: None }"
-- "post_visit_show_retention_policies_statement: ShowRetentionPoliciesStatement { database: None }"
-- "post_visit_statement: ShowRetentionPolicies(ShowRetentionPoliciesStatement { database: None })"
+- pre_visit_statement
+- pre_visit_show_retention_policies_statement
+- post_visit_show_retention_policies_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_tag_keys_statement-2.snap

@@ -2,32 +2,38 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW TAG KEYS ON telegraf FROM cpu WHERE host = \\\"west\\\" LIMIT 5 OFFSET 10\")"
 ---
-- "pre_visit_statement: ShowTagKeys(ShowTagKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) })"
-- "pre_visit_show_tag_keys_statement: ShowTagKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"west\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"west\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"west\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"west\"), data_type: None })"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })"
-- "pre_visit_limit_clause: LimitClause(5)"
-- "post_visit_limit_clause: LimitClause(5)"
-- "pre_visit_offset_clause: OffsetClause(10)"
-- "post_visit_offset_clause: OffsetClause(10)"
-- "post_visit_show_tag_keys_statement: ShowTagKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) }"
-- "post_visit_statement: ShowTagKeys(ShowTagKeysStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) })"
+- pre_visit_statement
+- pre_visit_show_tag_keys_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- pre_visit_show_from_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_show_from_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- post_visit_show_tag_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_tag_keys_statement.snap

@@ -2,8 +2,8 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW TAG KEYS\")"
 ---
-- "pre_visit_statement: ShowTagKeys(ShowTagKeysStatement { database: None, from: None, condition: None, limit: None, offset: None })"
-- "pre_visit_show_tag_keys_statement: ShowTagKeysStatement { database: None, from: None, condition: None, limit: None, offset: None }"
-- "post_visit_show_tag_keys_statement: ShowTagKeysStatement { database: None, from: None, condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowTagKeys(ShowTagKeysStatement { database: None, from: None, condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_tag_keys_statement
+- post_visit_show_tag_keys_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_tag_values_statement-2.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW TAG VALUES WITH KEY =~ /host|region/\")"
 ---
-- "pre_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: EqRegex(Regex(\"host|region\")), condition: None, limit: None, offset: None })"
-- "pre_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: EqRegex(Regex(\"host|region\")), condition: None, limit: None, offset: None }"
-- "pre_visit_with_key_clause: EqRegex(Regex(\"host|region\"))"
-- "post_visit_with_key_clause: EqRegex(Regex(\"host|region\"))"
-- "post_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: EqRegex(Regex(\"host|region\")), condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: EqRegex(Regex(\"host|region\")), condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_tag_values_statement
+- pre_visit_with_key_clause
+- post_visit_with_key_clause
+- post_visit_show_tag_values_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_tag_values_statement-3.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW TAG VALUES WITH KEY IN (host, region)\")"
 ---
-- "pre_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] }), condition: None, limit: None, offset: None })"
-- "pre_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] }), condition: None, limit: None, offset: None }"
-- "pre_visit_with_key_clause: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] })"
-- "post_visit_with_key_clause: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] })"
-- "post_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] }), condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: In(OneOrMore { contents: [Identifier(\"host\"), Identifier(\"region\")] }), condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_tag_values_statement
+- pre_visit_with_key_clause
+- post_visit_with_key_clause
+- post_visit_show_tag_values_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_tag_values_statement-4.snap

@@ -2,34 +2,40 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW TAG VALUES ON telegraf FROM cpu WITH KEY = host WHERE host = \\\"west\\\" LIMIT 5 OFFSET 10\")"
 ---
-- "pre_visit_statement: ShowTagValues(ShowTagValuesStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), with_key: Eq(Identifier(\"host\")), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) })"
-- "pre_visit_show_tag_values_statement: ShowTagValuesStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), with_key: Eq(Identifier(\"host\")), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) }"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_on_clause: OnClause(Identifier(\"telegraf\"))"
-- "pre_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "pre_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_measurement_name: Name(Identifier(\"cpu\"))"
-- "post_visit_qualified_measurement_name: QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }"
-- "post_visit_show_from_clause: OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }"
-- "pre_visit_with_key_clause: Eq(Identifier(\"host\"))"
-- "post_visit_with_key_clause: Eq(Identifier(\"host\"))"
-- "pre_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })"
-- "pre_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) }"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"host\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"host\"), data_type: None })"
-- "pre_visit_conditional_expression: Expr(VarRef { name: Identifier(\"west\"), data_type: None })"
-- "pre_visit_expr: VarRef { name: Identifier(\"west\"), data_type: None }"
-- "post_visit_expr: VarRef { name: Identifier(\"west\"), data_type: None }"
-- "post_visit_conditional_expression: Expr(VarRef { name: Identifier(\"west\"), data_type: None })"
-- "post_visit_conditional_expression: Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) }"
-- "post_visit_where_clause: WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })"
-- "pre_visit_limit_clause: LimitClause(5)"
-- "post_visit_limit_clause: LimitClause(5)"
-- "pre_visit_offset_clause: OffsetClause(10)"
-- "post_visit_offset_clause: OffsetClause(10)"
-- "post_visit_show_tag_values_statement: ShowTagValuesStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), with_key: Eq(Identifier(\"host\")), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) }"
-- "post_visit_statement: ShowTagValues(ShowTagValuesStatement { database: Some(OnClause(Identifier(\"telegraf\"))), from: Some(OneOrMore { contents: [QualifiedMeasurementName { database: None, retention_policy: None, name: Name(Identifier(\"cpu\")) }] }), with_key: Eq(Identifier(\"host\")), condition: Some(WhereClause(Binary { lhs: Expr(VarRef { name: Identifier(\"host\"), data_type: None }), op: Eq, rhs: Expr(VarRef { name: Identifier(\"west\"), data_type: None }) })), limit: Some(LimitClause(5)), offset: Some(OffsetClause(10)) })"
+- pre_visit_statement
+- pre_visit_show_tag_values_statement
+- pre_visit_on_clause
+- post_visit_on_clause
+- pre_visit_show_from_clause
+- pre_visit_qualified_measurement_name
+- pre_visit_measurement_name
+- post_visit_measurement_name
+- post_visit_qualified_measurement_name
+- post_visit_show_from_clause
+- pre_visit_with_key_clause
+- post_visit_with_key_clause
+- pre_visit_where_clause
+- pre_visit_conditional_expression
+- pre_visit_conditional_binary
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- pre_visit_conditional_expression
+- pre_visit_expr
+- pre_visit_var_ref
+- post_visit_var_ref
+- post_visit_expr
+- post_visit_conditional_expression
+- post_visit_conditional_binary
+- post_visit_conditional_expression
+- post_visit_where_clause
+- pre_visit_limit_clause
+- post_visit_limit_clause
+- pre_visit_offset_clause
+- post_visit_offset_clause
+- post_visit_show_tag_values_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/snapshots/influxdb_influxql_parser__visit_mut__test__show_tag_values_statement.snap

@@ -2,10 +2,10 @@
 source: influxdb_influxql_parser/src/visit_mut.rs
 expression: "visit_statement!(\"SHOW TAG VALUES WITH KEY = host\")"
 ---
-- "pre_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: Eq(Identifier(\"host\")), condition: None, limit: None, offset: None })"
-- "pre_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: Eq(Identifier(\"host\")), condition: None, limit: None, offset: None }"
-- "pre_visit_with_key_clause: Eq(Identifier(\"host\"))"
-- "post_visit_with_key_clause: Eq(Identifier(\"host\"))"
-- "post_visit_show_tag_values_statement: ShowTagValuesStatement { database: None, from: None, with_key: Eq(Identifier(\"host\")), condition: None, limit: None, offset: None }"
-- "post_visit_statement: ShowTagValues(ShowTagValuesStatement { database: None, from: None, with_key: Eq(Identifier(\"host\")), condition: None, limit: None, offset: None })"
+- pre_visit_statement
+- pre_visit_show_tag_values_statement
+- pre_visit_with_key_clause
+- post_visit_with_key_clause
+- post_visit_show_tag_values_statement
+- post_visit_statement
 

influxdb_influxql_parser/src/visit.rs

@@ -34,6 +34,7 @@ use crate::drop::DropMeasurementStatement;
 use crate::explain::ExplainStatement;
 use crate::expression::arithmetic::Expr;
 use crate::expression::conditional::ConditionalExpression;
+use crate::expression::{Binary, Call, ConditionalBinary, VarRef};
 use crate::select::{
     Dimension, Field, FieldList, FillClause, FromMeasurementClause, GroupByClause,
     MeasurementSelection, SLimitClause, SOffsetClause, SelectStatement, TimeDimension,
@@ -541,6 +542,49 @@ pub trait Visitor: Sized {
     fn post_visit_with_key_clause(self, _n: &WithKeyClause) -> Result<Self, Self::Error> {
         Ok(self)
     }
+
+    /// Invoked before any children of a variable reference are visited.
+    fn pre_visit_var_ref(self, _n: &VarRef) -> Result<Recursion<Self>, Self::Error> {
+        Ok(Continue(self))
+    }
+
+    /// Invoked after all children of a variable reference are visited.
+    fn post_visit_var_ref(self, _n: &VarRef) -> Result<Self, Self::Error> {
+        Ok(self)
+    }
+
+    /// Invoked before any children of a function call are visited.
+    fn pre_visit_call(self, _n: &Call) -> Result<Recursion<Self>, Self::Error> {
+        Ok(Continue(self))
+    }
+
+    /// Invoked after all children of a function call are visited.
+    fn post_visit_call(self, _n: &Call) -> Result<Self, Self::Error> {
+        Ok(self)
+    }
+
+    /// Invoked before any children of a binary expression are visited.
+    fn pre_visit_expr_binary(self, _n: &Binary) -> Result<Recursion<Self>, Self::Error> {
+        Ok(Continue(self))
+    }
+
+    /// Invoked after all children of a binary expression are visited.
+    fn post_visit_expr_binary(self, _n: &Binary) -> Result<Self, Self::Error> {
+        Ok(self)
+    }
+
+    /// Invoked before any children of a conditional binary expression are visited.
+    fn pre_visit_conditional_binary(
+        self,
+        _n: &ConditionalBinary,
+    ) -> Result<Recursion<Self>, Self::Error> {
+        Ok(Continue(self))
+    }
+
+    /// Invoked after all children of a conditional binary expression are visited.
+    fn post_visit_conditional_binary(self, _n: &ConditionalBinary) -> Result<Self, Self::Error> {
+        Ok(self)
+    }
 }
 
 /// Trait for types that can be visited by [`Visitor`]
@@ -1178,10 +1222,7 @@ impl Visitable for ConditionalExpression {
 
         let visitor = match self {
             Self::Expr(expr) => expr.accept(visitor),
-            Self::Binary { lhs, rhs, .. } => {
-                let visitor = lhs.accept(visitor)?;
-                rhs.accept(visitor)
-            }
+            Self::Binary(expr) => expr.accept(visitor),
             Self::Grouped(expr) => expr.accept(visitor),
         }?;
 
@@ -1197,20 +1238,16 @@ impl Visitable for Expr {
         };
 
         let visitor = match self {
-            Self::Call { args, .. } => args.iter().try_fold(visitor, |v, e| e.accept(v)),
-            Self::Binary { lhs, op: _, rhs } => {
-                let visitor = lhs.accept(visitor)?;
-                rhs.accept(visitor)
-            }
+            Self::Call(expr) => expr.accept(visitor),
+            Self::Binary(expr) => expr.accept(visitor),
             Self::Nested(expr) => expr.accept(visitor),
+            Self::VarRef(expr) => expr.accept(visitor),
 
             // We explicitly list out each enumeration, to ensure
             // we revisit if new items are added to the Expr enumeration.
-            Self::VarRef { .. }
-            | Self::BindParameter(_)
-            | Self::Literal(_)
-            | Self::Wildcard(_)
-            | Self::Distinct(_) => Ok(visitor),
+            Self::BindParameter(_) | Self::Literal(_) | Self::Wildcard(_) | Self::Distinct(_) => {
+                Ok(visitor)
+            }
         }?;
 
         visitor.post_visit_expr(self)
@@ -1228,6 +1265,58 @@ impl Visitable for OnClause {
     }
 }
 
+impl Visitable for VarRef {
+    fn accept<V: Visitor>(&self, visitor: V) -> Result<V, V::Error> {
+        let visitor = match visitor.pre_visit_var_ref(self)? {
+            Continue(visitor) => visitor,
+            Stop(visitor) => return Ok(visitor),
+        };
+
+        visitor.post_visit_var_ref(self)
+    }
+}
+
+impl Visitable for Call {
+    fn accept<V: Visitor>(&self, visitor: V) -> Result<V, V::Error> {
+        let visitor = match visitor.pre_visit_call(self)? {
+            Continue(visitor) => visitor,
+            Stop(visitor) => return Ok(visitor),
+        };
+
+        let visitor = self.args.iter().try_fold(visitor, |v, n| n.accept(v))?;
+
+        visitor.post_visit_call(self)
+    }
+}
+
+impl Visitable for Binary {
+    fn accept<V: Visitor>(&self, visitor: V) -> Result<V, V::Error> {
+        let visitor = match visitor.pre_visit_expr_binary(self)? {
+            Continue(visitor) => visitor,
+            Stop(visitor) => return Ok(visitor),
+        };
+
+        let visitor = self.lhs.accept(visitor)?;
+        let visitor = self.rhs.accept(visitor)?;
+
+        visitor.post_visit_expr_binary(self)
+    }
+}
+
+impl Visitable for ConditionalBinary {
+    fn accept<V: Visitor>(&self, visitor: V) -> Result<V, V::Error> {
+        let visitor = match visitor.pre_visit_conditional_binary(self)? {
+            Continue(visitor) => visitor,
+            Stop(visitor) => return Ok(visitor),
+        };
+
+        let visitor = self.lhs.accept(visitor)?;
+        let visitor = self.rhs.accept(visitor)?;
+
+        visitor.post_visit_conditional_binary(self)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::Recursion::Continue;
@@ -1241,6 +1330,7 @@ mod test {
     use crate::explain::ExplainStatement;
     use crate::expression::arithmetic::Expr;
     use crate::expression::conditional::ConditionalExpression;
+    use crate::expression::{Binary, Call, ConditionalBinary, VarRef};
     use crate::select::{
         Dimension, Field, FieldList, FillClause, FromMeasurementClause, GroupByClause,
         MeasurementSelection, SLimitClause, SOffsetClause, SelectStatement, TimeDimension,
@@ -1256,7 +1346,6 @@ mod test {
     use crate::show_tag_values::{ShowTagValuesStatement, WithKeyClause};
     use crate::simple_from_clause::{DeleteFromClause, ShowFromClause};
     use crate::statement::{statement, Statement};
-    use std::fmt::Debug;
 
     struct TestVisitor(Vec<String>);
 
@@ -1265,425 +1354,79 @@ mod test {
             Self(Vec::new())
         }
 
-        fn push_pre(self, name: &str, n: impl Debug) -> Self {
+        fn push_pre(self, name: &str) -> Self {
             let mut s = self.0;
-            s.push(format!("pre_visit_{name}: {n:?}"));
+            s.push(format!("pre_visit_{name}"));
             Self(s)
         }
 
-        fn push_post(self, name: &str, n: impl Debug) -> Self {
+        fn push_post(self, name: &str) -> Self {
             let mut s = self.0;
-            s.push(format!("post_visit_{name}: {n:?}"));
+            s.push(format!("post_visit_{name}"));
             Self(s)
         }
     }
 
+    macro_rules! trace_visit {
+        ($NAME:ident, $TYPE:ty) => {
+            paste::paste! {
+                fn [<pre_visit_ $NAME>](self, _n: &$TYPE) -> Result<Recursion<Self>, Self::Error> {
+                    Ok(Continue(self.push_pre(stringify!($NAME))))
+                }
+
+                fn [<post_visit_ $NAME>](self, _n: &$TYPE) -> Result<Self, Self::Error> {
+                    Ok(self.push_post(stringify!($NAME)))
+                }
+            }
+        };
+    }
+
     impl Visitor for TestVisitor {
         type Error = ();
 
-        fn pre_visit_statement(self, n: &Statement) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("statement", n)))
-        }
-
-        fn post_visit_statement(self, n: &Statement) -> Result<Self, Self::Error> {
-            Ok(self.push_post("statement", n))
-        }
-
-        fn pre_visit_delete_statement(
-            self,
-            n: &DeleteStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("delete_statement", n)))
-        }
-
-        fn post_visit_delete_statement(self, n: &DeleteStatement) -> Result<Self, Self::Error> {
-            Ok(self.push_post("delete_statement", n))
-        }
-
-        fn pre_visit_delete_from_clause(
-            self,
-            n: &DeleteFromClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("delete_from", n)))
-        }
-
-        fn post_visit_delete_from_clause(self, n: &DeleteFromClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("delete_from", n))
-        }
-
-        fn pre_visit_measurement_name(
-            self,
-            n: &MeasurementName,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("measurement_name", n)))
-        }
-
-        fn post_visit_measurement_name(self, n: &MeasurementName) -> Result<Self, Self::Error> {
-            Ok(self.push_post("measurement_name", n))
-        }
-
-        fn pre_visit_drop_measurement_statement(
-            self,
-            n: &DropMeasurementStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("drop_measurement_statement", n)))
-        }
-
-        fn post_visit_drop_measurement_statement(
-            self,
-            n: &DropMeasurementStatement,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("drop_measurement_statement", n))
-        }
-
-        fn pre_visit_explain_statement(
-            self,
-            n: &ExplainStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("explain_statement", n)))
-        }
-
-        fn post_visit_explain_statement(self, n: &ExplainStatement) -> Result<Self, Self::Error> {
-            Ok(self.push_post("explain_statement", n))
-        }
-
-        fn pre_visit_select_statement(
-            self,
-            n: &SelectStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("select_statement", n)))
-        }
-
-        fn post_visit_select_statement(self, n: &SelectStatement) -> Result<Self, Self::Error> {
-            Ok(self.push_post("select_statement", n))
-        }
-
-        fn pre_visit_show_databases_statement(
-            self,
-            n: &ShowDatabasesStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("show_databases_statement", n)))
-        }
-
-        fn post_visit_show_databases_statement(
-            self,
-            n: &ShowDatabasesStatement,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("show_databases_statement", n))
-        }
-
-        fn pre_visit_show_measurements_statement(
-            self,
-            n: &ShowMeasurementsStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("show_measurements_statement", n)))
-        }
-
-        fn post_visit_show_measurements_statement(
-            self,
-            n: &ShowMeasurementsStatement,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("show_measurements_statement", n))
-        }
-
-        fn pre_visit_show_retention_policies_statement(
-            self,
-            n: &ShowRetentionPoliciesStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(
-                self.push_pre("show_retention_policies_statement", n),
-            ))
-        }
-
-        fn post_visit_show_retention_policies_statement(
-            self,
-            n: &ShowRetentionPoliciesStatement,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("show_retention_policies_statement", n))
-        }
-
-        fn pre_visit_show_tag_keys_statement(
-            self,
-            n: &ShowTagKeysStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("show_tag_keys_statement", n)))
-        }
-
-        fn post_visit_show_tag_keys_statement(
-            self,
-            n: &ShowTagKeysStatement,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("show_tag_keys_statement", n))
-        }
-
-        fn pre_visit_show_tag_values_statement(
-            self,
-            n: &ShowTagValuesStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("show_tag_values_statement", n)))
-        }
-
-        fn post_visit_show_tag_values_statement(
-            self,
-            n: &ShowTagValuesStatement,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("show_tag_values_statement", n))
-        }
-
-        fn pre_visit_show_field_keys_statement(
-            self,
-            n: &ShowFieldKeysStatement,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("show_field_keys_statement", n)))
-        }
-
-        fn post_visit_show_field_keys_statement(
-            self,
-            n: &ShowFieldKeysStatement,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("show_field_keys_statement", n))
-        }
-
-        fn pre_visit_conditional_expression(
-            self,
-            n: &ConditionalExpression,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("conditional_expression", n)))
-        }
-
-        fn post_visit_conditional_expression(
-            self,
-            n: &ConditionalExpression,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("conditional_expression", n))
-        }
-
-        fn pre_visit_expr(self, n: &Expr) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("expr", n)))
-        }
-
-        fn post_visit_expr(self, n: &Expr) -> Result<Self, Self::Error> {
-            Ok(self.push_post("expr", n))
-        }
-
-        fn pre_visit_select_field_list(
-            self,
-            n: &FieldList,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("select_field_list", n)))
-        }
-
-        fn post_visit_select_field_list(self, n: &FieldList) -> Result<Self, Self::Error> {
-            Ok(self.push_post("select_field_list", n))
-        }
-
-        fn pre_visit_select_field(self, n: &Field) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("select_field", n)))
-        }
-
-        fn post_visit_select_field(self, n: &Field) -> Result<Self, Self::Error> {
-            Ok(self.push_post("select_field", n))
-        }
-
-        fn pre_visit_select_from_clause(
-            self,
-            n: &FromMeasurementClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("select_from_clause", n)))
-        }
-
-        fn post_visit_select_from_clause(
-            self,
-            n: &FromMeasurementClause,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("select_from_clause", n))
-        }
-
-        fn pre_visit_select_measurement_selection(
-            self,
-            n: &MeasurementSelection,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("select_measurement_selection", n)))
-        }
-
-        fn post_visit_select_measurement_selection(
-            self,
-            n: &MeasurementSelection,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("select_measurement_selection", n))
-        }
-
-        fn pre_visit_group_by_clause(
-            self,
-            n: &GroupByClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("group_by_clause", n)))
-        }
-
-        fn post_visit_group_by_clause(self, n: &GroupByClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("group_by_clause", n))
-        }
-
-        fn pre_visit_select_dimension(self, n: &Dimension) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("select_dimension", n)))
-        }
-
-        fn post_visit_select_dimension(self, n: &Dimension) -> Result<Self, Self::Error> {
-            Ok(self.push_post("select_dimension", n))
-        }
-
-        fn pre_visit_select_time_dimension(
-            self,
-            n: &TimeDimension,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("select_time_dimension", n)))
-        }
-
-        fn post_visit_select_time_dimension(self, n: &TimeDimension) -> Result<Self, Self::Error> {
-            Ok(self.push_post("select_time_dimension", n))
-        }
-
-        fn pre_visit_where_clause(self, n: &WhereClause) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("where_clause", n)))
-        }
-
-        fn post_visit_where_clause(self, n: &WhereClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("where_clause", n))
-        }
-
-        fn pre_visit_show_from_clause(
-            self,
-            n: &ShowFromClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("show_from_clause", n)))
-        }
-
-        fn post_visit_show_from_clause(self, n: &ShowFromClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("show_from_clause", n))
-        }
-
-        fn pre_visit_qualified_measurement_name(
-            self,
-            n: &QualifiedMeasurementName,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("qualified_measurement_name", n)))
-        }
-
-        fn post_visit_qualified_measurement_name(
-            self,
-            n: &QualifiedMeasurementName,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("qualified_measurement_name", n))
-        }
-
-        fn pre_visit_fill_clause(self, n: &FillClause) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("fill_clause", n)))
-        }
-
-        fn post_visit_fill_clause(self, n: &FillClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("fill_clause", n))
-        }
-
-        fn pre_visit_order_by_clause(
-            self,
-            n: &OrderByClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("order_by_clause", n)))
-        }
-
-        fn post_visit_order_by_clause(self, n: &OrderByClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("order_by_clause", n))
-        }
-
-        fn pre_visit_limit_clause(self, n: &LimitClause) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("limit_clause", n)))
-        }
-
-        fn post_visit_limit_clause(self, n: &LimitClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("limit_clause", n))
-        }
-
-        fn pre_visit_offset_clause(self, n: &OffsetClause) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("offset_clause", n)))
-        }
-
-        fn post_visit_offset_clause(self, n: &OffsetClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("offset_clause", n))
-        }
-
-        fn pre_visit_slimit_clause(self, n: &SLimitClause) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("slimit_clause", n)))
-        }
-
-        fn post_visit_slimit_clause(self, n: &SLimitClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("slimit_clause", n))
-        }
-
-        fn pre_visit_soffset_clause(
-            self,
-            n: &SOffsetClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("soffset_clause", n)))
-        }
-
-        fn post_visit_soffset_clause(self, n: &SOffsetClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("soffset_clause", n))
-        }
-
-        fn pre_visit_timezone_clause(
-            self,
-            n: &TimeZoneClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("timezone_clause", n)))
-        }
-
-        fn post_visit_timezone_clause(self, n: &TimeZoneClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("timezone_clause", n))
-        }
-
-        fn pre_visit_extended_on_clause(
-            self,
-            n: &ExtendedOnClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("extended_on_clause", n)))
-        }
-
-        fn post_visit_extended_on_clause(self, n: &ExtendedOnClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("extended_on_clause", n))
-        }
-
-        fn pre_visit_on_clause(self, n: &OnClause) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("on_clause", n)))
-        }
-
-        fn post_visit_on_clause(self, n: &OnClause) -> Result<Self, Self::Error> {
-            Ok(self.push_pre("on_clause", n))
-        }
-
-        fn pre_visit_with_measurement_clause(
-            self,
-            n: &WithMeasurementClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("with_measurement_clause", n)))
-        }
-
-        fn post_visit_with_measurement_clause(
-            self,
-            n: &WithMeasurementClause,
-        ) -> Result<Self, Self::Error> {
-            Ok(self.push_post("with_measurement_clause", n))
-        }
-
-        fn pre_visit_with_key_clause(
-            self,
-            n: &WithKeyClause,
-        ) -> Result<Recursion<Self>, Self::Error> {
-            Ok(Continue(self.push_pre("with_key_clause", n)))
-        }
-
-        fn post_visit_with_key_clause(self, n: &WithKeyClause) -> Result<Self, Self::Error> {
-            Ok(self.push_post("with_key_clause", n))
-        }
+        trace_visit!(statement, Statement);
+        trace_visit!(delete_statement, DeleteStatement);
+        trace_visit!(delete_from_clause, DeleteFromClause);
+        trace_visit!(measurement_name, MeasurementName);
+        trace_visit!(drop_measurement_statement, DropMeasurementStatement);
+        trace_visit!(explain_statement, ExplainStatement);
+        trace_visit!(select_statement, SelectStatement);
+        trace_visit!(show_databases_statement, ShowDatabasesStatement);
+        trace_visit!(show_measurements_statement, ShowMeasurementsStatement);
+        trace_visit!(
+            show_retention_policies_statement,
+            ShowRetentionPoliciesStatement
+        );
+        trace_visit!(show_tag_keys_statement, ShowTagKeysStatement);
+        trace_visit!(show_tag_values_statement, ShowTagValuesStatement);
+        trace_visit!(show_field_keys_statement, ShowFieldKeysStatement);
+        trace_visit!(conditional_expression, ConditionalExpression);
+        trace_visit!(expr, Expr);
+        trace_visit!(select_field_list, FieldList);
+        trace_visit!(select_field, Field);
+        trace_visit!(select_from_clause, FromMeasurementClause);
+        trace_visit!(select_measurement_selection, MeasurementSelection);
+        trace_visit!(group_by_clause, GroupByClause);
+        trace_visit!(select_dimension, Dimension);
+        trace_visit!(select_time_dimension, TimeDimension);
+        trace_visit!(where_clause, WhereClause);
+        trace_visit!(show_from_clause, ShowFromClause);
+        trace_visit!(qualified_measurement_name, QualifiedMeasurementName);
+        trace_visit!(fill_clause, FillClause);
+        trace_visit!(order_by_clause, OrderByClause);
+        trace_visit!(limit_clause, LimitClause);
+        trace_visit!(offset_clause, OffsetClause);
+        trace_visit!(slimit_clause, SLimitClause);
+        trace_visit!(soffset_clause, SOffsetClause);
+        trace_visit!(timezone_clause, TimeZoneClause);
+        trace_visit!(extended_on_clause, ExtendedOnClause);
+        trace_visit!(on_clause, OnClause);
+        trace_visit!(with_measurement_clause, WithMeasurementClause);
+        trace_visit!(with_key_clause, WithKeyClause);
+        trace_visit!(var_ref, VarRef);
+        trace_visit!(call, Call);
+        trace_visit!(expr_binary, Binary);
+        trace_visit!(conditional_binary, ConditionalBinary);
     }
 
     macro_rules! visit_statement {

influxdb_influxql_parser/src/visit_mut.rs

@@ -34,6 +34,7 @@ use crate::drop::DropMeasurementStatement;
 use crate::explain::ExplainStatement;
 use crate::expression::arithmetic::Expr;
 use crate::expression::conditional::ConditionalExpression;
+use crate::expression::{Binary, Call, ConditionalBinary, VarRef};
 use crate::select::{
     Dimension, Field, FieldList, FillClause, FromMeasurementClause, GroupByClause,
     MeasurementSelection, SLimitClause, SOffsetClause, SelectStatement, TimeDimension,
@@ -569,6 +570,52 @@ pub trait VisitorMut: Sized {
     fn post_visit_with_key_clause(&mut self, _n: &mut WithKeyClause) -> Result<(), Self::Error> {
         Ok(())
     }
+
+    /// Invoked before any children of a variable reference are visited.
+    fn pre_visit_var_ref(&mut self, _n: &mut VarRef) -> Result<Recursion, Self::Error> {
+        Ok(Continue)
+    }
+
+    /// Invoked after all children of a variable reference are visited.
+    fn post_visit_var_ref(&mut self, _n: &mut VarRef) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    /// Invoked before any children of a function call are visited.
+    fn pre_visit_call(&mut self, _n: &mut Call) -> Result<Recursion, Self::Error> {
+        Ok(Continue)
+    }
+
+    /// Invoked after all children of a function call are visited.
+    fn post_visit_call(&mut self, _n: &mut Call) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    /// Invoked before any children of a binary expression are visited.
+    fn pre_visit_expr_binary(&mut self, _n: &mut Binary) -> Result<Recursion, Self::Error> {
+        Ok(Continue)
+    }
+
+    /// Invoked after all children of a binary expression are visited.
+    fn post_visit_expr_binary(&mut self, _n: &mut Binary) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    /// Invoked before any children of a conditional binary expression are visited.
+    fn pre_visit_conditional_binary(
+        &mut self,
+        _n: &mut ConditionalBinary,
+    ) -> Result<Recursion, Self::Error> {
+        Ok(Continue)
+    }
+
+    /// Invoked after all children of a conditional binary expression are visited.
+    fn post_visit_conditional_binary(
+        &mut self,
+        _n: &mut ConditionalBinary,
+    ) -> Result<(), Self::Error> {
+        Ok(())
+    }
 }
 
 /// Trait for types that can be visited by [`VisitorMut`]
@@ -1119,10 +1166,7 @@ impl VisitableMut for ConditionalExpression {
 
         match self {
             Self::Expr(expr) => expr.accept(visitor),
-            Self::Binary { lhs, rhs, .. } => {
-                lhs.accept(visitor)?;
-                rhs.accept(visitor)
-            }
+            Self::Binary(expr) => expr.accept(visitor),
             Self::Grouped(expr) => expr.accept(visitor),
         }?;
 
@@ -1137,20 +1181,14 @@ impl VisitableMut for Expr {
         };
 
         match self {
-            Self::Call { args, .. } => args.iter_mut().try_for_each(|e| e.accept(visitor))?,
-            Self::Binary { lhs, op: _, rhs } => {
-                lhs.accept(visitor)?;
-                rhs.accept(visitor)?;
-            }
+            Self::Call(expr) => expr.accept(visitor)?,
+            Self::Binary(expr) => expr.accept(visitor)?,
             Self::Nested(expr) => expr.accept(visitor)?,
+            Self::VarRef(expr) => expr.accept(visitor)?,
 
             // We explicitly list out each enumeration, to ensure
             // we revisit if new items are added to the Expr enumeration.
-            Self::VarRef { .. }
-            | Self::BindParameter(_)
-            | Self::Literal(_)
-            | Self::Wildcard(_)
-            | Self::Distinct(_) => {}
+            Self::BindParameter(_) | Self::Literal(_) | Self::Wildcard(_) | Self::Distinct(_) => {}
         };
 
         visitor.post_visit_expr(self)
@@ -1167,6 +1205,54 @@ impl VisitableMut for OnClause {
     }
 }
 
+impl VisitableMut for VarRef {
+    fn accept<V: VisitorMut>(&mut self, visitor: &mut V) -> Result<(), V::Error> {
+        if let Stop = visitor.pre_visit_var_ref(self)? {
+            return Ok(());
+        };
+
+        visitor.post_visit_var_ref(self)
+    }
+}
+
+impl VisitableMut for Call {
+    fn accept<V: VisitorMut>(&mut self, visitor: &mut V) -> Result<(), V::Error> {
+        if let Stop = visitor.pre_visit_call(self)? {
+            return Ok(());
+        }
+
+        self.args.iter_mut().try_for_each(|e| e.accept(visitor))?;
+
+        visitor.post_visit_call(self)
+    }
+}
+
+impl VisitableMut for Binary {
+    fn accept<V: VisitorMut>(&mut self, visitor: &mut V) -> Result<(), V::Error> {
+        if let Stop = visitor.pre_visit_expr_binary(self)? {
+            return Ok(());
+        };
+
+        self.lhs.accept(visitor)?;
+        self.rhs.accept(visitor)?;
+
+        visitor.post_visit_expr_binary(self)
+    }
+}
+
+impl VisitableMut for ConditionalBinary {
+    fn accept<V: VisitorMut>(&mut self, visitor: &mut V) -> Result<(), V::Error> {
+        if let Stop = visitor.pre_visit_conditional_binary(self)? {
+            return Ok(());
+        };
+
+        self.lhs.accept(visitor)?;
+        self.rhs.accept(visitor)?;
+
+        visitor.post_visit_conditional_binary(self)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::Recursion::Continue;
@@ -1180,6 +1266,7 @@ mod test {
     use crate::explain::ExplainStatement;
     use crate::expression::arithmetic::Expr;
     use crate::expression::conditional::ConditionalExpression;
+    use crate::expression::{Binary, Call, ConditionalBinary, VarRef};
     use crate::parse_statements;
     use crate::select::{
         Dimension, Field, FieldList, FillClause, FromMeasurementClause, GroupByClause,
@@ -1196,7 +1283,6 @@ mod test {
     use crate::show_tag_values::{ShowTagValuesStatement, WithKeyClause};
     use crate::simple_from_clause::{DeleteFromClause, ShowFromClause};
     use crate::statement::{statement, Statement};
-    use std::fmt::Debug;
 
     struct TestVisitor(Vec<String>);
 
@@ -1205,533 +1291,77 @@ mod test {
             Self(Vec::new())
         }
 
-        fn push_pre(&mut self, name: &str, n: impl Debug) {
-            self.0.push(format!("pre_visit_{name}: {n:?}"));
+        fn push_pre(&mut self, name: &str) {
+            self.0.push(format!("pre_visit_{name}"));
         }
 
-        fn push_post(&mut self, name: &str, n: impl Debug) {
-            self.0.push(format!("post_visit_{name}: {n:?}"));
+        fn push_post(&mut self, name: &str) {
+            self.0.push(format!("post_visit_{name}"));
         }
     }
 
+    macro_rules! trace_visit {
+        ($NAME:ident, $TYPE:ty) => {
+            paste::paste! {
+                fn [<pre_visit_ $NAME>](&mut self, _n: &mut $TYPE) -> Result<Recursion, Self::Error> {
+                    self.push_pre(stringify!($NAME));
+                    Ok(Continue)
+                }
+
+                fn [<post_visit_ $NAME>](&mut self, _n: &mut $TYPE) -> Result<(), Self::Error> {
+                    self.push_post(stringify!($NAME));
+                    Ok(())
+                }
+            }
+        };
+    }
+
     impl VisitorMut for TestVisitor {
         type Error = ();
 
-        fn pre_visit_statement(&mut self, n: &mut Statement) -> Result<Recursion, Self::Error> {
-            self.push_pre("statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_statement(&mut self, n: &mut Statement) -> Result<(), Self::Error> {
-            self.push_post("statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_delete_statement(
-            &mut self,
-            n: &mut DeleteStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("delete_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_delete_statement(
-            &mut self,
-            n: &mut DeleteStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("delete_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_delete_from_clause(
-            &mut self,
-            n: &mut DeleteFromClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("delete_from", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_delete_from_clause(
-            &mut self,
-            n: &mut DeleteFromClause,
-        ) -> Result<(), Self::Error> {
-            self.push_post("delete_from", n);
-            Ok(())
-        }
-
-        fn pre_visit_measurement_name(
-            &mut self,
-            n: &mut MeasurementName,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("measurement_name", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_measurement_name(
-            &mut self,
-            n: &mut MeasurementName,
-        ) -> Result<(), Self::Error> {
-            self.push_post("measurement_name", n);
-            Ok(())
-        }
-
-        fn pre_visit_drop_measurement_statement(
-            &mut self,
-            n: &mut DropMeasurementStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("drop_measurement_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_drop_measurement_statement(
-            &mut self,
-            n: &mut DropMeasurementStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("drop_measurement_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_explain_statement(
-            &mut self,
-            n: &mut ExplainStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("explain_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_explain_statement(
-            &mut self,
-            n: &mut ExplainStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("explain_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_select_statement(
-            &mut self,
-            n: &mut SelectStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("select_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_select_statement(
-            &mut self,
-            n: &mut SelectStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("select_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_show_databases_statement(
-            &mut self,
-            n: &mut ShowDatabasesStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("show_databases_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_show_databases_statement(
-            &mut self,
-            n: &mut ShowDatabasesStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("show_databases_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_show_measurements_statement(
-            &mut self,
-            n: &mut ShowMeasurementsStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("show_measurements_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_show_measurements_statement(
-            &mut self,
-            n: &mut ShowMeasurementsStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("show_measurements_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_show_retention_policies_statement(
-            &mut self,
-            n: &mut ShowRetentionPoliciesStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("show_retention_policies_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_show_retention_policies_statement(
-            &mut self,
-            n: &mut ShowRetentionPoliciesStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("show_retention_policies_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_show_tag_keys_statement(
-            &mut self,
-            n: &mut ShowTagKeysStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("show_tag_keys_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_show_tag_keys_statement(
-            &mut self,
-            n: &mut ShowTagKeysStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("show_tag_keys_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_show_tag_values_statement(
-            &mut self,
-            n: &mut ShowTagValuesStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("show_tag_values_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_show_tag_values_statement(
-            &mut self,
-            n: &mut ShowTagValuesStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("show_tag_values_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_show_field_keys_statement(
-            &mut self,
-            n: &mut ShowFieldKeysStatement,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("show_field_keys_statement", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_show_field_keys_statement(
-            &mut self,
-            n: &mut ShowFieldKeysStatement,
-        ) -> Result<(), Self::Error> {
-            self.push_post("show_field_keys_statement", n);
-            Ok(())
-        }
-
-        fn pre_visit_conditional_expression(
-            &mut self,
-            n: &mut ConditionalExpression,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("conditional_expression", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_conditional_expression(
-            &mut self,
-            n: &mut ConditionalExpression,
-        ) -> Result<(), Self::Error> {
-            self.push_post("conditional_expression", n);
-            Ok(())
-        }
-
-        fn pre_visit_expr(&mut self, n: &mut Expr) -> Result<Recursion, Self::Error> {
-            self.push_pre("expr", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_expr(&mut self, n: &mut Expr) -> Result<(), Self::Error> {
-            self.push_post("expr", n);
-            Ok(())
-        }
-
-        fn pre_visit_select_field_list(
-            &mut self,
-            n: &mut FieldList,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("select_field_list", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_select_field_list(&mut self, n: &mut FieldList) -> Result<(), Self::Error> {
-            self.push_post("select_field_list", n);
-            Ok(())
-        }
-
-        fn pre_visit_select_field(&mut self, n: &mut Field) -> Result<Recursion, Self::Error> {
-            self.push_pre("select_field", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_select_field(&mut self, n: &mut Field) -> Result<(), Self::Error> {
-            self.push_post("select_field", n);
-            Ok(())
-        }
-
-        fn pre_visit_select_from_clause(
-            &mut self,
-            n: &mut FromMeasurementClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("select_from_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_select_from_clause(
-            &mut self,
-            n: &mut FromMeasurementClause,
-        ) -> Result<(), Self::Error> {
-            self.push_post("select_from_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_select_measurement_selection(
-            &mut self,
-            n: &mut MeasurementSelection,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("select_measurement_selection", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_select_measurement_selection(
-            &mut self,
-            n: &mut MeasurementSelection,
-        ) -> Result<(), Self::Error> {
-            self.push_post("select_measurement_selection", n);
-            Ok(())
-        }
-
-        fn pre_visit_group_by_clause(
-            &mut self,
-            n: &mut GroupByClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("group_by_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_group_by_clause(&mut self, n: &mut GroupByClause) -> Result<(), Self::Error> {
-            self.push_post("group_by_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_select_dimension(
-            &mut self,
-            n: &mut Dimension,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("select_dimension", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_select_dimension(&mut self, n: &mut Dimension) -> Result<(), Self::Error> {
-            self.push_post("select_dimension", n);
-            Ok(())
-        }
-
-        fn pre_visit_select_time_dimension(
-            &mut self,
-            n: &mut TimeDimension,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("select_time_dimension", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_select_time_dimension(
-            &mut self,
-            n: &mut TimeDimension,
-        ) -> Result<(), Self::Error> {
-            self.push_post("select_time_dimension", n);
-            Ok(())
-        }
-
-        fn pre_visit_where_clause(
-            &mut self,
-            n: &mut WhereClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("where_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_where_clause(&mut self, n: &mut WhereClause) -> Result<(), Self::Error> {
-            self.push_post("where_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_show_from_clause(
-            &mut self,
-            n: &mut ShowFromClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("show_from_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_show_from_clause(
-            &mut self,
-            n: &mut ShowFromClause,
-        ) -> Result<(), Self::Error> {
-            self.push_post("show_from_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_qualified_measurement_name(
-            &mut self,
-            n: &mut QualifiedMeasurementName,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("qualified_measurement_name", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_qualified_measurement_name(
-            &mut self,
-            n: &mut QualifiedMeasurementName,
-        ) -> Result<(), Self::Error> {
-            self.push_post("qualified_measurement_name", n);
-            Ok(())
-        }
-
-        fn pre_visit_fill_clause(&mut self, n: &mut FillClause) -> Result<Recursion, Self::Error> {
-            self.push_pre("fill_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_fill_clause(&mut self, n: &mut FillClause) -> Result<(), Self::Error> {
-            self.push_post("fill_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_order_by_clause(
-            &mut self,
-            n: &mut OrderByClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("order_by_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_order_by_clause(&mut self, n: &mut OrderByClause) -> Result<(), Self::Error> {
-            self.push_post("order_by_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_limit_clause(
-            &mut self,
-            n: &mut LimitClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("limit_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_limit_clause(&mut self, n: &mut LimitClause) -> Result<(), Self::Error> {
-            self.push_post("limit_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_offset_clause(
-            &mut self,
-            n: &mut OffsetClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("offset_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_offset_clause(&mut self, n: &mut OffsetClause) -> Result<(), Self::Error> {
-            self.push_post("offset_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_slimit_clause(
-            &mut self,
-            n: &mut SLimitClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("slimit_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_slimit_clause(&mut self, n: &mut SLimitClause) -> Result<(), Self::Error> {
-            self.push_post("slimit_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_soffset_clause(
-            &mut self,
-            n: &mut SOffsetClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("soffset_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_soffset_clause(&mut self, n: &mut SOffsetClause) -> Result<(), Self::Error> {
-            self.push_post("soffset_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_timezone_clause(
-            &mut self,
-            n: &mut TimeZoneClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("timezone_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_timezone_clause(
-            &mut self,
-            n: &mut TimeZoneClause,
-        ) -> Result<(), Self::Error> {
-            self.push_post("timezone_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_extended_on_clause(
-            &mut self,
-            n: &mut ExtendedOnClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("extended_on_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_extended_on_clause(
-            &mut self,
-            n: &mut ExtendedOnClause,
-        ) -> Result<(), Self::Error> {
-            self.push_post("extended_on_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_on_clause(&mut self, n: &mut OnClause) -> Result<Recursion, Self::Error> {
-            self.push_pre("on_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_on_clause(&mut self, n: &mut OnClause) -> Result<(), Self::Error> {
-            self.push_pre("on_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_with_measurement_clause(
-            &mut self,
-            n: &mut WithMeasurementClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("with_measurement_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_with_measurement_clause(
-            &mut self,
-            n: &mut WithMeasurementClause,
-        ) -> Result<(), Self::Error> {
-            self.push_post("with_measurement_clause", n);
-            Ok(())
-        }
-
-        fn pre_visit_with_key_clause(
-            &mut self,
-            n: &mut WithKeyClause,
-        ) -> Result<Recursion, Self::Error> {
-            self.push_pre("with_key_clause", n);
-            Ok(Continue)
-        }
-
-        fn post_visit_with_key_clause(&mut self, n: &mut WithKeyClause) -> Result<(), Self::Error> {
-            self.push_post("with_key_clause", n);
-            Ok(())
-        }
+        trace_visit!(statement, Statement);
+        trace_visit!(delete_statement, DeleteStatement);
+        trace_visit!(delete_from_clause, DeleteFromClause);
+        trace_visit!(measurement_name, MeasurementName);
+        trace_visit!(drop_measurement_statement, DropMeasurementStatement);
+        trace_visit!(explain_statement, ExplainStatement);
+        trace_visit!(select_statement, SelectStatement);
+        trace_visit!(show_databases_statement, ShowDatabasesStatement);
+        trace_visit!(show_measurements_statement, ShowMeasurementsStatement);
+        trace_visit!(
+            show_retention_policies_statement,
+            ShowRetentionPoliciesStatement
+        );
+        trace_visit!(show_tag_keys_statement, ShowTagKeysStatement);
+        trace_visit!(show_tag_values_statement, ShowTagValuesStatement);
+        trace_visit!(show_field_keys_statement, ShowFieldKeysStatement);
+        trace_visit!(conditional_expression, ConditionalExpression);
+        trace_visit!(expr, Expr);
+        trace_visit!(select_field_list, FieldList);
+        trace_visit!(select_field, Field);
+        trace_visit!(select_from_clause, FromMeasurementClause);
+        trace_visit!(select_measurement_selection, MeasurementSelection);
+        trace_visit!(group_by_clause, GroupByClause);
+        trace_visit!(select_dimension, Dimension);
+        trace_visit!(select_time_dimension, TimeDimension);
+        trace_visit!(where_clause, WhereClause);
+        trace_visit!(show_from_clause, ShowFromClause);
+        trace_visit!(qualified_measurement_name, QualifiedMeasurementName);
+        trace_visit!(fill_clause, FillClause);
+        trace_visit!(order_by_clause, OrderByClause);
+        trace_visit!(limit_clause, LimitClause);
+        trace_visit!(offset_clause, OffsetClause);
+        trace_visit!(slimit_clause, SLimitClause);
+        trace_visit!(soffset_clause, SOffsetClause);
+        trace_visit!(timezone_clause, TimeZoneClause);
+        trace_visit!(extended_on_clause, ExtendedOnClause);
+        trace_visit!(on_clause, OnClause);
+        trace_visit!(with_measurement_clause, WithMeasurementClause);
+        trace_visit!(with_key_clause, WithKeyClause);
+        trace_visit!(var_ref, VarRef);
+        trace_visit!(call, Call);
+        trace_visit!(expr_binary, Binary);
+        trace_visit!(conditional_binary, ConditionalBinary);
     }
 
     macro_rules! visit_statement {

iox_query_influxql/src/plan/expr_type_evaluator.rs

@@ -3,7 +3,7 @@ use crate::plan::field_mapper::map_type;
 use crate::plan::SchemaProvider;
 use datafusion::common::{DataFusionError, Result};
 use influxdb_influxql_parser::common::{MeasurementName, QualifiedMeasurementName};
-use influxdb_influxql_parser::expression::{Expr, VarRefDataType};
+use influxdb_influxql_parser::expression::{Call, Expr, VarRef, VarRefDataType};
 use influxdb_influxql_parser::literal::Literal;
 use influxdb_influxql_parser::select::{Dimension, FromMeasurementClause, MeasurementSelection};
 use itertools::Itertools;
@@ -31,8 +31,8 @@ impl<'a> TypeEvaluator<'a> {
 
     fn eval_type(&self, expr: &Expr) -> Result<Option<VarRefDataType>> {
         Ok(match expr {
-            Expr::VarRef { name, data_type } => self.eval_var_ref(name.as_str(), data_type)?,
-            Expr::Call { name, args } => self.eval_call(name.as_str(), args)?,
+            Expr::VarRef(v) => self.eval_var_ref(v)?,
+            Expr::Call(v) => self.eval_call(v)?,
             // NOTE: This is a deviation from https://github.com/influxdata/influxql/blob/1ba470371ec093d57a726b143fe6ccbacf1b452b/ast.go#L4635,
             // as we'll let DataFusion determine the column type and if the types are compatible.
             Expr::Binary { .. } => None,
@@ -54,12 +54,8 @@ impl<'a> TypeEvaluator<'a> {
 
     /// Returns the type for the specified [`Expr`].
     /// This function assumes that the expression has already been reduced.
-    fn eval_var_ref(
-        &self,
-        name: &str,
-        data_type: &Option<VarRefDataType>,
-    ) -> Result<Option<VarRefDataType>> {
-        Ok(match data_type {
+    fn eval_var_ref(&self, expr: &VarRef) -> Result<Option<VarRefDataType>> {
+        Ok(match expr.data_type {
             Some(dt)
                 if matches!(
                     dt,
@@ -70,7 +66,7 @@ impl<'a> TypeEvaluator<'a> {
                         | VarRefDataType::Boolean
                 ) =>
             {
-                Some(*dt)
+                Some(dt)
             }
             _ => {
                 let mut data_type: Option<VarRefDataType> = None;
@@ -79,7 +75,10 @@ impl<'a> TypeEvaluator<'a> {
                         MeasurementSelection::Name(QualifiedMeasurementName {
                             name: MeasurementName::Name(ident),
                             ..
-                        }) => match (data_type, map_type(self.s, ident.as_str(), name)?) {
+                        }) => match (
+                            data_type,
+                            map_type(self.s, ident.as_str(), expr.name.as_str())?,
+                        ) {
                             (Some(existing), Some(res)) => {
                                 if res < existing {
                                     data_type = Some(res)
@@ -90,7 +89,7 @@ impl<'a> TypeEvaluator<'a> {
                         },
                         MeasurementSelection::Subquery(select) => {
                             // find the field by name
-                            if let Some(field) = field_by_name(select, name) {
+                            if let Some(field) = field_by_name(select, expr.name.as_str()) {
                                 match (data_type, evaluate_type(self.s, &field.expr, &select.from)?)
                                 {
                                     (Some(existing), Some(res)) => {
@@ -106,7 +105,7 @@ impl<'a> TypeEvaluator<'a> {
                             if data_type.is_none() {
                                 if let Some(group_by) = &select.group_by {
                                     if group_by.iter().any(|dim| {
-                                        matches!(dim, Dimension::Tag(ident) if ident.as_str() == name)
+                                        matches!(dim, Dimension::Tag(ident) if ident.as_str() == expr.name.as_str())
                                     }) {
                                         data_type = Some(VarRefDataType::Tag);
                                     }
@@ -130,11 +129,15 @@ impl<'a> TypeEvaluator<'a> {
     ///
     /// Derived from [Go implementation](https://github.com/influxdata/influxql/blob/1ba470371ec093d57a726b143fe6ccbacf1b452b/ast.go#L4693)
     /// and [here](https://github.com/influxdata/influxdb/blob/37088e8f5330bec0f08a376b2cb945d02a296f4e/influxql/query/functions.go#L50).
-    fn eval_call(&self, name: &str, args: &[Expr]) -> Result<Option<VarRefDataType>> {
+    fn eval_call(&self, call: &Call) -> Result<Option<VarRefDataType>> {
         // Evaluate the data types of the arguments
-        let arg_types: Vec<_> = args.iter().map(|expr| self.eval_type(expr)).try_collect()?;
+        let arg_types: Vec<_> = call
+            .args
+            .iter()
+            .map(|expr| self.eval_type(expr))
+            .try_collect()?;
 
-        Ok(match name.to_ascii_lowercase().as_str() {
+        Ok(match call.name.as_str() {
             "mean" => Some(VarRefDataType::Float),
             "count" => Some(VarRefDataType::Integer),
             "min" | "max" | "sum" | "first" | "last" => match arg_types.first() {

iox_query_influxql/src/plan/field.rs

@@ -1,4 +1,4 @@
-use influxdb_influxql_parser::expression::Expr;
+use influxdb_influxql_parser::expression::{Call, Expr, VarRef};
 use influxdb_influxql_parser::select::{Field, SelectStatement};
 use influxdb_influxql_parser::visit::{Recursion, Visitable, Visitor};
 use std::ops::Deref;
@@ -18,11 +18,11 @@ pub(crate) fn field_name(f: &Field) -> String {
     let mut expr = &f.expr;
     loop {
         expr = match expr {
-            Expr::Call { name, .. } => return name.clone(),
+            Expr::Call(Call { name, .. }) => return name.clone(),
             Expr::Nested(nested) => nested,
             Expr::Binary { .. } => return binary_expr_name(&f.expr),
             Expr::Distinct(_) => return "distinct".to_string(),
-            Expr::VarRef { name, .. } => return name.deref().into(),
+            Expr::VarRef(VarRef { name, .. }) => return name.deref().into(),
             Expr::Wildcard(_) | Expr::BindParameter(_) | Expr::Literal(_) => return "".to_string(),
         };
     }
@@ -45,10 +45,10 @@ pub(crate) fn field_by_name(select: &SelectStatement, name: &str) -> Option<Fiel
         .iter()
         .find(|f| {
             field_name(f) == name || match &f.expr {
-                Expr::Call { name: func_name, args } if (func_name.eq_ignore_ascii_case("top")
+                Expr::Call(Call{ name: func_name, args }) if (func_name.eq_ignore_ascii_case("top")
                     || func_name.eq_ignore_ascii_case("bottom"))
                     && args.len() > 2 =>
-                    args[1..].iter().any(|f| matches!(f, Expr::VarRef { name: field_name, .. } if field_name.as_str() == name)),
+                    args[1..].iter().any(|f| matches!(f, Expr::VarRef(VarRef{ name: field_name, .. }) if field_name.as_str() == name)),
                 _ => false,
             }
         })
@@ -60,13 +60,13 @@ struct BinaryExprNameVisitor<'a>(&'a mut Vec<String>);
 impl<'a> Visitor for BinaryExprNameVisitor<'a> {
     type Error = ();
 
-    fn pre_visit_expr(self, n: &Expr) -> Result<Recursion<Self>, Self::Error> {
-        match n {
-            Expr::Call { name, .. } => self.0.push(name.clone()),
-            Expr::VarRef { name, .. } => self.0.push(name.to_string()),
-            _ => {}
-        };
+    fn pre_visit_var_ref(self, n: &VarRef) -> Result<Recursion<Self>, Self::Error> {
+        self.0.push(n.name.to_string());
+        Ok(Recursion::Continue(self))
+    }
 
+    fn pre_visit_call(self, n: &Call) -> Result<Recursion<Self>, Self::Error> {
+        self.0.push(n.name.clone());
         Ok(Recursion::Continue(self))
     }
 }

iox_query_influxql/src/plan/planner.rs

@@ -29,7 +29,8 @@ use generated_types::influxdata::iox::querier::v1::InfluxQlMetadata;
 use influxdb_influxql_parser::explain::{ExplainOption, ExplainStatement};
 use influxdb_influxql_parser::expression::walk::walk_expr;
 use influxdb_influxql_parser::expression::{
-    BinaryOperator, ConditionalExpression, ConditionalOperator, VarRefDataType,
+    Binary, Call, ConditionalBinary, ConditionalExpression, ConditionalOperator, VarRef,
+    VarRefDataType,
 };
 use influxdb_influxql_parser::select::{
     FillClause, GroupByClause, SLimitClause, SOffsetClause, TimeZoneClause,
@@ -255,10 +256,10 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
         // The `time` column is always present in the result set
         let mut fields = if find_time_column_index(&select.fields).is_none() {
             vec![Field {
-                expr: IQLExpr::VarRef {
+                expr: IQLExpr::VarRef(VarRef {
                     name: "time".into(),
                     data_type: Some(VarRefDataType::Timestamp),
-                },
+                }),
                 alias: Some("time".into()),
             }]
         } else {
@@ -297,10 +298,10 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
                         .filter_map(|col| match tag_columns.remove(*col) {
                             true => None,
                             false => Some(Field {
-                                expr: IQLExpr::VarRef {
+                                expr: IQLExpr::VarRef(VarRef {
                                     name: (*col).into(),
                                     data_type: Some(VarRefDataType::Tag),
-                                },
+                                }),
                                 alias: Some((*col).into()),
                             }),
                         }),
@@ -390,7 +391,7 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
             // looking for a reference to one column that
             // is a field
             walk_expr(&f.expr, &mut |e| match e {
-                IQLExpr::VarRef { name, .. } => {
+                IQLExpr::VarRef(VarRef { name, .. }) => {
                     match schemas.iox_schema.field_by_name(name.deref().as_str()) {
                         Some((InfluxColumnType::Field(_), _)) => ControlFlow::Break(()),
                         _ => ControlFlow::Continue(()),
@@ -403,6 +404,16 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
             return LogicalPlanBuilder::empty(false).build();
         }
 
+        // next we extract the functions which require windowing, such as difference or integral
+        fields.iter().any(|f| {
+            walk_expr(&f.expr, &mut |e| match e {
+                IQLExpr::Call(Call { name, .. }) if name == "difference" => ControlFlow::Break(()),
+                _ => ControlFlow::Continue(()),
+            });
+
+            false
+        });
+
         let plan = self.plan_where_clause(ctx, &select.condition, input, &schemas)?;
 
         // Transform InfluxQL AST field expressions to a list of DataFusion expressions.
@@ -665,8 +676,8 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
     ) -> Result<Expr> {
         match iql {
             ConditionalExpression::Expr(expr) => self.expr_to_df_expr(ctx, expr, schemas),
-            ConditionalExpression::Binary { lhs, op, rhs } => {
-                self.binary_conditional_to_df_expr(ctx, lhs, *op, rhs, schemas)
+            ConditionalExpression::Binary(expr) => {
+                self.binary_conditional_to_df_expr(ctx, expr, schemas)
             }
             ConditionalExpression::Grouped(e) => self.conditional_to_df_expr(ctx, e, schemas),
         }
@@ -676,12 +687,12 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
     fn binary_conditional_to_df_expr(
         &self,
         ctx: &Context<'_>,
-        lhs: &ConditionalExpression,
-        op: ConditionalOperator,
-        rhs: &ConditionalExpression,
+        expr: &ConditionalBinary,
         schemas: &Schemas,
     ) -> Result<Expr> {
-        let op = conditional_op_to_operator(op)?;
+        let ConditionalBinary { lhs, op, rhs } = expr;
+
+        let op = conditional_op_to_operator(*op)?;
 
         let (lhs_time, rhs_time) = (is_time_field(lhs), is_time_field(rhs));
         let (lhs, rhs) = if matches!(
@@ -725,10 +736,10 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
             IQLExpr::Wildcard(_) => Err(DataFusionError::Internal(
                 "unexpected wildcard in projection".into(),
             )),
-            IQLExpr::VarRef {
+            IQLExpr::VarRef(VarRef {
                 name,
                 data_type: opt_dst_type,
-            } => {
+            }) => {
                 let name = normalize_identifier(name);
                 Ok(
                     if ctx.scope == ExprScope::Where && name.eq_ignore_ascii_case("time") {
@@ -818,10 +829,8 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
                 },
             },
             IQLExpr::Distinct(_) => Err(DataFusionError::NotImplemented("DISTINCT".into())),
-            IQLExpr::Call { name, args } => self.call_to_df_expr(ctx, name, args, schemas),
-            IQLExpr::Binary { lhs, op, rhs } => {
-                self.arithmetic_expr_to_df_expr(ctx, lhs, *op, rhs, schemas)
-            }
+            IQLExpr::Call(call) => self.call_to_df_expr(ctx, call, schemas),
+            IQLExpr::Binary(expr) => self.arithmetic_expr_to_df_expr(ctx, expr, schemas),
             IQLExpr::Nested(e) => self.expr_to_df_expr(ctx, e, schemas),
         }
     }
@@ -842,36 +851,30 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
     /// > * <https://github.com/influxdata/influxdb_iox/issues/6939>
     ///
     /// [docs]: https://docs.influxdata.com/influxdb/v1.8/query_language/functions/
-    fn call_to_df_expr(
-        &self,
-        ctx: &Context<'_>,
-        name: &str,
-        args: &[IQLExpr],
-        schemas: &Schemas,
-    ) -> Result<Expr> {
-        if is_scalar_math_function(name) {
-            return self.scalar_math_func_to_df_expr(ctx, name, args, schemas);
+    fn call_to_df_expr(&self, ctx: &Context<'_>, call: &Call, schemas: &Schemas) -> Result<Expr> {
+        if is_scalar_math_function(call.name.as_str()) {
+            return self.scalar_math_func_to_df_expr(ctx, call, schemas);
         }
 
         match ctx.scope {
             ExprScope::Where => {
-                if name.eq_ignore_ascii_case("now") {
+                if call.name.eq_ignore_ascii_case("now") {
                     Err(DataFusionError::NotImplemented("now".into()))
                 } else {
+                    let name = &call.name;
                     Err(DataFusionError::External(
                         format!("invalid function call in condition: {name}").into(),
                     ))
                 }
             }
-            ExprScope::Projection => self.function_to_df_expr(ctx, name, args, schemas),
+            ExprScope::Projection => self.function_to_df_expr(ctx, call, schemas),
         }
     }
 
     fn function_to_df_expr(
         &self,
         ctx: &Context<'_>,
-        name: &str,
-        args: &[IQLExpr],
+        call: &Call,
         schemas: &Schemas,
     ) -> Result<Expr> {
         fn check_arg_count(name: &str, args: &[IQLExpr], count: usize) -> Result<()> {
@@ -885,7 +888,9 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
             }
         }
 
-        match name {
+        let Call { name, args } = call;
+
+        match name.as_str() {
             "count" => {
                 // TODO(sgc): Handle `COUNT DISTINCT` variants
                 let distinct = false;
@@ -923,16 +928,16 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
     fn scalar_math_func_to_df_expr(
         &self,
         ctx: &Context<'_>,
-        name: &str,
-        args: &[IQLExpr],
+        call: &Call,
         schemas: &Schemas,
     ) -> Result<Expr> {
-        let args = args
+        let args = call
+            .args
             .iter()
             .map(|e| self.expr_to_df_expr(ctx, e, schemas))
             .collect::<Result<Vec<Expr>>>()?;
 
-        match BuiltinScalarFunction::from_str(name)? {
+        match BuiltinScalarFunction::from_str(call.name.as_str())? {
             BuiltinScalarFunction::Log => {
                 if args.len() != 2 {
                     Err(DataFusionError::Plan(
@@ -953,15 +958,13 @@ impl<'a> InfluxQLToLogicalPlan<'a> {
     fn arithmetic_expr_to_df_expr(
         &self,
         ctx: &Context<'_>,
-        lhs: &IQLExpr,
-        op: BinaryOperator,
-        rhs: &IQLExpr,
+        expr: &Binary,
         schemas: &Schemas,
     ) -> Result<Expr> {
         Ok(binary_expr(
-            self.expr_to_df_expr(ctx, lhs, schemas)?,
-            binary_operator_to_df_operator(op),
-            self.expr_to_df_expr(ctx, rhs, schemas)?,
+            self.expr_to_df_expr(ctx, &expr.lhs, schemas)?,
+            binary_operator_to_df_operator(expr.op),
+            self.expr_to_df_expr(ctx, &expr.rhs, schemas)?,
         ))
     }
 
@@ -1174,7 +1177,7 @@ fn has_aggregate_exprs(fields: &FieldList) -> bool {
 /// call to an aggregate function.
 fn is_aggregate_field(f: &Field) -> bool {
     walk_expr(&f.expr, &mut |e| match e {
-        IQLExpr::Call { name, .. } if is_aggregate_function(name) => ControlFlow::Break(()),
+        IQLExpr::Call(Call { name, .. }) if is_aggregate_function(name) => ControlFlow::Break(()),
         _ => ControlFlow::Continue(()),
     })
     .is_break()
@@ -1184,10 +1187,10 @@ fn is_aggregate_field(f: &Field) -> bool {
 /// is a tag or is [`None`], which is unknown.
 fn find_tag_and_unknown_columns(fields: &FieldList) -> impl Iterator<Item = &str> {
     fields.iter().filter_map(|f| match &f.expr {
-        IQLExpr::VarRef {
+        IQLExpr::VarRef(VarRef {
             name,
             data_type: Some(VarRefDataType::Tag) | None,
-        } => Some(name.deref().as_str()),
+        }) => Some(name.deref().as_str()),
         _ => None,
     })
 }
@@ -1294,7 +1297,7 @@ pub(crate) fn find_time_column_index(fields: &[Field]) -> Option<usize> {
     fields
         .iter()
         .find_position(
-            |f| matches!(&f.expr, IQLExpr::VarRef { name, .. } if name.deref() == "time"),
+            |f| matches!(&f.expr, IQLExpr::VarRef(VarRef { name, .. }) if name.deref() == "time"),
         )
         .map(|(i, _)| i)
 }
@@ -1370,7 +1373,7 @@ fn is_aggregate_function(name: &str) -> bool {
 /// [go]: https://github.com/influxdata/influxql/blob/1ba470371ec093d57a726b143fe6ccbacf1b452b/ast.go#L5751-L5753
 fn is_time_field(cond: &ConditionalExpression) -> bool {
     if let ConditionalExpression::Expr(expr) = cond {
-        if let IQLExpr::VarRef { ref name, .. } = **expr {
+        if let IQLExpr::VarRef(VarRef { ref name, .. }) = **expr {
             name.eq_ignore_ascii_case("time")
         } else {
             false

iox_query_influxql/src/plan/planner/select.rs

@@ -5,7 +5,7 @@ use datafusion::logical_expr::{Expr, LogicalPlan, LogicalPlanBuilder};
 use datafusion_util::AsExpr;
 use generated_types::influxdata::iox::querier::v1::influx_ql_metadata::TagKeyColumn;
 use influxdb_influxql_parser::common::OrderByClause;
-use influxdb_influxql_parser::expression::{Expr as IQLExpr, VarRefDataType};
+use influxdb_influxql_parser::expression::{Expr as IQLExpr, VarRef, VarRefDataType};
 use influxdb_influxql_parser::select::{Field, SelectStatement};
 use schema::INFLUXQL_MEASUREMENT_COLUMN_NAME;
 use std::collections::HashMap;
@@ -43,10 +43,10 @@ pub(super) fn make_tag_key_column_meta(
         .iter()
         .enumerate()
         .filter_map(|(index, f)| match &f.expr {
-            IQLExpr::VarRef {
+            IQLExpr::VarRef(VarRef {
                 name,
                 data_type: Some(VarRefDataType::Tag) | None,
-            } => Some((name.deref().as_str(), index + START_INDEX)),
+            }) => Some((name.deref().as_str(), index + START_INDEX)),
             _ => None,
         })
         .collect::<HashMap<_, _>>();

iox_query_influxql/src/plan/planner_time_range_expression.rs

@@ -3,7 +3,7 @@ use crate::plan::util::binary_operator_to_df_operator;
 use arrow::temporal_conversions::MILLISECONDS_IN_DAY;
 use datafusion::common::{DataFusionError, Result, ScalarValue};
 use datafusion::logical_expr::{binary_expr, lit, now, BinaryExpr, Expr as DFExpr, Operator};
-use influxdb_influxql_parser::expression::BinaryOperator;
+use influxdb_influxql_parser::expression::{Binary, BinaryOperator};
 use influxdb_influxql_parser::{expression::Expr, literal::Literal};
 
 type ExprResult = Result<DFExpr>;
@@ -128,12 +128,11 @@ fn map_expr_err(expr: &Expr) -> impl Fn(DataFusionError) -> DataFusionError + '_
 
 fn reduce_expr(expr: &Expr, tz: Option<chrono_tz::Tz>) -> ExprResult {
     match expr {
-        Expr::Binary { lhs, op, rhs } => reduce_binary_expr(lhs, *op, rhs, tz).map_err(map_expr_err(expr)),
-
-        Expr::Call { name, .. } => {
-            if !name.eq_ignore_ascii_case("now") {
+        Expr::Binary(v) => reduce_binary_expr(v, tz).map_err(map_expr_err(expr)),
+        Expr::Call (v) => {
+            if !v.name.eq_ignore_ascii_case("now") {
                 return Err(DataFusionError::Plan(
-                    format!("invalid function call '{name}'"),
+                    format!("invalid function call '{}'", v.name),
                 ));
             }
             Ok(now())
@@ -159,14 +158,10 @@ fn reduce_expr(expr: &Expr, tz: Option<chrono_tz::Tz>) -> ExprResult {
     }
 }
 
-fn reduce_binary_expr(
-    lhs: &Expr,
-    op: BinaryOperator,
-    rhs: &Expr,
-    tz: Option<chrono_tz::Tz>,
-) -> ExprResult {
-    let lhs = reduce_expr(lhs, tz)?;
-    let rhs = reduce_expr(rhs, tz)?;
+fn reduce_binary_expr(expr: &Binary, tz: Option<chrono_tz::Tz>) -> ExprResult {
+    let lhs = reduce_expr(&expr.lhs, tz)?;
+    let op = expr.op;
+    let rhs = reduce_expr(&expr.rhs, tz)?;
 
     match lhs {
         DFExpr::Literal(ScalarValue::IntervalMonthDayNano(Some(v))) => {

iox_query_influxql/src/plan/rewriter.rs

@@ -7,7 +7,7 @@ use crate::plan::{util, SchemaProvider};
 use datafusion::common::{DataFusionError, Result};
 use influxdb_influxql_parser::common::{MeasurementName, QualifiedMeasurementName};
 use influxdb_influxql_parser::expression::walk::{walk_expr, walk_expr_mut};
-use influxdb_influxql_parser::expression::{Expr, VarRefDataType, WildcardType};
+use influxdb_influxql_parser::expression::{Call, Expr, VarRef, VarRefDataType, WildcardType};
 use influxdb_influxql_parser::identifier::Identifier;
 use influxdb_influxql_parser::literal::Literal;
 use influxdb_influxql_parser::select::{
@@ -199,14 +199,14 @@ fn rewrite_field_list(s: &dyn SchemaProvider, stmt: &mut SelectStatement) -> Res
     // hasn't been specified.
     if let ControlFlow::Break(e) = stmt.fields.iter_mut().try_for_each(|f| {
         walk_expr_mut::<DataFusionError>(&mut f.expr, &mut |e| {
-            if matches!(e, Expr::VarRef { .. }) {
+            if matches!(e, Expr::VarRef(_)) {
                 let new_type = match evaluate_type(s, e.borrow(), &stmt.from) {
                     Err(e) => ControlFlow::Break(e)?,
                     Ok(v) => v,
                 };
 
-                if let Expr::VarRef { data_type, .. } = e {
-                    *data_type = new_type;
+                if let Expr::VarRef(v) = e {
+                    v.data_type = new_type;
                 }
             }
             ControlFlow::Continue(())
@@ -234,23 +234,17 @@ fn rewrite_field_list(s: &dyn SchemaProvider, stmt: &mut SelectStatement) -> Res
         }
     }
 
-    #[derive(PartialEq, PartialOrd, Eq, Ord)]
-    struct VarRef {
-        name: String,
-        data_type: VarRefDataType,
-    }
-
     let fields = if !field_set.is_empty() {
         let fields_iter = field_set.iter().map(|(k, v)| VarRef {
-            name: k.clone(),
-            data_type: *v,
+            name: k.clone().into(),
+            data_type: Some(*v),
         });
 
         if !has_group_by_wildcard {
             fields_iter
                 .chain(tag_set.iter().map(|tag| VarRef {
-                    name: tag.clone(),
-                    data_type: VarRefDataType::Tag,
+                    name: tag.clone().into(),
+                    data_type: Some(VarRefDataType::Tag),
                 }))
                 .sorted()
                 .collect::<Vec<_>>()
@@ -267,10 +261,7 @@ fn rewrite_field_list(s: &dyn SchemaProvider, stmt: &mut SelectStatement) -> Res
         for f in stmt.fields.iter() {
             let add_field = |f: &VarRef| {
                 new_fields.push(Field {
-                    expr: Expr::VarRef {
-                        name: f.name.clone().into(),
-                        data_type: Some(f.data_type),
-                    },
+                    expr: Expr::VarRef(f.clone()),
                     alias: None,
                 })
             };
@@ -279,8 +270,12 @@ fn rewrite_field_list(s: &dyn SchemaProvider, stmt: &mut SelectStatement) -> Res
                 Expr::Wildcard(wct) => {
                     let filter: fn(&&VarRef) -> bool = match wct {
                         None => |_| true,
-                        Some(WildcardType::Tag) => |v| v.data_type.is_tag_type(),
-                        Some(WildcardType::Field) => |v| v.data_type.is_field_type(),
+                        Some(WildcardType::Tag) => {
+                            |v| v.data_type.map_or(false, |dt| dt.is_tag_type())
+                        }
+                        Some(WildcardType::Field) => {
+                            |v| v.data_type.map_or(false, |dt| dt.is_field_type())
+                        }
                     };
 
                     fields.iter().filter(filter).for_each(add_field);
@@ -294,53 +289,52 @@ fn rewrite_field_list(s: &dyn SchemaProvider, stmt: &mut SelectStatement) -> Res
                         .for_each(add_field);
                 }
 
-                Expr::Call { name, args } => {
+                Expr::Call(Call { name, args }) => {
                     let mut name = name;
                     let mut args = args;
 
                     // Search for the call with a wildcard by continuously descending until
                     // we no longer have a call.
-                    while let Some(Expr::Call {
+                    while let Some(Expr::Call(Call {
                         name: inner_name,
                         args: inner_args,
-                    }) = args.first()
+                    })) = args.first()
                     {
                         name = inner_name;
                         args = inner_args;
                     }
 
                     let mut supported_types = HashSet::from([
-                        VarRefDataType::Float,
-                        VarRefDataType::Integer,
-                        VarRefDataType::Unsigned,
+                        Some(VarRefDataType::Float),
+                        Some(VarRefDataType::Integer),
+                        Some(VarRefDataType::Unsigned),
                     ]);
 
                     // Add additional types for certain functions.
                     match name.to_lowercase().as_str() {
                         "count" | "first" | "last" | "distinct" | "elapsed" | "mode" | "sample" => {
-                            supported_types
-                                .extend([VarRefDataType::String, VarRefDataType::Boolean]);
+                            supported_types.extend([
+                                Some(VarRefDataType::String),
+                                Some(VarRefDataType::Boolean),
+                            ]);
                         }
                         "min" | "max" => {
-                            supported_types.insert(VarRefDataType::Boolean);
+                            supported_types.insert(Some(VarRefDataType::Boolean));
                         }
                         "holt_winters" | "holt_winters_with_fit" => {
-                            supported_types.remove(&VarRefDataType::Unsigned);
+                            supported_types.remove(&Some(VarRefDataType::Unsigned));
                         }
                         _ => {}
                     }
 
                     let add_field = |v: &VarRef| {
                         let mut args = args.clone();
-                        args[0] = Expr::VarRef {
-                            name: v.name.clone().into(),
-                            data_type: Some(v.data_type),
-                        };
+                        args[0] = Expr::VarRef(v.clone());
                         new_fields.push(Field {
-                            expr: Expr::Call {
+                            expr: Expr::Call(Call {
                                 name: name.clone(),
                                 args,
-                            },
+                            }),
                             alias: Some(format!("{}_{}", field_name(f), v.name).into()),
                         })
                     };