Add derive based AST visitor

.gitignore

@@ -2,6 +2,7 @@
 # will have compiled files and executables
 /target/
 /sqlparser_bench/target/
+/derive/target/
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock

Cargo.toml

@@ -5,7 +5,7 @@ version = "0.28.0"
 authors = ["Andy Grove <andygrove73@gmail.com>"]
 homepage = "https://github.com/sqlparser-rs/sqlparser-rs"
 documentation = "https://docs.rs/sqlparser/"
-keywords = ["ansi", "sql", "lexer", "parser"]
+keywords = ["ansi", "sql", "lexer", "parser"]
 repository = "https://github.com/sqlparser-rs/sqlparser-rs"
 license = "Apache-2.0"
 include = [
@@ -23,6 +23,7 @@ default = ["std"]
 std = []
 # Enable JSON output in the `cli` example:
 json_example = ["serde_json", "serde"]
+visitor = ["sqlparser_derive"]
 
 [dependencies]
 bigdecimal = { version = "0.3", features = ["serde"], optional = true }
@@ -32,6 +33,7 @@ serde = { version = "1.0", features = ["derive"], optional = true }
 # of dev-dependencies because of
 # https://github.com/rust-lang/cargo/issues/1596
 serde_json = { version = "1.0", optional = true }
+sqlparser_derive = { version = "0.1", path = "derive", optional = true }
 
 [dev-dependencies]
 simple_logger = "4.0"

derive/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "sqlparser_derive"
+description = "proc macro for sqlparser"
+version = "0.1.0"
+authors = ["Andy Grove <andygrove73@gmail.com>"]
+homepage = "https://github.com/sqlparser-rs/sqlparser-rs"
+documentation = "https://docs.rs/sqlparser/"
+keywords = ["ansi", "sql", "lexer", "parser"]
+repository = "https://github.com/sqlparser-rs/sqlparser-rs"
+license = "Apache-2.0"
+include = [
+ "src/**/*.rs",
+ "Cargo.toml",
+]
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "1.0"
+proc-macro2 = "1.0"
+quote = "1.0"

derive/README.md

@@ -0,0 +1,79 @@
+# SQL Parser Derive Macro
+
+## Visit
+
+This crate contains a procedural macro that can automatically derive implementations of the `Visit` trait
+
+```rust
+#[derive(Visit)]
+struct Foo {
+ boolean: bool,
+ bar: Bar,
+}
+
+#[derive(Visit)]
+enum Bar {
+ A(),
+ B(String, bool),
+ C { named: i32 },
+}
+```
+
+Will generate code akin to
+
+```rust
+impl Visit for Foo {
+ fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+ self.boolean.visit(visitor)?;
+ self.bar.visit(visitor)?;
+ ControlFlow::Continue(())
+ }
+}
+
+impl Visit for Bar {
+ fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+ match self {
+ Self::A() => {}
+ Self::B(_1, _2) => {
+ _1.visit(visitor)?;
+ _2.visit(visitor)?;
+ }
+ Self::C { named } => {
+ named.visit(visitor)?;
+ }
+ }
+ ControlFlow::Continue(())
+ }
+}
+```
+
+Additionally certain types may wish to call a corresponding method on visitor before recursing
+
+```rust
+#[derive(Visit)]
+#[visit(with = "visit_expr")]
+enum Expr {
+ A(),
+ B(String, #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))] ObjectName, bool),
+}
+```
+
+Will generate
+
+```rust
+impl Visit for Bar {
+ fn visit<V: Visitor>(&self, visitor: &mut V) -> ControlFlow<V::Break> {
+ visitor.visit_expr(self)?;
+ match self {
+ Self::A() => {}
+ Self::B(_1, _2, _3) => {
+ _1.visit(visitor)?;
+ visitor.visit_relation(_3)?;
+ _2.visit(visitor)?;
+ _3.visit(visitor)?;
+ }
+ }
+ ControlFlow::Continue(())
+ }
+}
+```

derive/src/lib.rs

@@ -0,0 +1,184 @@
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote, quote_spanned, ToTokens};
+use syn::spanned::Spanned;
+use syn::{
+ parse_macro_input, parse_quote, Attribute, Data, DeriveInput, Fields, GenericParam, Generics,
+ Ident, Index, Lit, Meta, MetaNameValue, NestedMeta,
+};
+
+/// Implementation of `[#derive(Visit)]`
+#[proc_macro_derive(Visit, attributes(visit))]
+pub fn derive_visit(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+ // Parse the input tokens into a syntax tree.
+ let input = parse_macro_input!(input as DeriveInput);
+ let name = input.ident;
+
+ let attributes = Attributes::parse(&input.attrs);
+ // Add a bound `T: HeapSize` to every type parameter T.
+ let generics = add_trait_bounds(input.generics);
+ let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+ let (pre_visit, post_visit) = attributes.visit(quote!(self));
+ let children = visit_children(&input.data);
+
+ let expanded = quote! {
+ // The generated impl.
+ impl #impl_generics sqlparser::ast::Visit for #name #ty_generics #where_clause {
+ fn visit<V: sqlparser::ast::Visitor>(&self, visitor: &mut V) -> ::std::ops::ControlFlow<V::Break> {
+ #pre_visit
+ #children
+ #post_visit
+ ::std::ops::ControlFlow::Continue(())
+ }
+ }
+ };
+
+ proc_macro::TokenStream::from(expanded)
+}
+
+/// Parses attributes that can be provided to this macro
+///
+/// `#[visit(leaf, with = "visit_expr")]`
+#[derive(Default)]
+struct Attributes {
+ /// Content for the `with` attribute
+ with: Option<Ident>,
+}
+
+impl Attributes {
+ fn parse(attrs: &[Attribute]) -> Self {
+ let mut out = Self::default();
+ for attr in attrs.iter().filter(|a| a.path.is_ident("visit")) {
+ let meta = attr.parse_meta().expect("visit attribute");
+ match meta {
+ Meta::List(l) => {
+ for nested in &l.nested {
+ match nested {
+ NestedMeta::Meta(Meta::NameValue(v)) => out.parse_name_value(v),
+ _ => panic!("Expected #[visit(key = \"value\")]"),
+ }
+ }
+ }
+ _ => panic!("Expected #[visit(...)]"),
+ }
+ }
+ out
+ }
+
+ /// Updates self with a name value attribute
+ fn parse_name_value(&mut self, v: &MetaNameValue) {
+ if v.path.is_ident("with") {
+ match &v.lit {
+ Lit::Str(s) => self.with = Some(format_ident!("{}", s.value(), span = s.span())),
+ _ => panic!("Expected a string value, got {}", v.lit.to_token_stream()),
+ }
+ return;
+ }
+ panic!("Unrecognised kv attribute {}", v.path.to_token_stream())
+ }
+
+ /// Returns the pre and post visit token streams
+ fn visit(&self, s: TokenStream) -> (Option<TokenStream>, Option<TokenStream>) {
+ let pre_visit = self.with.as_ref().map(|m| {
+ let m = format_ident!("pre_{}", m);
+ quote!(visitor.#m(#s)?;)
+ });
+ let post_visit = self.with.as_ref().map(|m| {
+ let m = format_ident!("post_{}", m);
+ quote!(visitor.#m(#s)?;)
+ });
+ (pre_visit, post_visit)
+ }
+}
+
+// Add a bound `T: Visit` to every type parameter T.
+fn add_trait_bounds(mut generics: Generics) -> Generics {
+ for param in &mut generics.params {
+ if let GenericParam::Type(ref mut type_param) = *param {
+ type_param.bounds.push(parse_quote!(sqlparser::ast::Visit));
+ }
+ }
+ generics
+}
+
+// Generate the body of the visit implementation for the given type
+fn visit_children(data: &Data) -> TokenStream {
+ match data {
+ Data::Struct(data) => match &data.fields {
+ Fields::Named(fields) => {
+ let recurse = fields.named.iter().map(|f| {
+ let name = &f.ident;
+ let attributes = Attributes::parse(&f.attrs);
+ let (pre_visit, post_visit) = attributes.visit(quote!(&self.#name));
+ quote_spanned!(f.span() => #pre_visit sqlparser::ast::Visit::visit(&self.#name, visitor)?; #post_visit)
+ });
+ quote! {
+ #(#recurse)*
+ }
+ }
+ Fields::Unnamed(fields) => {
+ let recurse = fields.unnamed.iter().enumerate().map(|(i, f)| {
+ let index = Index::from(i);
+ let attributes = Attributes::parse(&f.attrs);
+ let (pre_visit, post_visit) = attributes.visit(quote!(&self.#index));
+ quote_spanned!(f.span() => #pre_visit sqlparser::ast::Visit::visit(&self.#index, visitor)?; #post_visit)
+ });
+ quote! {
+ #(#recurse)*
+ }
+ }
+ Fields::Unit => {
+ quote!()
+ }
+ },
+ Data::Enum(data) => {
+ let statements = data.variants.iter().map(|v| {
+ let name = &v.ident;
+ match &v.fields {
+ Fields::Named(fields) => {
+ let names = fields.named.iter().map(|f| &f.ident);
+ let visit = fields.named.iter().map(|f| {
+ let name = &f.ident;
+ let attributes = Attributes::parse(&f.attrs);
+ let (pre_visit, post_visit) = attributes.visit(quote!(&#name));
+ quote_spanned!(f.span() => #pre_visit sqlparser::ast::Visit::visit(#name, visitor)?; #post_visit)
+ });
+
+ quote!(
+ Self::#name { #(#names),* } => {
+ #(#visit)*
+ }
+ )
+ }
+ Fields::Unnamed(fields) => {
+ let names = fields.unnamed.iter().enumerate().map(|(i, f)| format_ident!("_{}", i, span = f.span()));
+ let visit = fields.unnamed.iter().enumerate().map(|(i, f)| {
+ let name = format_ident!("_{}", i);
+ let attributes = Attributes::parse(&f.attrs);
+ let (pre_visit, post_visit) = attributes.visit(quote!(&#name));
+ quote_spanned!(f.span() => #pre_visit sqlparser::ast::Visit::visit(#name, visitor)?; #post_visit)
+ });
+
+ quote! {
+ Self::#name ( #(#names),*) => {
+ #(#visit)*
+ }
+ }
+ }
+ Fields::Unit => {
+ quote! {
+ Self::#name => {}
+ }
+ }
+ }
+ });
+
+ quote! {
+ match self {
+ #(#statements),*
+ }
+ }
+ }
+ Data::Union(_) => unimplemented!(),
+ }
+}

src/ast/data_type.rs

@@ -17,13 +17,17 @@ use core::fmt;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+#[cfg(feature = "visitor")]
+use sqlparser_derive::Visit;
+
 use crate::ast::ObjectName;
 
 use super::value::escape_single_quote_string;
 
 /// SQL data types
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit))]
 pub enum DataType {
  /// Fixed-length character type e.g. CHARACTER(10)
  Character(Option<CharacterLength>),
@@ -337,6 +341,7 @@ fn format_datetime_precision_and_tz(
 /// guarantee compatibility with the input query we must maintain its exact information.
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit))]
 pub enum TimezoneInfo {
  /// No information about time zone. E.g., TIMESTAMP
  None,
@@ -384,6 +389,7 @@ impl fmt::Display for TimezoneInfo {
 /// [standard]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#exact-numeric-type
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit))]
 pub enum ExactNumberInfo {
  /// No additional information e.g. `DECIMAL`
  None,
@@ -414,6 +420,7 @@ impl fmt::Display for ExactNumberInfo {
 /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#character-length
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit))]
 pub struct CharacterLength {
  /// Default (if VARYING) or maximum (if not VARYING) length
  pub length: u64,
@@ -436,6 +443,7 @@ impl fmt::Display for CharacterLength {
 /// [1]: https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#char-length-units
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit))]
 pub enum CharLengthUnits {
  /// CHARACTERS unit
  Characters,