Added handling of CSVs in COPY STDIN

Cargo.toml

@@ -47,6 +47,7 @@ visitor = ["sqlparser_derive"]
 [dependencies]
 bigdecimal = { version = "0.4.1", features = ["serde"], optional = true }
 log = "0.4"
+csv = "1.4.0"
 recursive = { version = "0.1.1", optional = true}
 
 serde = { version = "1.0", default-features = false, features = ["derive", "alloc"], optional = true }

src/ast/mod.rs

@@ -3227,7 +3227,7 @@ pub enum Statement {
         /// WITH options (before PostgreSQL version 9.0)
         legacy_options: Vec<CopyLegacyOption>,
         /// VALUES a vector of values to be copied
-        values: Vec<Option<String>>,
+        values: Vec<Vec<Option<String>>>,
     },
     /// ```sql
     /// COPY INTO <table> | <location>
@@ -4579,18 +4579,76 @@ impl fmt::Display for Statement {
                 if !legacy_options.is_empty() {
                     write!(f, " {}", display_separated(legacy_options, " "))?;
                 }
+
+                let mut null_symbol = "\\N";
+                let mut writer_builder = csv::WriterBuilder::new();
+
+                // Apply options
+                for option in options {
+                    match option {
+                        CopyOption::Delimiter(c) => {
+                            writer_builder.delimiter(*c as u8);
+                        }
+                        CopyOption::Quote(c) => {
+                            writer_builder.quote(*c as u8);
+                        }
+                        CopyOption::Escape(c) => {
+                            writer_builder.escape(*c as u8);
+                        }
+                        CopyOption::Null(null) => {
+                            null_symbol = null;
+                        }
+                        _ => {}
+                    }
+                }
+
+                // Apply legacy options
+                for option in legacy_options {
+                    match option {
+                        CopyLegacyOption::Delimiter(c) => {
+                            writer_builder.delimiter(*c as u8);
+                        }
+                        CopyLegacyOption::Header => {
+                            writer_builder.has_headers(true);
+                        }
+                        CopyLegacyOption::Null(null) => {
+                            null_symbol = null;
+                        }
+                        CopyLegacyOption::Csv(csv_options) => {
+                            for csv_option in csv_options {
+                                match csv_option {
+                                    CopyLegacyCsvOption::Header => {
+                                        writer_builder.has_headers(true);
+                                    }
+                                    CopyLegacyCsvOption::Quote(c) => {
+                                        writer_builder.quote(*c as u8);
+                                    }
+                                    CopyLegacyCsvOption::Escape(c) => {
+                                        writer_builder.escape(*c as u8);
+                                    }
+                                    _ => {}
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+
                 if !values.is_empty() {
                     writeln!(f, ";")?;
-                    let mut delim = "";
-                    for v in values {
-                        write!(f, "{delim}")?;
-                        delim = "\t";
-                        if let Some(v) = v {
-                            write!(f, "{v}")?;
-                        } else {
-                            write!(f, "\\N")?;
-                        }
+                    let mut writer = writer_builder.from_writer(vec![]);
+                    for row in values {
+                        writer
+                            .write_record(
+                                row.iter()
+                                    .map(|column| column.as_deref().unwrap_or(null_symbol)),
+                            )
+                            .map_err(|_| fmt::Error)?
                     }
+                    writer.flush().map_err(|_| fmt::Error)?;
+                    let data = String::from_utf8(writer.into_inner().map_err(|_| fmt::Error)?)
+                        .map_err(|_| fmt::Error)?;
+                    write!(f, "{}", data)?;
                     write!(f, "\n\\.")?;
                 }
                 Ok(())

src/dialect/bigquery.rs

@@ -83,7 +83,7 @@ impl Dialect for BigQueryDialect {
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '_'
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '_' || ch == '-'
     }
 
     /// See [doc](https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#quoted_literals)

src/dialect/snowflake.rs

@@ -1049,9 +1049,9 @@ pub fn parse_create_stage(
 
 pub fn parse_stage_name_identifier(parser: &mut Parser) -> Result<Ident, ParserError> {
     let mut ident = String::new();
-    while let Some(next_token) = parser.next_token_no_skip() {
-        match &next_token.token {
-            Token::SemiColon => break,
+    loop {
+        match &parser.next_token().token {
+            Token::SemiColon | Token::EOF => break,
             Token::Period => {
                 parser.prev_token();
                 break;