feat: support range query

Signed-off-by: Ruihang Xia <[email protected]>

Author: Taylor-lagrange

Cargo.toml

@@ -25,11 +25,7 @@ documentation = "https://docs.rs/sqlparser/"
 keywords = ["ansi", "sql", "lexer", "parser"]
 repository = "https://github.com/apache/datafusion-sqlparser-rs"
 license = "Apache-2.0"
-include = [
-    "src/**/*.rs",
-    "Cargo.toml",
-    "LICENSE.TXT",
-]
+include = ["src/**/*.rs", "Cargo.toml", "LICENSE.TXT"]
 edition = "2021"
 
 [lib]
@@ -43,9 +39,11 @@ recursive-protection = ["std", "recursive"]
 # Enable JSON output in the `cli` example:
 json_example = ["serde_json", "serde"]
 visitor = ["sqlparser_derive"]
+bigdecimal-sql = ["bigdecimal", "df_sqlparser/bigdecimal"]
 
 [dependencies]
 bigdecimal = { version = "0.4.1", features = ["serde"], optional = true }
+df_sqlparser = { package = "sqlparser", version = "0.55.0" }
 log = "0.4"
 recursive = { version = "0.1.1", optional = true}
 
@@ -55,6 +53,8 @@ serde = { version = "1.0", default-features = false, features = ["derive", "allo
 # https://github.com/rust-lang/cargo/issues/1596
 serde_json = { version = "1.0", optional = true }
 sqlparser_derive = { version = "0.3.0", path = "derive", optional = true }
+regex = "1"
+lazy_static = "1.4.0"
 
 [dev-dependencies]
 simple_logger = "5.0"

derive/src/lib.rs

@@ -15,15 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use proc_macro2::TokenStream;
+use proc_macro2::{Literal, TokenStream};
 use quote::{format_ident, quote, quote_spanned, ToTokens};
 use syn::spanned::Spanned;
 use syn::{
     parse::{Parse, ParseStream},
     parse_macro_input, parse_quote, Attribute, Data, DeriveInput, Fields, GenericParam, Generics,
     Ident, Index, LitStr, Meta, Token, Type, TypePath,
 };
-use syn::{Path, PathArguments};
+use syn::{
+    AngleBracketedGenericArguments, DataEnum, DataStruct, FieldsNamed, FieldsUnnamed,
+    GenericArgument, MetaList, Path, PathArguments, PathSegment,
+};
 
 /// Implementation of `[#derive(Visit)]`
 #[proc_macro_derive(VisitMut, attributes(visit))]
@@ -289,3 +292,323 @@ fn is_option(ty: &Type) -> bool {
     }
     false
 }
+
+/// Determine the variable type to decide which method in the `Convert` trait to use
+fn get_var_type(ty: &Type) -> TokenStream {
+    let span = ty.span();
+    if let Type::Path(TypePath {
+        path: Path { segments, .. },
+        ..
+    }) = ty
+    {
+        if let Some(PathSegment { ident, arguments }) = segments.first() {
+            return match ident.to_string().as_str() {
+                "Option" => {
+                    if let PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+                        args,
+                        ..
+                    }) = arguments
+                    {
+                        if let Some(GenericArgument::Type(Type::Path(TypePath {
+                            path: Path { segments, .. },
+                            ..
+                        }))) = args.first()
+                        {
+                            if let Some(PathSegment { ident, .. }) = segments.first() {
+                                return match ident.to_string().as_str() {
+                                    "Box" => quote_spanned!(span => Convert::convert_option_box),
+                                    "Vec" => quote_spanned!(span => Convert::convert_option_vec),
+                                    _ => quote_spanned!(span => Convert::convert_option),
+                                };
+                            }
+                        }
+                    }
+                    quote_spanned!(span => Convert::convert_option)
+                }
+                "Vec" => {
+                    if let PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+                        args,
+                        ..
+                    }) = arguments
+                    {
+                        if let Some(GenericArgument::Type(Type::Path(TypePath {
+                            path: Path { segments, .. },
+                            ..
+                        }))) = args.first()
+                        {
+                            if let Some(PathSegment { ident, .. }) = segments.first() {
+                                return match ident.to_string().as_str() {
+                                    "Vec" => quote_spanned!(span => Convert::convert_matrix),
+                                    "Box" => quote_spanned!(span => Convert::convert_vec_box),
+                                    _ => quote_spanned!(span => Convert::convert_vec),
+                                };
+                            }
+                        }
+                    }
+                    quote_spanned!(span => Convert::convert_vec)
+                }
+                "Box" => quote_spanned!(span => Convert::convert_box),
+                _ => quote_spanned!(span => Convert::convert),
+            };
+        }
+    }
+    quote_spanned!(span => Convert::convert)
+}
+
+/// Obtain the struct path where `datafusion` `sqlparser` is located from derive macro helper attribute `df_path`,
+/// if value not given, the default return is `df_sqlparser::ast`
+fn get_crate_path(st: &DeriveInput) -> TokenStream {
+    let span = st.span();
+    for attr in &st.attrs {
+        let Meta::List(MetaList {
+            path: Path { segments, .. },
+            tokens,
+            ..
+        }) = &attr.meta
+        else {
+            continue;
+        };
+        if let Some(PathSegment { ident, .. }) = segments.first() {
+            if ident.to_string().as_str() == "df_path" {
+                return tokens.clone();
+            }
+        }
+    }
+    quote_spanned!(span => df_sqlparser::ast)
+}
+
+/// Check whether the attribute `ignore_item` exists. If the attribute exists,
+/// the corresponding convert method will not be generated.
+/// If exist attribute `ignore_item`
+/// 1. enum conversion returns panic
+/// 2. struct conversion does not generate the corresponding field
+fn ignore_convert(attrs: &Vec<Attribute>) -> bool {
+    for attr in attrs {
+        let Meta::Path(Path { segments, .. }) = &attr.meta else {
+            continue;
+        };
+        if let Some(PathSegment { ident, .. }) = segments.first() {
+            if ident.to_string().as_str() == "ignore_item" {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+fn convert_struct(st: &DeriveInput) -> TokenStream {
+    let name = &st.ident;
+    let path = get_crate_path(st);
+    // for struct pattern like
+    // struct xxx {
+    //  xxx: xxx
+    // }
+    if let Data::Struct(DataStruct {
+        fields: Fields::Named(FieldsNamed { named, .. }),
+        ..
+    }) = &st.data
+    {
+        let span = named.span();
+        let mut fields: Vec<TokenStream> = Vec::with_capacity(named.len());
+        for field in named {
+            if ignore_convert(&field.attrs) {
+                continue;
+            }
+            let field_name = field.ident.clone().unwrap();
+            let var_type = get_var_type(&field.ty);
+            let span = field_name.span();
+            let code = quote_spanned! { span =>
+                #field_name: #var_type(value.#field_name),
+            };
+            fields.push(code);
+        }
+        return quote_spanned! { span =>
+            impl From<#name> for #path::#name {
+                #[allow(unused_variables)]
+                fn from(value: #name) -> Self {
+                    Self {
+                        #(#fields)*
+                    }
+                }
+            }
+        };
+    }
+    // for struct pattern like
+    // struct xxx(xxxx);
+    if let Data::Struct(DataStruct {
+        fields: Fields::Unnamed(FieldsUnnamed { unnamed, .. }),
+        ..
+    }) = &st.data
+    {
+        let span = unnamed.span();
+        let mut fields: Vec<TokenStream> = Vec::with_capacity(unnamed.len());
+        for i in 0..unnamed.len() {
+            if ignore_convert(&unnamed[i].attrs) {
+                continue;
+            }
+            let field_name = Literal::usize_unsuffixed(i);
+            let var_type = get_var_type(&unnamed[i].ty);
+            let span = unnamed[i].span();
+            let code = quote_spanned! { span =>
+                #var_type(value.#field_name),
+            };
+            fields.push(code);
+        }
+        return quote_spanned! { span =>
+            impl From<#name> for #path::#name {
+                #[allow(unused_variables)]
+                fn from(value: #name) -> Self {
+                    Self(#(#fields)*)
+                }
+            }
+        };
+    }
+    panic!("Unrecognised Struct Type{}", st.to_token_stream())
+}
+
+fn convert_enum(st: &DeriveInput) -> TokenStream {
+    let name = &st.ident;
+    let path = get_crate_path(st);
+    if let Data::Enum(DataEnum { variants, .. }) = &st.data {
+        let span = variants.span();
+        let mut fields: Vec<TokenStream> = Vec::with_capacity(variants.len());
+        for field in variants {
+            let enum_name = &field.ident;
+            let span = enum_name.span();
+            let ignore_convert = ignore_convert(&field.attrs);
+            // for enum item like xxxxxx(xxx)
+            if let Fields::Unnamed(FieldsUnnamed { unnamed, .. }) = &field.fields {
+                let inner_names = ('a'..='z')
+                    .map(|x| Ident::new(x.to_string().as_str(), unnamed.span()))
+                    .collect::<Vec<_>>()[..unnamed.len()]
+                    .to_vec();
+                let mut codes: Vec<TokenStream> = Vec::with_capacity(unnamed.len());
+                let inner_fields: Vec<_> = inner_names.iter().map(|x| quote!(#x,)).collect();
+                for (inner_name, field) in inner_names.iter().zip(unnamed.iter()) {
+                    let var_type = get_var_type(&field.ty);
+                    let span = field.span();
+                    codes.push(quote_spanned! { span =>
+                        #var_type(#inner_name),
+                    });
+                }
+                fields.push(if ignore_convert {
+                    quote_spanned! { span =>
+                        #name::#enum_name(#(#inner_fields)*) => panic!("Convert on this item is ignored"),
+                    }
+                } else {
+                    quote_spanned! { span =>
+                        #name::#enum_name(#(#inner_fields)*) => Self::#enum_name(#(#codes)*),
+                    }
+                });
+            }
+            //  for enum item like
+            //  xxxxxx {
+            //     xxx: xxxx,
+            // },
+            if let Fields::Named(FieldsNamed { named, .. }) = &field.fields {
+                let mut inner_fields: Vec<TokenStream> = Vec::with_capacity(named.len());
+                let mut codes: Vec<TokenStream> = Vec::with_capacity(named.len());
+                let span = named.span();
+                for field in named {
+                    let field_name = field.ident.clone().unwrap();
+                    let span = field_name.span();
+                    let var_type = get_var_type(&field.ty);
+                    inner_fields.push(quote_spanned!(span => #field_name,));
+                    codes.push(quote_spanned! { span =>
+                        #field_name: #var_type(#field_name),
+                    });
+                }
+                fields.push(if ignore_convert {
+                    quote_spanned! { span =>
+                        #name::#enum_name{#(#inner_fields)*} => panic!("Convert on this item is ignored"),
+                    }
+                } else {
+                    quote_spanned! { span =>
+                        #name::#enum_name{#(#inner_fields)*} => Self::#enum_name{#(#codes)*},
+                    }
+                });
+            }
+            //  for enum item like
+            // xxxxxx
+            if let Fields::Unit = &field.fields {
+                let span = field.span();
+                fields.push(if ignore_convert {
+                    quote_spanned! { span =>
+                        #name::#enum_name => panic!("Convert on this item is ignored"),
+                    }
+                } else {
+                    quote_spanned! { span =>
+                        #name::#enum_name => Self::#enum_name,
+                    }
+                });
+            }
+        }
+        return quote_spanned! { span =>
+            impl From<#name> for #path::#name {
+                #[allow(unused_variables)]
+                fn from(value: #name) -> Self {
+                    match value{
+                        #(#fields)*
+                    }
+                }
+            }
+        };
+    }
+    panic!("Unrecognised Enum Type{}", st.to_token_stream())
+}
+
+fn convert_union(st: &DeriveInput) -> TokenStream {
+    let name = &st.ident;
+    let path = get_crate_path(st);
+
+    if let Data::Union(data_union) = &st.data {
+        let span = data_union.fields.span();
+        let mut fields: Vec<TokenStream> = Vec::with_capacity(data_union.fields.named.len());
+
+        for field in &data_union.fields.named {
+            if ignore_convert(&field.attrs) {
+                continue;
+            }
+            let field_name = field.ident.clone().unwrap();
+            let var_type = get_var_type(&field.ty);
+            let span = field_name.span();
+            let code = quote_spanned! { span =>
+                #field_name: unsafe { #var_type(value.#field_name) },
+            };
+            fields.push(code);
+        }
+
+        quote_spanned! { span =>
+            impl From<#name> for #path::#name {
+                #[allow(unused_variables)]
+                fn from(value: #name) -> Self {
+                    unsafe {
+                        Self {
+                            #(#fields)*
+                        }
+                    }
+                }
+            }
+        }
+    } else {
+        panic!("Expected Union type")
+    }
+}
+
+fn expand_df_convert(st: &DeriveInput) -> TokenStream {
+    match st.data {
+        Data::Struct(_) => convert_struct(st),
+        Data::Enum(_) => convert_enum(st),
+        Data::Union(_) => convert_union(st),
+    }
+}
+
+/// Derive macro to implement `From` Trait. Convert the current sqlparser struct to the struct used by datafusion sqlparser.
+/// There are two helper attributes that can be marked on the derive struct/enum, affecting the generated Convert function
+/// 1. `#[df_path(....)]`: Most structures are defined in `df_sqlparser::ast`, if the path of some structures is not in this path,
+///    user need to specify `df_path` to tell the compiler the location of this struct/enum
+/// 2. `#[ignore_item]`: Marked on the field of the struct/enum, indicating that the Convert method of the field of the struct/enum is not generated·
+#[proc_macro_derive(DFConvert, attributes(df_path, ignore_item))]
+pub fn derive_df_convert(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    expand_df_convert(&parse_macro_input!(input as DeriveInput)).into()
+}

rust-toolchain

@@ -0,0 +1 @@
+stable