Merge branch 'main' into postgres-regression-11

Author: LucaCappelletti94

.github/workflows/rust.yml

@@ -82,6 +82,7 @@ jobs:
         with:
           targets: 'thumbv6m-none-eabi'
       - run: cargo check --no-default-features --target thumbv6m-none-eabi
+      - run: cargo check --no-default-features --features visitor --target thumbv6m-none-eabi
 
   test:
     strategy:

derive/src/visit.rs

@@ -62,11 +62,11 @@ pub(crate) fn derive_visit(
             fn visit<V: sqlparser::ast::#visitor_trait>(
                 &#modifier self,
                 visitor: &mut V
-            ) -> ::std::ops::ControlFlow<V::Break> {
+            ) -> ::core::ops::ControlFlow<V::Break> {
                 #pre_visit
                 #children
                 #post_visit
-                ::std::ops::ControlFlow::Continue(())
+                ::core::ops::ControlFlow::Continue(())
             }
         }
     };

sqlparser_bench/benches/sqlparser_bench.rs

@@ -16,7 +16,7 @@
 // under the License.
 
 use criterion::{criterion_group, criterion_main, Criterion};
-use sqlparser::dialect::GenericDialect;
+use sqlparser::dialect::{GenericDialect, PostgreSqlDialect, SQLiteDialect};
 use sqlparser::keywords::Keyword;
 use sqlparser::parser::Parser;
 use sqlparser::tokenizer::{Span, Word};
@@ -152,5 +152,107 @@ fn parse_many_identifiers(c: &mut Criterion) {
     group.finish();
 }
 
-criterion_group!(benches, basic_queries, word_to_ident, parse_many_identifiers);
+/// Benchmark parsing pathological compound chains that previously caused 2^N
+/// work in `parse_compound_expr`. The input `IF a0.a1...aN.#` rejects at the
+/// trailing `#`, which used to force quadratic-or-worse backtracking through
+/// the chain.
+fn parse_compound_chain(c: &mut Criterion) {
+    let mut group = c.benchmark_group("parse_compound_chain");
+    let dialect = GenericDialect {};
+
+    for &n in &[10usize, 20, 30] {
+        let chain = (0..n)
+            .map(|i| format!("a{i}"))
+            .collect::<Vec<_>>()
+            .join(".");
+        let sql = format!("IF {chain}.#");
+
+        group.bench_function(format!("chain_{n}"), |b| {
+            b.iter(|| {
+                let _ = Parser::parse_sql(&dialect, std::hint::black_box(&sql));
+            });
+        });
+    }
+
+    group.finish();
+}
+
+/// Benchmark parsing pathological compound chains with a reserved keyword in
+/// field position, like `SELECT x.not-b.not-b...`. The `.not-b` shape used to
+/// cause 2^N work in `parse_compound_expr` because `parse_prefix` descended
+/// into `parse_not` -> `parse_subexpr`, re-walking the remaining chain at
+/// every segment.
+fn parse_compound_keyword_chain(c: &mut Criterion) {
+    let mut group = c.benchmark_group("parse_compound_keyword_chain");
+    let dialect = GenericDialect {};
+
+    for &n in &[5usize, 10, 15] {
+        let body = std::iter::repeat_n(".not-b", n).collect::<String>();
+        let sql = format!("SELECT x{body}");
+
+        group.bench_function(format!("chain_{n}"), |b| {
+            b.iter(|| {
+                let _ = Parser::parse_sql(&dialect, std::hint::black_box(&sql));
+            });
+        });
+    }
+
+    group.finish();
+}
+
+/// Benchmark parsing pathological `IF(<keyword-fn>(<keyword-fn>(...x` chains
+/// that previously caused 2^N work in `parse_prefix`. Each nested
+/// `current_time(` segment used to be explored twice at every level (once via
+/// the speculative reserved-word arm, once via the unreserved-word fallback),
+/// doubling work per level. Post-fix the cost is linear in chain length.
+fn parse_prefix_keyword_call_chain(c: &mut Criterion) {
+    let mut group = c.benchmark_group("parse_prefix_keyword_call_chain");
+    let dialect = PostgreSqlDialect {};
+
+    for &n in &[10usize, 20, 30] {
+        let sql = String::from("if(") + &"current_time(".repeat(n) + "x";
+
+        group.bench_function(format!("chain_{n}"), |b| {
+            b.iter(|| {
+                let _ = Parser::parse_sql(&dialect, std::hint::black_box(&sql));
+            });
+        });
+    }
+
+    group.finish();
+}
+
+/// Benchmark parsing pathological `case-case-case-...c` chains that
+/// previously caused 2^N work in `parse_prefix`. Each `case` token used to
+/// trigger a speculative `parse_case_expr` that recursively descends the
+/// chain, but the unreserved-word fallback returns `Identifier(case)` so the
+/// overall `parse_prefix` succeeds and the failure cache never fires.
+/// Post-fix the per-arm cache short-circuits the speculative descent.
+fn parse_prefix_case_chain(c: &mut Criterion) {
+    let mut group = c.benchmark_group("parse_prefix_case_chain");
+    let dialect = SQLiteDialect {};
+
+    for &n in &[10usize, 20, 30] {
+        let sql = "case\t-".repeat(n) + "c";
+
+        group.bench_function(format!("chain_{n}"), |b| {
+            b.iter(|| {
+                let _ = Parser::parse_sql(&dialect, std::hint::black_box(&sql));
+            });
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    basic_queries,
+    word_to_ident,
+    parse_many_identifiers,
+    parse_compound_chain,
+    parse_compound_keyword_chain,
+    parse_prefix_keyword_call_chain,
+    parse_prefix_case_chain
+);
 criterion_main!(benches);

src/ast/comments.rs

@@ -33,7 +33,7 @@ impl Comments {
     /// last accepted comment.  In other words, this method will skip the
     /// comment if its comming out of order (as encountered in the parsed
     /// source code.)
-    pub(crate) fn offer(&mut self, comment: CommentWithSpan) {
+    pub fn offer(&mut self, comment: CommentWithSpan) {
         if self
             .0
             .last()
@@ -71,7 +71,7 @@ impl Comments {
     /// // all comments appearing before line seven, i.e. before the first statement itself
     /// assert_eq!(
     ///    &comments.find(..Location::new(7, 1)).map(|c| c.as_str()).collect::<Vec<_>>(),
-    ///    &["\n header comment ...\n ... spanning multiple lines\n", " first statement\n"]);
+    ///    &["\n header comment ...\n ... spanning multiple lines\n", " first statement"]);
     ///
     /// // all comments appearing within the first statement
     /// assert_eq!(
@@ -81,7 +81,7 @@ impl Comments {
     /// // all comments appearing within or after the first statement
     /// assert_eq!(
     ///    &comments.find(Location::new(7, 1)..).map(|c| c.as_str()).collect::<Vec<_>>(),
-    ///    &[" world ", " second statement\n", " trailing comment\n"]);
+    ///    &[" world ", " second statement", " trailing comment"]);
     /// ```
     ///
     /// The [Spanned](crate::ast::Spanned) trait allows you to access location

src/ast/data_type.rs

@@ -439,10 +439,11 @@ pub enum DataType {
     Custom(ObjectName, Vec<String>),
     /// Arrays.
     Array(ArrayElemTypeDef),
-    /// Map, see [ClickHouse].
+    /// Map, see [ClickHouse], [Hive].
     ///
     /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/map
-    Map(Box<DataType>, Box<DataType>),
+    /// [Hive]: https://hive.apache.org/docs/latest/language/languagemanual-types/
+    Map(Box<DataType>, Box<DataType>, MapBracketKind),
     /// Tuple, see [ClickHouse].
     ///
     /// [ClickHouse]: https://clickhouse.com/docs/en/sql-reference/data-types/tuple
@@ -785,9 +786,14 @@ impl fmt::Display for DataType {
             DataType::LowCardinality(data_type) => {
                 write!(f, "LowCardinality({data_type})")
             }
-            DataType::Map(key_data_type, value_data_type) => {
-                write!(f, "Map({key_data_type}, {value_data_type})")
-            }
+            DataType::Map(key_data_type, value_data_type, bracket) => match bracket {
+                MapBracketKind::Parentheses => {
+                    write!(f, "Map({key_data_type}, {value_data_type})")
+                }
+                MapBracketKind::AngleBrackets => {
+                    write!(f, "MAP<{key_data_type}, {value_data_type}>")
+                }
+            },
             DataType::Tuple(fields) => {
                 write!(f, "Tuple({})", display_comma_separated(fields))
             }
@@ -904,6 +910,17 @@ pub enum StructBracketKind {
     AngleBrackets,
 }
 
+/// Type of brackets used for `MAP` types.
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum MapBracketKind {
+    /// Example: `Map(String, UInt16)`
+    Parentheses,
+    /// Example: `MAP<STRING, INT>`
+    AngleBrackets,
+}
+
 /// Timestamp and Time data types information about TimeZone formatting.
 ///
 /// This is more related to a display information than real differences between each variant. To

src/ast/ddl.rs

@@ -2817,6 +2817,10 @@ pub struct CreateIndex {
     pub unique: bool,
     /// whether the index is created concurrently
     pub concurrently: bool,
+    /// whether the index is created asynchronously ([DSQL]).
+    ///
+    /// [DSQL]: https://docs.aws.amazon.com/aurora-dsql/latest/userguide/working-with-create-index-async.html
+    pub r#async: bool,
     /// IF NOT EXISTS clause
     pub if_not_exists: bool,
     /// INCLUDE clause: <https://www.postgresql.org/docs/current/sql-createindex.html>
@@ -2842,13 +2846,14 @@ impl fmt::Display for CreateIndex {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(
             f,
-            "CREATE {unique}INDEX {concurrently}{if_not_exists}",
+            "CREATE {unique}INDEX {concurrently}{async_}{if_not_exists}",
             unique = if self.unique { "UNIQUE " } else { "" },
             concurrently = if self.concurrently {
                 "CONCURRENTLY "
             } else {
                 ""
             },
+            async_ = if self.r#async { "ASYNC " } else { "" },
             if_not_exists = if self.if_not_exists {
                 "IF NOT EXISTS "
             } else {

src/ast/mod.rs

@@ -53,7 +53,7 @@ use crate::{
 
 pub use self::data_type::{
     ArrayElemTypeDef, BinaryLength, CharLengthUnits, CharacterLength, DataType, EnumMember,
-    ExactNumberInfo, IntervalFields, StructBracketKind, TimezoneInfo,
+    ExactNumberInfo, IntervalFields, MapBracketKind, StructBracketKind, TimezoneInfo,
 };
 pub use self::dcl::{
     AlterRoleOperation, CreateRole, Grant, ResetConfig, Revoke, RoleOption, SecondaryRoles,
@@ -4500,6 +4500,28 @@ pub enum Statement {
         comment: Option<String>,
     },
     /// ```sql
+    /// CREATE [ OR REPLACE ] [ { TEMP | TEMPORARY | VOLATILE } ] FILE FORMAT [ IF NOT EXISTS ] <name>
+    ///   [ TYPE = { CSV | JSON | AVRO | ORC | PARQUET | XML } [ formatTypeOptions ] ]
+    ///   [ COMMENT = '<string_literal>' ]
+    /// ```
+    /// See <https://docs.snowflake.com/en/sql-reference/sql/create-file-format>
+    CreateFileFormat {
+        /// `OR REPLACE` flag.
+        or_replace: bool,
+        /// Whether file format is temporary.
+        temporary: bool,
+        /// Whether file format is volatile.
+        volatile: bool,
+        /// `IF NOT EXISTS` flag.
+        if_not_exists: bool,
+        /// File format name.
+        name: ObjectName,
+        /// Format type options (e.g. `TYPE`, `FIELD_DELIMITER`, `COMPRESSION`, ...).
+        options: KeyValueOptions,
+        /// Optional comment.
+        comment: Option<String>,
+    },
+    /// ```sql
     /// ASSERT <condition> [AS <message>]
     /// ```
     Assert {
@@ -4865,6 +4887,20 @@ pub enum Statement {
     /// Snowflake `LIST`
     /// See: <https://docs.snowflake.com/en/sql-reference/sql/list>
     List(FileStagingCommand),
+    /// Snowflake `PUT`
+    /// ```sql
+    /// PUT 'file://<path>' <internalStage> [ <option> = <value> ... ]
+    /// ```
+    /// Options include `PARALLEL`, `AUTO_COMPRESS`, `SOURCE_COMPRESSION`, `OVERWRITE`.
+    /// See: <https://docs.snowflake.com/en/sql-reference/sql/put>
+    Put {
+        /// Local source URI as written in the statement, e.g. `file:///tmp/data.csv`.
+        source: String,
+        /// Target internal stage (e.g. `@mystage`, `@~`, `@%table`).
+        stage: ObjectName,
+        /// Trailing options (`PARALLEL=4`, `AUTO_COMPRESS=TRUE`, ...).
+        options: KeyValueOptions,
+    },
     /// Snowflake `REMOVE`
     /// See: <https://docs.snowflake.com/en/sql-reference/sql/remove>
     Remove(FileStagingCommand),
@@ -6186,6 +6222,31 @@ impl fmt::Display for Statement {
                 }
                 Ok(())
             }
+            Statement::CreateFileFormat {
+                or_replace,
+                temporary,
+                volatile,
+                if_not_exists,
+                name,
+                options,
+                comment,
+            } => {
+                write!(
+                    f,
+                    "CREATE {or_replace}{temp}{volatile}FILE FORMAT {if_not_exists}{name}",
+                    or_replace = if *or_replace { "OR REPLACE " } else { "" },
+                    temp = if *temporary { "TEMPORARY " } else { "" },
+                    volatile = if *volatile { "VOLATILE " } else { "" },
+                    if_not_exists = if *if_not_exists { "IF NOT EXISTS " } else { "" },
+                )?;
+                if !options.options.is_empty() {
+                    write!(f, " {options}")?;
+                }
+                if let Some(comment) = comment {
+                    write!(f, " COMMENT='{}'", comment)?;
+                }
+                Ok(())
+            }
             Statement::CopyIntoSnowflake {
                 kind,
                 into,
@@ -6387,6 +6448,17 @@ impl fmt::Display for Statement {
             Statement::WaitFor(s) => write!(f, "{s}"),
             Statement::Return(r) => write!(f, "{r}"),
             Statement::List(command) => write!(f, "LIST {command}"),
+            Statement::Put {
+                source,
+                stage,
+                options,
+            } => {
+                write!(f, "PUT '{source}' {stage}")?;
+                if !options.options.is_empty() {
+                    write!(f, " {options}")?;
+                }
+                Ok(())
+            }
             Statement::Remove(command) => write!(f, "REMOVE {command}"),
             Statement::ExportData(e) => write!(f, "{e}"),
             Statement::CreateUser(s) => write!(f, "{s}"),
@@ -12183,7 +12255,8 @@ impl fmt::Display for OptimizerHint {
                 f.write_str(prefix)?;
                 f.write_str(&self.prefix)?;
                 f.write_str("+")?;
-                f.write_str(&self.text)
+                f.write_str(&self.text)?;
+                f.write_str("\n")
             }
             OptimizerHintStyle::MultiLine => {
                 f.write_str("/*")?;

src/ast/query.rs

@@ -3715,8 +3715,11 @@ pub struct SelectInto {
     pub unlogged: bool,
     /// `TABLE` keyword present.
     pub table: bool,
-    /// Name of the target table.
-    pub name: ObjectName,
+    /// Target(s) of the `INTO` clause.
+    ///
+    /// [Postgres]: https://www.postgresql.org/docs/current/sql-selectinto.html
+    /// [MySQL]: https://dev.mysql.com/doc/refman/9.7/en/select-into.html
+    pub targets: Vec<Expr>,
 }
 
 impl fmt::Display for SelectInto {
@@ -3725,7 +3728,14 @@ impl fmt::Display for SelectInto {
         let unlogged = if self.unlogged { " UNLOGGED" } else { "" };
         let table = if self.table { " TABLE" } else { "" };
 
-        write!(f, "INTO{}{}{} {}", temporary, unlogged, table, self.name)
+        write!(
+            f,
+            "INTO{}{}{} {}",
+            temporary,
+            unlogged,
+            table,
+            display_comma_separated(&self.targets)
+        )
     }
 }