Temp for Wren Engine 0.12.3

derive/README.md

@@ -151,6 +151,55 @@ visitor.post_visit_expr(<is null operand>)
 visitor.post_visit_expr(<is null expr>)
 ```
 
+If the field is a `Option` and add `#[with = "visit_xxx"]` to the field, the generated code
+will try to access the field only if it is `Some`:
+
+```rust
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub struct ShowStatementIn {
+    pub clause: ShowStatementInClause,
+    pub parent_type: Option<ShowStatementInParentType>,
+    #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
+    pub parent_name: Option<ObjectName>,
+}
+```
+
+This will generate
+
+```rust
+impl sqlparser::ast::Visit for ShowStatementIn {
+    fn visit<V: sqlparser::ast::Visitor>(
+        &self,
+        visitor: &mut V,
+    ) -> ::std::ops::ControlFlow<V::Break> {
+        sqlparser::ast::Visit::visit(&self.clause, visitor)?;
+        sqlparser::ast::Visit::visit(&self.parent_type, visitor)?;
+        if let Some(value) = &self.parent_name {
+            visitor.pre_visit_relation(value)?;
+            sqlparser::ast::Visit::visit(value, visitor)?;
+            visitor.post_visit_relation(value)?;
+        }
+        ::std::ops::ControlFlow::Continue(())
+    }
+}
+
+impl sqlparser::ast::VisitMut for ShowStatementIn {
+    fn visit<V: sqlparser::ast::VisitorMut>(
+        &mut self,
+        visitor: &mut V,
+    ) -> ::std::ops::ControlFlow<V::Break> {
+        sqlparser::ast::VisitMut::visit(&mut self.clause, visitor)?;
+        sqlparser::ast::VisitMut::visit(&mut self.parent_type, visitor)?;
+        if let Some(value) = &mut self.parent_name {
+            visitor.pre_visit_relation(value)?;
+            sqlparser::ast::VisitMut::visit(value, visitor)?;
+            visitor.post_visit_relation(value)?;
+        }
+        ::std::ops::ControlFlow::Continue(())
+    }
+}
+```
+
 ## Releasing
 
 This crate's release is not automated. Instead it is released manually as needed

derive/src/lib.rs

@@ -18,11 +18,8 @@
 use proc_macro2::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,
-};
+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};
 
 /// Implementation of `[#derive(Visit)]`
 #[proc_macro_derive(VisitMut, attributes(visit))]
@@ -182,9 +179,21 @@ fn visit_children(
             Fields::Named(fields) => {
                 let recurse = fields.named.iter().map(|f| {
                     let name = &f.ident;
+                    let is_option = is_option(&f.ty);
                     let attributes = Attributes::parse(&f.attrs);
-                    let (pre_visit, post_visit) = attributes.visit(quote!(&#modifier self.#name));
-                    quote_spanned!(f.span() => #pre_visit sqlparser::ast::#visit_trait::visit(&#modifier self.#name, visitor)?; #post_visit)
+                    if is_option && attributes.with.is_some() {
+                        let (pre_visit, post_visit) = attributes.visit(quote!(value));
+                        quote_spanned!(f.span() =>
+                            if let Some(value) = &#modifier self.#name {
+                                #pre_visit sqlparser::ast::#visit_trait::visit(value, visitor)?; #post_visit
+                            }
+                        )
+                    } else {
+                        let (pre_visit, post_visit) = attributes.visit(quote!(&#modifier self.#name));
+                        quote_spanned!(f.span() =>
+                            #pre_visit sqlparser::ast::#visit_trait::visit(&#modifier self.#name, visitor)?; #post_visit
+                        )
+                    }
                 });
                 quote! {
                     #(#recurse)*
@@ -256,3 +265,16 @@ fn visit_children(
         Data::Union(_) => unimplemented!(),
     }
 }
+
+fn is_option(ty: &Type) -> bool {
+    if let Type::Path(TypePath { path: Path { segments, .. }, .. }) = ty {
+        if let Some(segment) = segments.last() {
+            if segment.ident == "Option" {
+                if let PathArguments::AngleBracketed(args) = &segment.arguments {
+                    return args.args.len() == 1;
+                }
+            }
+        }
+    }
+    false
+}

src/ast/mod.rs

@@ -26,7 +26,6 @@ use alloc::{
 
 use core::fmt::{self, Display};
 use core::ops::Deref;
-
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -7587,6 +7586,7 @@ impl fmt::Display for ShowStatementInParentType {
 pub struct ShowStatementIn {
     pub clause: ShowStatementInClause,
     pub parent_type: Option<ShowStatementInParentType>,
+    #[cfg_attr(feature = "visitor", visit(with = "visit_relation"))]
     pub parent_name: Option<ObjectName>,
 }
 

src/ast/visitor.rs

@@ -876,7 +876,16 @@ mod tests {
                     "POST: QUERY: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ORDER BY EMPID",
                     "POST: STATEMENT: SELECT * FROM monthly_sales PIVOT(SUM(a.amount) FOR a.MONTH IN ('JAN', 'FEB', 'MAR', 'APR')) AS p (c, d) ORDER BY EMPID",
                 ]
-            )
+            ),
+            (
+                "SHOW COLUMNS FROM t1",
+                vec![
+                    "PRE: STATEMENT: SHOW COLUMNS FROM t1",
+                    "PRE: RELATION: t1",
+                    "POST: RELATION: t1",
+                    "POST: STATEMENT: SHOW COLUMNS FROM t1",
+                ],
+            ),
         ];
         for (sql, expected) in tests {
             let actual = do_visit(sql);

src/dialect/bigquery.rs

@@ -72,4 +72,8 @@ impl Dialect for BigQueryDialect {
     fn require_interval_qualifier(&self) -> bool {
         true
     }
+
+    fn support_period_map_access_key(&self) -> bool {
+        true
+    }
 }

src/dialect/duckdb.rs

@@ -75,4 +75,9 @@ impl Dialect for DuckDbDialect {
     fn supports_load_extension(&self) -> bool {
         true
     }
+
+    /// See DuckDB <https://duckdb.org/docs/sql/data_types/struct.html#retrieving-from-structs>
+    fn support_period_map_access_key(&self) -> bool {
+        true
+    }
 }

src/dialect/generic.rs

@@ -123,4 +123,8 @@ impl Dialect for GenericDialect {
     fn supports_named_fn_args_with_assignment_operator(&self) -> bool {
         true
     }
+
+    fn support_period_map_access_key(&self) -> bool {
+        true
+    }
 }

src/dialect/mod.rs

@@ -676,6 +676,15 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Return true if the dialect supports the period map access key
+    ///
+    /// Access on BigQuery nested and repeated expressions can
+    /// mix notations in the same expression.
+    /// <https://cloud.google.com/bigquery/docs/nested-repeated#query_nested_and_repeated_columns>
+    fn support_period_map_access_key(&self) -> bool {
+        false
+    }
+
     /// Returns true if the dialect supports PartiQL for querying semi-structured data
     /// <https://partiql.org/index.html>
     fn supports_partiql(&self) -> bool {

src/parser/mod.rs

@@ -2976,12 +2976,23 @@ impl<'a> Parser<'a> {
             })
         } else if Token::LBracket == tok {
             if dialect_of!(self is PostgreSqlDialect | DuckDbDialect | GenericDialect) {
-                self.parse_subscript(expr)
+                let expr = self.parse_multi_dim_subscript(expr)?;
+                if self.dialect.support_period_map_access_key() {
+                    self.parse_map_access(expr, vec![])
+                } else {
+                    Ok(expr)
+                }
             } else if dialect_of!(self is SnowflakeDialect) || self.dialect.supports_partiql() {
                 self.prev_token();
                 self.parse_json_access(expr)
             } else {
-                self.parse_map_access(expr)
+                let key = self.parse_expr()?;
+                self.expect_token(&Token::RBracket)?;
+                let keys = vec![MapAccessKey {
+                    key,
+                    syntax: MapAccessSyntax::Bracket,
+                }];
+                self.parse_map_access(expr, keys)
             }
         } else if dialect_of!(self is SnowflakeDialect | GenericDialect) && Token::Colon == tok {
             self.prev_token();
@@ -3077,6 +3088,19 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Parse an multi-dimension array accessing like `[1:3][1][1]`
+    ///
+    /// Parser is right after the first `[`
+    pub fn parse_multi_dim_subscript(&mut self, mut expr: Expr) -> Result<Expr, ParserError> {
+        loop {
+            expr = self.parse_subscript(expr)?;
+            if !self.consume_token(&Token::LBracket) {
+                break;
+            }
+        }
+        Ok(expr)
+    }
+
     /// Parses an array subscript like `[1:3]`
     ///
     /// Parser is right after `[`
@@ -3147,14 +3171,15 @@ impl<'a> Parser<'a> {
         Ok(JsonPath { path })
     }
 
-    pub fn parse_map_access(&mut self, expr: Expr) -> Result<Expr, ParserError> {
-        let key = self.parse_expr()?;
-        self.expect_token(&Token::RBracket)?;
-
-        let mut keys = vec![MapAccessKey {
-            key,
-            syntax: MapAccessSyntax::Bracket,
-        }];
+    /// Parse the map access like `[key]` or `.key` if [Dialect::support_period_map_access_key] is true
+    /// It could be an access-chain like `[key1][key2].key3`
+    ///
+    /// The parameter `keys` is an initialized buffer that could contain some keys parsed from other places.
+    pub fn parse_map_access(
+        &mut self,
+        expr: Expr,
+        mut keys: Vec<MapAccessKey>,
+    ) -> Result<Expr, ParserError> {
         loop {
             let key = match self.peek_token().token {
                 Token::LBracket => {
@@ -3166,10 +3191,7 @@ impl<'a> Parser<'a> {
                         syntax: MapAccessSyntax::Bracket,
                     }
                 }
-                // Access on BigQuery nested and repeated expressions can
-                // mix notations in the same expression.
-                // https://cloud.google.com/bigquery/docs/nested-repeated#query_nested_and_repeated_columns
-                Token::Period if dialect_of!(self is BigQueryDialect) => {
+                Token::Period if self.dialect.support_period_map_access_key() => {
                     self.next_token(); // consume `.`
                     MapAccessKey {
                         key: self.parse_expr()?,
@@ -3181,10 +3203,16 @@ impl<'a> Parser<'a> {
             keys.push(key);
         }
 
-        Ok(Expr::MapAccess {
-            column: Box::new(expr),
-            keys,
-        })
+        // If no any key be collected, it means the elements have been parsed to [Subscript]
+        // e.g. `select abc[1]` or `select abc[1][2]`
+        if keys.is_empty() {
+            Ok(expr)
+        } else {
+            Ok(Expr::MapAccess {
+                column: Box::new(expr),
+                keys,
+            })
+        }
     }
 
     /// Parses the parens following the `[ NOT ] IN` operator.

tests/sqlparser_common.rs

@@ -12368,6 +12368,28 @@ fn parse_create_table_select() {
     }
 }
 
+#[test]
+fn test_period_map_access() {
+    let supported_dialects = TestedDialects::new(vec![
+        Box::new(GenericDialect {}),
+        Box::new(DuckDbDialect {}),
+    ]);
+    let sqls = [
+        "SELECT abc[1] FROM t",
+        "SELECT abc[1].f1 FROM t",
+        "SELECT abc[1].f1.f2 FROM t",
+        "SELECT f1.abc[1] FROM t",
+        "SELECT f1.f2.abc[1] FROM t",
+        "SELECT f1.abc[1].f2 FROM t",
+        "SELECT abc['a'][1].f1 FROM t",
+        "SELECT abc['a'].f1[1].f2 FROM t",
+        "SELECT abc['a'].f1[1].f2[2] FROM t",
+    ];
+    for sql in sqls {
+        supported_dialects.verified_stmt(sql);
+    }
+}
+
 #[test]
 fn test_reserved_keywords_for_identifiers() {
     let dialects = all_dialects_where(|d| d.is_reserved_for_identifier(Keyword::INTERVAL));