iffyio commented on code in PR #1747:
URL:
https://github.com/apache/datafusion-sqlparser-rs/pull/1747#discussion_r2067864705
##########
src/ast/helpers/stmt_create_table.rs:
##########
@@ -76,27 +78,20 @@ pub struct CreateTableBuilder {
pub constraints: Vec<TableConstraint>,
pub hive_distribution: HiveDistributionStyle,
pub hive_formats: Option<HiveFormat>,
- pub table_properties: Vec<SqlOption>,
- pub with_options: Vec<SqlOption>,
pub file_format: Option<FileFormat>,
pub location: Option<String>,
pub query: Option<Box<Query>>,
pub without_rowid: bool,
pub like: Option<ObjectName>,
pub clone: Option<ObjectName>,
- pub engine: Option<TableEngine>,
- pub comment: Option<CommentDef>,
- pub auto_increment_offset: Option<u32>,
- pub default_charset: Option<String>,
- pub collation: Option<String>,
+ pub comment_after_column_def: Option<CommentDef>,
Review Comment:
can we call it plainly `comment` as previously or was there a requirement
for the naming?
##########
src/ast/mod.rs:
##########
@@ -8543,27 +8617,13 @@ impl Display for CreateViewParams {
}
}
-/// Engine of DB. Some warehouse has parameters of engine, e.g. [clickhouse]
-///
-/// [clickhouse]: https://clickhouse.com/docs/en/engines/table-engines
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct TableEngine {
- pub name: String,
- pub parameters: Option<Vec<Ident>>,
-}
-
-impl Display for TableEngine {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", self.name)?;
-
- if let Some(parameters) = self.parameters.as_ref() {
- write!(f, "({})", display_comma_separated(parameters))?;
- }
-
- Ok(())
- }
+pub struct NamedParenthesizedList {
Review Comment:
Can we add a doc comment with an example of what the option looks like? in
order to illustrate what the fields of the struct map to as well
##########
src/ast/mod.rs:
##########
@@ -7289,6 +7310,16 @@ pub enum SqlOption {
range_direction: Option<PartitionRangeDirection>,
for_values: Vec<Expr>,
},
+
+ Comment(CommentDef),
+
+ TableSpace(TablespaceOption),
Review Comment:
Can we add descriptions for these variants, also it would be good at least
with the tablespace version to link to the docs where the option comes from?
##########
src/ast/mod.rs:
##########
@@ -8543,27 +8617,13 @@ impl Display for CreateViewParams {
}
}
-/// Engine of DB. Some warehouse has parameters of engine, e.g. [clickhouse]
-///
-/// [clickhouse]: https://clickhouse.com/docs/en/engines/table-engines
#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct TableEngine {
- pub name: String,
- pub parameters: Option<Vec<Ident>>,
-}
-
-impl Display for TableEngine {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}", self.name)?;
-
- if let Some(parameters) = self.parameters.as_ref() {
- write!(f, "({})", display_comma_separated(parameters))?;
- }
-
- Ok(())
- }
+pub struct NamedParenthesizedList {
+ pub key: Ident,
+ pub value: Option<Ident>,
+ pub parameters: Vec<Ident>,
Review Comment:
hmm not sure re the naming of the properties, they don't hint anything being
named as the `NamedParenthesizeList` suggest and the parameters property is
essentially a list of values as well so that the current struct is declaring a
`value` and `values` which feels odd. maybe replacing `value` with `name`, and
`parameters` with `values` would make more sense? Since currently if `value` is
None, then the `Vec` isn't representing parameters for that option, rather a
plain list of values
##########
src/parser/mod.rs:
##########
@@ -7082,18 +7030,252 @@ impl<'a> Parser<'a> {
if let Token::Word(word) = self.peek_token().token {
if word.keyword == Keyword::OPTIONS {
- options = Some(self.parse_options(Keyword::OPTIONS)?);
+ table_options =
+
CreateTableOptions::Options(self.parse_options(Keyword::OPTIONS)?)
}
};
}
+ if !dialect_of!(self is HiveDialect) && table_options ==
CreateTableOptions::None {
+ let plain_options = self.parse_plain_options()?;
+ if !plain_options.is_empty() {
+ table_options = CreateTableOptions::Plain(plain_options)
+ }
+ };
+
Ok(CreateTableConfiguration {
partition_by,
cluster_by,
- options,
+ table_options,
})
}
+ fn parse_plain_option(&mut self) -> Result<Option<SqlOption>, ParserError>
{
+ // Single parameter option
+ if self.parse_keywords(&[Keyword::START, Keyword::TRANSACTION]) {
+ return Ok(Some(SqlOption::Ident(Ident::new("START TRANSACTION"))));
+ }
+
+ // Custom option
+ if self.parse_keywords(&[Keyword::COMMENT]) {
+ let has_eq = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let comment = match (has_eq, value.token) {
+ (true, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithEq(s))))
+ }
+ (false, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithoutEq(s))))
+ }
+ (_, token) => {
+ self.expected("Token::SingleQuotedString",
TokenWithSpan::wrap(token))
+ }
+ };
+ return comment;
+ }
+
+ if self.parse_keywords(&[Keyword::ENGINE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let engine = match value.token {
+ Token::Word(w) => {
+ let parameters = if self.peek_token() == Token::LParen {
+ self.parse_parenthesized_identifiers()?
+ } else {
+ vec![]
+ };
+
+ Ok(Some(SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("ENGINE"),
+ value: Some(Ident::new(w.value)),
+ parameters,
+ },
+ )))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return engine;
+ }
+
+ if self.parse_keywords(&[Keyword::TABLESPACE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let tablespace = match value.token {
+ // TABLESPACE tablespace_name [STORAGE DISK] | [TABLESPACE
tablespace_name] STORAGE MEMORY
+ Token::Word(Word { value: name, .. }) |
Token::SingleQuotedString(name) => {
+ let storage = match self.parse_keyword(Keyword::STORAGE) {
+ true => {
+ let _ = self.consume_token(&Token::Eq);
+ let storage_token = self.next_token();
+ match &storage_token.token {
+ Token::Word(w) => match
w.value.to_uppercase().as_str() {
+ "DISK" => Some(StorageType::Disk),
+ "MEMORY" => Some(StorageType::Memory),
+ _ => self
+ .expected("Storage type (DISK or
MEMORY)", storage_token)?,
+ },
+ _ => self.expected("Token::Word",
storage_token)?,
+ }
+ }
+ false => None,
+ };
+
+ Ok(Some(SqlOption::TableSpace(TablespaceOption {
+ name,
+ storage,
+ })))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return tablespace;
+ }
+
+ if self.parse_keyword(Keyword::UNION) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ match value.token {
+ // UNION [=] (tbl_name[,tbl_name]...)
Review Comment:
Can we also mention where this syntax comes from?
##########
tests/sqlparser_mysql.rs:
##########
@@ -859,29 +873,276 @@ fn parse_create_table_comment() {
#[test]
fn parse_create_table_auto_increment_offset() {
- let canonical =
- "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE=InnoDB
AUTO_INCREMENT 123";
- let with_equal =
- "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE=InnoDB
AUTO_INCREMENT=123";
+ let sql =
+ "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE = InnoDB
AUTO_INCREMENT = 123";
+
+ match mysql().verified_stmt(sql) {
+ Statement::CreateTable(CreateTable {
+ name,
+ table_options,
+ ..
+ }) => {
+ assert_eq!(name.to_string(), "foo");
+
+ let plain_options = match table_options {
+ CreateTableOptions::Plain(options) => options,
+ _ => unreachable!(),
+ };
+
+ assert!(plain_options.contains(&SqlOption::KeyValue {
+ key: Ident::new("AUTO_INCREMENT"),
+ value: Expr::Value(
+ Value::Number(
+ Parser::parse("123".to_owned(),
Location::empty()).unwrap(),
+ false
+ )
+ .into()
+ )
+ }));
+ }
+ _ => unreachable!(),
+ }
+}
+
+#[test]
+fn parse_create_table_multiple_options_order_independent() {
+ let sql1 = "CREATE TABLE mytable (id INT) ENGINE=InnoDB ROW_FORMAT=DYNAMIC
KEY_BLOCK_SIZE=8 COMMENT='abc'";
+ let sql2 = "CREATE TABLE mytable (id INT) KEY_BLOCK_SIZE=8 COMMENT='abc'
ENGINE=InnoDB ROW_FORMAT=DYNAMIC";
+ let sql3 = "CREATE TABLE mytable (id INT) ROW_FORMAT=DYNAMIC
KEY_BLOCK_SIZE=8 COMMENT='abc' ENGINE=InnoDB";
- for sql in [canonical, with_equal] {
- match mysql().one_statement_parses_to(sql, canonical) {
+ for sql in [sql1, sql2, sql3] {
+ match mysql().parse_sql_statements(sql).unwrap().pop().unwrap() {
Statement::CreateTable(CreateTable {
name,
- auto_increment_offset,
+ table_options,
..
}) => {
- assert_eq!(name.to_string(), "foo");
- assert_eq!(
- auto_increment_offset.expect("Should exist").to_string(),
- "123"
- );
+ assert_eq!(name.to_string(), "mytable");
+
+ let plain_options = match table_options {
+ CreateTableOptions::Plain(options) => options,
+ _ => unreachable!(),
+ };
+
+
assert!(plain_options.contains(&SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("ENGINE"),
+ value: Some(Ident::new("InnoDB")),
+ parameters: vec![]
+ }
+ )));
+
+ assert!(plain_options.contains(&SqlOption::KeyValue {
+ key: Ident::new("KEY_BLOCK_SIZE"),
+ value: Expr::Value(
+ Value::Number(
+ Parser::parse("8".to_owned(),
Location::empty()).unwrap(),
+ false
+ )
+ .into()
+ )
+ }));
+
+ assert!(plain_options
+
.contains(&SqlOption::Comment(CommentDef::WithEq("abc".to_owned()))));
+
+ assert!(plain_options.contains(&SqlOption::KeyValue {
+ key: Ident::new("ROW_FORMAT"),
+ value: Expr::Identifier(Ident::new("DYNAMIC".to_owned()))
+ }));
}
_ => unreachable!(),
}
}
}
+#[test]
+fn parse_create_table_with_all_table_options() {
+ let sql =
+ "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE = InnoDB
AUTO_INCREMENT = 123 DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci
INSERT_METHOD = FIRST KEY_BLOCK_SIZE = 8 ROW_FORMAT = DYNAMIC DATA DIRECTORY =
'/var/lib/mysql/data' INDEX DIRECTORY = '/var/lib/mysql/index' PACK_KEYS = 1
STATS_AUTO_RECALC = 1 STATS_PERSISTENT = 0 STATS_SAMPLE_PAGES = 128
DELAY_KEY_WRITE = 1 COMPRESSION = 'ZLIB' ENCRYPTION = 'Y' MAX_ROWS = 10000
MIN_ROWS = 10 AUTOEXTEND_SIZE = 64 AVG_ROW_LENGTH = 128 CHECKSUM = 1 CONNECTION
= 'mysql://localhost' ENGINE_ATTRIBUTE = 'primary' PASSWORD = 'secure_password'
SECONDARY_ENGINE_ATTRIBUTE = 'secondary_attr' START TRANSACTION TABLESPACE
my_tablespace STORAGE DISK UNION = (table1, table2, table3)";
+
+ let x = mysql().verified_stmt(sql);
Review Comment:
```suggestion
```
given the match version below is identical
##########
src/parser/mod.rs:
##########
@@ -4217,7 +4217,7 @@ impl<'a> Parser<'a> {
}
}
- fn parse<T: FromStr>(s: String, loc: Location) -> Result<T, ParserError>
+ pub fn parse<T: FromStr>(s: String, loc: Location) -> Result<T,
ParserError>
Review Comment:
```suggestion
fn parse<T: FromStr>(s: String, loc: Location) -> Result<T, ParserError>
```
was there a requirement for this change to pub? if needed elsewhere inthe
crate we can use `pub(crate)``instead
##########
src/ast/mod.rs:
##########
@@ -7320,10 +7351,53 @@ impl fmt::Display for SqlOption {
display_comma_separated(for_values)
)
}
+ SqlOption::TableSpace(tablespace_option) => {
+ write!(f, "TABLESPACE {}", tablespace_option.name)?;
+ match tablespace_option.storage {
+ Some(StorageType::Disk) => write!(f, " STORAGE DISK"),
+ Some(StorageType::Memory) => write!(f, " STORAGE MEMORY"),
+ _ => Ok(()),
Review Comment:
```suggestion
None => Ok(()),
```
##########
src/ast/mod.rs:
##########
@@ -7289,6 +7310,16 @@ pub enum SqlOption {
range_direction: Option<PartitionRangeDirection>,
for_values: Vec<Expr>,
},
+
+ Comment(CommentDef),
+
+ TableSpace(TablespaceOption),
+
+ // Advanced parameter formations
+ // UNION = (tbl_name[,tbl_name]...)
+ // ENGINE = ReplicatedMergeTree('/table_name','{replica}', ver)
+ // ENGINE = SummingMergeTree([columns])
Review Comment:
```suggestion
/// An option representing a key value pair, where the value is a
parenthesized list and with an optional name.
///
/// ```sql
/// UNION = (table1, table2)
/// ENGINE = ReplicatedMergeTree('/table_name','{replica}', ver)
/// ENGINE = SummingMergeTree(column1, column2)
/// ```
```
##########
src/ast/mod.rs:
##########
@@ -7320,10 +7351,53 @@ impl fmt::Display for SqlOption {
display_comma_separated(for_values)
)
}
+ SqlOption::TableSpace(tablespace_option) => {
+ write!(f, "TABLESPACE {}", tablespace_option.name)?;
+ match tablespace_option.storage {
+ Some(StorageType::Disk) => write!(f, " STORAGE DISK"),
+ Some(StorageType::Memory) => write!(f, " STORAGE MEMORY"),
+ _ => Ok(()),
+ }
+ }
+
Review Comment:
```suggestion
```
##########
src/ast/mod.rs:
##########
@@ -7320,10 +7351,53 @@ impl fmt::Display for SqlOption {
display_comma_separated(for_values)
)
}
+ SqlOption::TableSpace(tablespace_option) => {
+ write!(f, "TABLESPACE {}", tablespace_option.name)?;
+ match tablespace_option.storage {
+ Some(StorageType::Disk) => write!(f, " STORAGE DISK"),
+ Some(StorageType::Memory) => write!(f, " STORAGE MEMORY"),
+ _ => Ok(()),
+ }
+ }
+
+ SqlOption::Comment(comment) => match comment {
+ CommentDef::WithEq(comment) => {
+ write!(f, "COMMENT = '{comment}'")
+ }
+ CommentDef::WithoutEq(comment) => {
+ write!(f, "COMMENT '{comment}'")
+ }
+ },
+ SqlOption::NamedParenthesizedList(value) => {
+ write!(f, "{} = ", value.key)?;
+ if let Some(key) = &value.value {
+ write!(f, "{}", key)?;
+ }
+ if !value.parameters.is_empty() {
+ write!(f, "({})",
display_comma_separated(&value.parameters))?
+ }
+ Ok(())
+ }
}
}
}
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum StorageType {
+ Disk,
+ Memory,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
Review Comment:
Can we add a description and link to the docs?
##########
src/parser/mod.rs:
##########
@@ -7082,18 +7030,252 @@ impl<'a> Parser<'a> {
if let Token::Word(word) = self.peek_token().token {
if word.keyword == Keyword::OPTIONS {
- options = Some(self.parse_options(Keyword::OPTIONS)?);
+ table_options =
+
CreateTableOptions::Options(self.parse_options(Keyword::OPTIONS)?)
}
};
}
+ if !dialect_of!(self is HiveDialect) && table_options ==
CreateTableOptions::None {
+ let plain_options = self.parse_plain_options()?;
+ if !plain_options.is_empty() {
+ table_options = CreateTableOptions::Plain(plain_options)
+ }
+ };
+
Ok(CreateTableConfiguration {
partition_by,
cluster_by,
- options,
+ table_options,
})
}
+ fn parse_plain_option(&mut self) -> Result<Option<SqlOption>, ParserError>
{
+ // Single parameter option
+ if self.parse_keywords(&[Keyword::START, Keyword::TRANSACTION]) {
Review Comment:
Can we include a link to where this syntax comes from?
##########
src/parser/mod.rs:
##########
@@ -7082,18 +7030,252 @@ impl<'a> Parser<'a> {
if let Token::Word(word) = self.peek_token().token {
if word.keyword == Keyword::OPTIONS {
- options = Some(self.parse_options(Keyword::OPTIONS)?);
+ table_options =
+
CreateTableOptions::Options(self.parse_options(Keyword::OPTIONS)?)
}
};
}
+ if !dialect_of!(self is HiveDialect) && table_options ==
CreateTableOptions::None {
+ let plain_options = self.parse_plain_options()?;
+ if !plain_options.is_empty() {
+ table_options = CreateTableOptions::Plain(plain_options)
+ }
+ };
+
Ok(CreateTableConfiguration {
partition_by,
cluster_by,
- options,
+ table_options,
})
}
+ fn parse_plain_option(&mut self) -> Result<Option<SqlOption>, ParserError>
{
+ // Single parameter option
+ if self.parse_keywords(&[Keyword::START, Keyword::TRANSACTION]) {
+ return Ok(Some(SqlOption::Ident(Ident::new("START TRANSACTION"))));
+ }
+
+ // Custom option
+ if self.parse_keywords(&[Keyword::COMMENT]) {
+ let has_eq = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let comment = match (has_eq, value.token) {
+ (true, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithEq(s))))
+ }
+ (false, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithoutEq(s))))
+ }
+ (_, token) => {
+ self.expected("Token::SingleQuotedString",
TokenWithSpan::wrap(token))
+ }
+ };
+ return comment;
+ }
+
+ if self.parse_keywords(&[Keyword::ENGINE]) {
Review Comment:
Can we include a link to where this syntax comes from?
##########
src/parser/mod.rs:
##########
@@ -7082,18 +7030,252 @@ impl<'a> Parser<'a> {
if let Token::Word(word) = self.peek_token().token {
if word.keyword == Keyword::OPTIONS {
- options = Some(self.parse_options(Keyword::OPTIONS)?);
+ table_options =
+
CreateTableOptions::Options(self.parse_options(Keyword::OPTIONS)?)
}
};
}
+ if !dialect_of!(self is HiveDialect) && table_options ==
CreateTableOptions::None {
+ let plain_options = self.parse_plain_options()?;
+ if !plain_options.is_empty() {
+ table_options = CreateTableOptions::Plain(plain_options)
+ }
+ };
+
Ok(CreateTableConfiguration {
partition_by,
cluster_by,
- options,
+ table_options,
})
}
+ fn parse_plain_option(&mut self) -> Result<Option<SqlOption>, ParserError>
{
+ // Single parameter option
+ if self.parse_keywords(&[Keyword::START, Keyword::TRANSACTION]) {
+ return Ok(Some(SqlOption::Ident(Ident::new("START TRANSACTION"))));
+ }
+
+ // Custom option
+ if self.parse_keywords(&[Keyword::COMMENT]) {
+ let has_eq = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let comment = match (has_eq, value.token) {
+ (true, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithEq(s))))
+ }
+ (false, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithoutEq(s))))
+ }
+ (_, token) => {
+ self.expected("Token::SingleQuotedString",
TokenWithSpan::wrap(token))
+ }
+ };
+ return comment;
+ }
+
+ if self.parse_keywords(&[Keyword::ENGINE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let engine = match value.token {
+ Token::Word(w) => {
+ let parameters = if self.peek_token() == Token::LParen {
+ self.parse_parenthesized_identifiers()?
+ } else {
+ vec![]
+ };
+
+ Ok(Some(SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("ENGINE"),
+ value: Some(Ident::new(w.value)),
+ parameters,
+ },
+ )))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return engine;
+ }
+
+ if self.parse_keywords(&[Keyword::TABLESPACE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let tablespace = match value.token {
+ // TABLESPACE tablespace_name [STORAGE DISK] | [TABLESPACE
tablespace_name] STORAGE MEMORY
+ Token::Word(Word { value: name, .. }) |
Token::SingleQuotedString(name) => {
+ let storage = match self.parse_keyword(Keyword::STORAGE) {
+ true => {
+ let _ = self.consume_token(&Token::Eq);
+ let storage_token = self.next_token();
+ match &storage_token.token {
+ Token::Word(w) => match
w.value.to_uppercase().as_str() {
+ "DISK" => Some(StorageType::Disk),
+ "MEMORY" => Some(StorageType::Memory),
+ _ => self
+ .expected("Storage type (DISK or
MEMORY)", storage_token)?,
+ },
+ _ => self.expected("Token::Word",
storage_token)?,
+ }
+ }
+ false => None,
+ };
+
+ Ok(Some(SqlOption::TableSpace(TablespaceOption {
+ name,
+ storage,
+ })))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return tablespace;
+ }
+
+ if self.parse_keyword(Keyword::UNION) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ match value.token {
+ // UNION [=] (tbl_name[,tbl_name]...)
+ Token::LParen => {
+ let tables: Vec<Ident> =
+ self.parse_comma_separated0(Parser::parse_identifier,
Token::RParen)?;
+ self.expect_token(&Token::RParen)?;
+
+ return Ok(Some(SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("UNION"),
+ value: None,
+ parameters: tables,
+ },
+ )));
+ }
+ _ => {
+ return self.expected("Token::LParen", value)?;
+ }
+ }
+ }
+
+ // Key/Value parameter option
+ let key = if self.parse_keywords(&[Keyword::DEFAULT,
Keyword::CHARSET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("DEFAULT CHARSET")
+ } else if self.parse_keyword(Keyword::CHARSET) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("CHARSET")
+ } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::CHARACTER,
Keyword::SET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("DEFAULT CHARACTER SET")
+ } else if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("CHARACTER SET")
+ } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::COLLATE]) {
+ // [DEFAULT] COLLATE [=] collation_name
Review Comment:
```suggestion
// [DEFAULT] CHARACTER SET [=] charset_name
Ident::new("DEFAULT CHARSET")
} else if self.parse_keyword(Keyword::CHARSET) {
// [DEFAULT] CHARACTER SET [=] charset_name
Ident::new("CHARSET")
} else if self.parse_keywords(&[Keyword::DEFAULT,
Keyword::CHARACTER, Keyword::SET]) {
Ident::new("DEFAULT CHARACTER SET")
} else if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) {
Ident::new("CHARACTER SET")
} else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::COLLATE])
{
```
similar for the others, I think we can skip the comments describing grammar
for the key and value. Since the value doesn't affect the parser, and the key
is already being described by the parse_keywords function call.
On a related note, I think its important if we can find a way to flag the
documentation to mysql for the applicable options, ideally without mentioning
it per-option but maybe that's the easiest way if the sources across the
options are mixed
##########
src/parser/mod.rs:
##########
@@ -7082,18 +7030,252 @@ impl<'a> Parser<'a> {
if let Token::Word(word) = self.peek_token().token {
if word.keyword == Keyword::OPTIONS {
- options = Some(self.parse_options(Keyword::OPTIONS)?);
+ table_options =
+
CreateTableOptions::Options(self.parse_options(Keyword::OPTIONS)?)
}
};
}
+ if !dialect_of!(self is HiveDialect) && table_options ==
CreateTableOptions::None {
+ let plain_options = self.parse_plain_options()?;
+ if !plain_options.is_empty() {
+ table_options = CreateTableOptions::Plain(plain_options)
+ }
+ };
+
Ok(CreateTableConfiguration {
partition_by,
cluster_by,
- options,
+ table_options,
})
}
+ fn parse_plain_option(&mut self) -> Result<Option<SqlOption>, ParserError>
{
+ // Single parameter option
+ if self.parse_keywords(&[Keyword::START, Keyword::TRANSACTION]) {
+ return Ok(Some(SqlOption::Ident(Ident::new("START TRANSACTION"))));
+ }
+
+ // Custom option
+ if self.parse_keywords(&[Keyword::COMMENT]) {
+ let has_eq = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let comment = match (has_eq, value.token) {
+ (true, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithEq(s))))
+ }
+ (false, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithoutEq(s))))
+ }
+ (_, token) => {
+ self.expected("Token::SingleQuotedString",
TokenWithSpan::wrap(token))
+ }
+ };
+ return comment;
+ }
+
+ if self.parse_keywords(&[Keyword::ENGINE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let engine = match value.token {
+ Token::Word(w) => {
+ let parameters = if self.peek_token() == Token::LParen {
+ self.parse_parenthesized_identifiers()?
+ } else {
+ vec![]
+ };
+
+ Ok(Some(SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("ENGINE"),
+ value: Some(Ident::new(w.value)),
+ parameters,
+ },
+ )))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return engine;
+ }
+
+ if self.parse_keywords(&[Keyword::TABLESPACE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let tablespace = match value.token {
+ // TABLESPACE tablespace_name [STORAGE DISK] | [TABLESPACE
tablespace_name] STORAGE MEMORY
+ Token::Word(Word { value: name, .. }) |
Token::SingleQuotedString(name) => {
+ let storage = match self.parse_keyword(Keyword::STORAGE) {
+ true => {
+ let _ = self.consume_token(&Token::Eq);
+ let storage_token = self.next_token();
+ match &storage_token.token {
+ Token::Word(w) => match
w.value.to_uppercase().as_str() {
+ "DISK" => Some(StorageType::Disk),
+ "MEMORY" => Some(StorageType::Memory),
+ _ => self
+ .expected("Storage type (DISK or
MEMORY)", storage_token)?,
+ },
+ _ => self.expected("Token::Word",
storage_token)?,
+ }
+ }
+ false => None,
+ };
+
+ Ok(Some(SqlOption::TableSpace(TablespaceOption {
+ name,
+ storage,
+ })))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return tablespace;
+ }
+
+ if self.parse_keyword(Keyword::UNION) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ match value.token {
+ // UNION [=] (tbl_name[,tbl_name]...)
+ Token::LParen => {
+ let tables: Vec<Ident> =
+ self.parse_comma_separated0(Parser::parse_identifier,
Token::RParen)?;
+ self.expect_token(&Token::RParen)?;
+
+ return Ok(Some(SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("UNION"),
+ value: None,
+ parameters: tables,
+ },
+ )));
+ }
+ _ => {
+ return self.expected("Token::LParen", value)?;
+ }
+ }
+ }
+
+ // Key/Value parameter option
+ let key = if self.parse_keywords(&[Keyword::DEFAULT,
Keyword::CHARSET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("DEFAULT CHARSET")
+ } else if self.parse_keyword(Keyword::CHARSET) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("CHARSET")
+ } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::CHARACTER,
Keyword::SET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("DEFAULT CHARACTER SET")
+ } else if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("CHARACTER SET")
+ } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::COLLATE]) {
+ // [DEFAULT] COLLATE [=] collation_name
+ Ident::new("DEFAULT COLLATE")
+ } else if self.parse_keyword(Keyword::COLLATE) {
+ // [DEFAULT] COLLATE [=] collation_name
+ Ident::new("COLLATE")
+ } else if self.parse_keywords(&[Keyword::DATA, Keyword::DIRECTORY]) {
+ // {DATA | INDEX} DIRECTORY [=] 'absolute path to directory'
+ Ident::new("DATA DIRECTORY")
+ } else if self.parse_keywords(&[Keyword::INDEX, Keyword::DIRECTORY]) {
+ // {DATA | INDEX} DIRECTORY [=] 'absolute path to directory'
+ Ident::new("INDEX DIRECTORY")
+ } else if self.parse_keyword(Keyword::KEY_BLOCK_SIZE) {
+ // KEY_BLOCK_SIZE [=] value
+ Ident::new("KEY_BLOCK_SIZE")
+ } else if self.parse_keyword(Keyword::ROW_FORMAT) {
+ // ROW_FORMAT [=] {DEFAULT | DYNAMIC | FIXED | COMPRESSED |
REDUNDANT | COMPACT}
+ Ident::new("ROW_FORMAT")
+ } else if self.parse_keyword(Keyword::PACK_KEYS) {
+ // PACK_KEYS [=] {0 | 1 | DEFAULT}
+ Ident::new("PACK_KEYS")
+ } else if self.parse_keyword(Keyword::STATS_AUTO_RECALC) {
+ // STATS_AUTO_RECALC [=] {DEFAULT | 0 | 1}
+ Ident::new("STATS_AUTO_RECALC")
+ } else if self.parse_keyword(Keyword::STATS_PERSISTENT) {
+ //STATS_PERSISTENT [=] {DEFAULT | 0 | 1}
+ Ident::new("STATS_PERSISTENT")
+ } else if self.parse_keyword(Keyword::STATS_SAMPLE_PAGES) {
+ // STATS_SAMPLE_PAGES [=] value
+ Ident::new("STATS_SAMPLE_PAGES")
+ } else if self.parse_keyword(Keyword::DELAY_KEY_WRITE) {
+ // DELAY_KEY_WRITE [=] {0 | 1}
+ Ident::new("DELAY_KEY_WRITE")
+ } else if self.parse_keyword(Keyword::COMPRESSION) {
+ // COMPRESSION [=] {'ZLIB' | 'LZ4' | 'NONE'}
+ Ident::new("COMPRESSION")
+ } else if self.parse_keyword(Keyword::ENCRYPTION) {
+ // ENCRYPTION [=] {'Y' | 'N'}
+ Ident::new("ENCRYPTION")
+ } else if self.parse_keyword(Keyword::MAX_ROWS) {
+ // MAX_ROWS [=] value
+ Ident::new("MAX_ROWS")
+ } else if self.parse_keyword(Keyword::MIN_ROWS) {
+ // MIN_ROWS [=] value
+ Ident::new("MIN_ROWS")
+ } else if self.parse_keyword(Keyword::AUTOEXTEND_SIZE) {
+ // AUTOEXTEND_SIZE [=] value
+ Ident::new("AUTOEXTEND_SIZE")
+ } else if self.parse_keyword(Keyword::AVG_ROW_LENGTH) {
+ // AVG_ROW_LENGTH [=] value
+ Ident::new("AVG_ROW_LENGTH")
+ } else if self.parse_keyword(Keyword::CHECKSUM) {
+ // CHECKSUM [=] {0 | 1}
+ Ident::new("CHECKSUM")
+ } else if self.parse_keyword(Keyword::CONNECTION) {
+ // CONNECTION [=] 'connect_string'
+ Ident::new("CONNECTION")
+ } else if self.parse_keyword(Keyword::ENGINE_ATTRIBUTE) {
+ // ENGINE_ATTRIBUTE [=] 'string'
+ Ident::new("ENGINE_ATTRIBUTE")
+ } else if self.parse_keyword(Keyword::PASSWORD) {
+ // PASSWORD [=] 'string'
+ Ident::new("PASSWORD")
+ } else if self.parse_keyword(Keyword::SECONDARY_ENGINE_ATTRIBUTE) {
+ // SECONDARY_ENGINE_ATTRIBUTE [=] 'string'
+ Ident::new("SECONDARY_ENGINE_ATTRIBUTE")
+ } else if self.parse_keyword(Keyword::INSERT_METHOD) {
+ // INSERT_METHOD [=] { NO | FIRST | LAST }
+ Ident::new("INSERT_METHOD")
+ } else if self.parse_keyword(Keyword::AUTO_INCREMENT) {
+ Ident::new("AUTO_INCREMENT")
+ } else {
+ return Ok(None);
+ };
+
+ let _ = self.consume_token(&Token::Eq);
+
+ let value = match self
+ .maybe_parse(|parser| parser.parse_value())?
+ .map(Expr::Value)
+ {
+ Some(expr) => expr,
+ None => Expr::Identifier(self.parse_identifier()?),
+ };
+
+ Ok(Some(SqlOption::KeyValue { key, value }))
+ }
+
+ pub fn parse_plain_options(&mut self) -> Result<Vec<SqlOption>,
ParserError> {
Review Comment:
```suggestion
fn parse_plain_options(&mut self) -> Result<Vec<SqlOption>, ParserError>
{
```
##########
src/parser/mod.rs:
##########
@@ -7082,18 +7030,252 @@ impl<'a> Parser<'a> {
if let Token::Word(word) = self.peek_token().token {
if word.keyword == Keyword::OPTIONS {
- options = Some(self.parse_options(Keyword::OPTIONS)?);
+ table_options =
+
CreateTableOptions::Options(self.parse_options(Keyword::OPTIONS)?)
}
};
}
+ if !dialect_of!(self is HiveDialect) && table_options ==
CreateTableOptions::None {
+ let plain_options = self.parse_plain_options()?;
+ if !plain_options.is_empty() {
+ table_options = CreateTableOptions::Plain(plain_options)
+ }
+ };
+
Ok(CreateTableConfiguration {
partition_by,
cluster_by,
- options,
+ table_options,
})
}
+ fn parse_plain_option(&mut self) -> Result<Option<SqlOption>, ParserError>
{
+ // Single parameter option
+ if self.parse_keywords(&[Keyword::START, Keyword::TRANSACTION]) {
+ return Ok(Some(SqlOption::Ident(Ident::new("START TRANSACTION"))));
+ }
+
+ // Custom option
+ if self.parse_keywords(&[Keyword::COMMENT]) {
+ let has_eq = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let comment = match (has_eq, value.token) {
+ (true, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithEq(s))))
+ }
+ (false, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithoutEq(s))))
+ }
+ (_, token) => {
+ self.expected("Token::SingleQuotedString",
TokenWithSpan::wrap(token))
+ }
+ };
+ return comment;
+ }
+
+ if self.parse_keywords(&[Keyword::ENGINE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let engine = match value.token {
+ Token::Word(w) => {
+ let parameters = if self.peek_token() == Token::LParen {
+ self.parse_parenthesized_identifiers()?
+ } else {
+ vec![]
+ };
+
+ Ok(Some(SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("ENGINE"),
+ value: Some(Ident::new(w.value)),
+ parameters,
+ },
+ )))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return engine;
+ }
+
+ if self.parse_keywords(&[Keyword::TABLESPACE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let tablespace = match value.token {
+ // TABLESPACE tablespace_name [STORAGE DISK] | [TABLESPACE
tablespace_name] STORAGE MEMORY
Review Comment:
Can we include a link to where the syntax comes from?
##########
tests/sqlparser_mysql.rs:
##########
@@ -859,29 +873,276 @@ fn parse_create_table_comment() {
#[test]
fn parse_create_table_auto_increment_offset() {
- let canonical =
- "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE=InnoDB
AUTO_INCREMENT 123";
- let with_equal =
- "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE=InnoDB
AUTO_INCREMENT=123";
+ let sql =
+ "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE = InnoDB
AUTO_INCREMENT = 123";
+
+ match mysql().verified_stmt(sql) {
+ Statement::CreateTable(CreateTable {
+ name,
+ table_options,
+ ..
+ }) => {
+ assert_eq!(name.to_string(), "foo");
+
+ let plain_options = match table_options {
+ CreateTableOptions::Plain(options) => options,
+ _ => unreachable!(),
+ };
+
+ assert!(plain_options.contains(&SqlOption::KeyValue {
+ key: Ident::new("AUTO_INCREMENT"),
+ value: Expr::Value(
+ Value::Number(
+ Parser::parse("123".to_owned(),
Location::empty()).unwrap(),
+ false
+ )
+ .into()
+ )
+ }));
+ }
+ _ => unreachable!(),
+ }
+}
+
+#[test]
+fn parse_create_table_multiple_options_order_independent() {
+ let sql1 = "CREATE TABLE mytable (id INT) ENGINE=InnoDB ROW_FORMAT=DYNAMIC
KEY_BLOCK_SIZE=8 COMMENT='abc'";
+ let sql2 = "CREATE TABLE mytable (id INT) KEY_BLOCK_SIZE=8 COMMENT='abc'
ENGINE=InnoDB ROW_FORMAT=DYNAMIC";
+ let sql3 = "CREATE TABLE mytable (id INT) ROW_FORMAT=DYNAMIC
KEY_BLOCK_SIZE=8 COMMENT='abc' ENGINE=InnoDB";
- for sql in [canonical, with_equal] {
- match mysql().one_statement_parses_to(sql, canonical) {
+ for sql in [sql1, sql2, sql3] {
+ match mysql().parse_sql_statements(sql).unwrap().pop().unwrap() {
Statement::CreateTable(CreateTable {
name,
- auto_increment_offset,
+ table_options,
..
}) => {
- assert_eq!(name.to_string(), "foo");
- assert_eq!(
- auto_increment_offset.expect("Should exist").to_string(),
- "123"
- );
+ assert_eq!(name.to_string(), "mytable");
+
+ let plain_options = match table_options {
+ CreateTableOptions::Plain(options) => options,
+ _ => unreachable!(),
+ };
+
+
assert!(plain_options.contains(&SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("ENGINE"),
+ value: Some(Ident::new("InnoDB")),
+ parameters: vec![]
+ }
+ )));
+
+ assert!(plain_options.contains(&SqlOption::KeyValue {
+ key: Ident::new("KEY_BLOCK_SIZE"),
+ value: Expr::Value(
+ Value::Number(
+ Parser::parse("8".to_owned(),
Location::empty()).unwrap(),
+ false
+ )
+ .into()
+ )
+ }));
+
+ assert!(plain_options
+
.contains(&SqlOption::Comment(CommentDef::WithEq("abc".to_owned()))));
+
+ assert!(plain_options.contains(&SqlOption::KeyValue {
+ key: Ident::new("ROW_FORMAT"),
+ value: Expr::Identifier(Ident::new("DYNAMIC".to_owned()))
+ }));
}
_ => unreachable!(),
}
}
}
+#[test]
+fn parse_create_table_with_all_table_options() {
+ let sql =
+ "CREATE TABLE foo (bar INT NOT NULL AUTO_INCREMENT) ENGINE = InnoDB
AUTO_INCREMENT = 123 DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci
INSERT_METHOD = FIRST KEY_BLOCK_SIZE = 8 ROW_FORMAT = DYNAMIC DATA DIRECTORY =
'/var/lib/mysql/data' INDEX DIRECTORY = '/var/lib/mysql/index' PACK_KEYS = 1
STATS_AUTO_RECALC = 1 STATS_PERSISTENT = 0 STATS_SAMPLE_PAGES = 128
DELAY_KEY_WRITE = 1 COMPRESSION = 'ZLIB' ENCRYPTION = 'Y' MAX_ROWS = 10000
MIN_ROWS = 10 AUTOEXTEND_SIZE = 64 AVG_ROW_LENGTH = 128 CHECKSUM = 1 CONNECTION
= 'mysql://localhost' ENGINE_ATTRIBUTE = 'primary' PASSWORD = 'secure_password'
SECONDARY_ENGINE_ATTRIBUTE = 'secondary_attr' START TRANSACTION TABLESPACE
my_tablespace STORAGE DISK UNION = (table1, table2, table3)";
+
+ let x = mysql().verified_stmt(sql);
+ println!("{x:?}");
Review Comment:
```suggestion
```
##########
src/parser/mod.rs:
##########
@@ -7082,18 +7030,252 @@ impl<'a> Parser<'a> {
if let Token::Word(word) = self.peek_token().token {
if word.keyword == Keyword::OPTIONS {
- options = Some(self.parse_options(Keyword::OPTIONS)?);
+ table_options =
+
CreateTableOptions::Options(self.parse_options(Keyword::OPTIONS)?)
}
};
}
+ if !dialect_of!(self is HiveDialect) && table_options ==
CreateTableOptions::None {
+ let plain_options = self.parse_plain_options()?;
+ if !plain_options.is_empty() {
+ table_options = CreateTableOptions::Plain(plain_options)
+ }
+ };
+
Ok(CreateTableConfiguration {
partition_by,
cluster_by,
- options,
+ table_options,
})
}
+ fn parse_plain_option(&mut self) -> Result<Option<SqlOption>, ParserError>
{
+ // Single parameter option
+ if self.parse_keywords(&[Keyword::START, Keyword::TRANSACTION]) {
+ return Ok(Some(SqlOption::Ident(Ident::new("START TRANSACTION"))));
+ }
+
+ // Custom option
+ if self.parse_keywords(&[Keyword::COMMENT]) {
+ let has_eq = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let comment = match (has_eq, value.token) {
+ (true, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithEq(s))))
+ }
+ (false, Token::SingleQuotedString(s)) => {
+ Ok(Some(SqlOption::Comment(CommentDef::WithoutEq(s))))
+ }
+ (_, token) => {
+ self.expected("Token::SingleQuotedString",
TokenWithSpan::wrap(token))
+ }
+ };
+ return comment;
+ }
+
+ if self.parse_keywords(&[Keyword::ENGINE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let engine = match value.token {
+ Token::Word(w) => {
+ let parameters = if self.peek_token() == Token::LParen {
+ self.parse_parenthesized_identifiers()?
+ } else {
+ vec![]
+ };
+
+ Ok(Some(SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("ENGINE"),
+ value: Some(Ident::new(w.value)),
+ parameters,
+ },
+ )))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return engine;
+ }
+
+ if self.parse_keywords(&[Keyword::TABLESPACE]) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ let tablespace = match value.token {
+ // TABLESPACE tablespace_name [STORAGE DISK] | [TABLESPACE
tablespace_name] STORAGE MEMORY
+ Token::Word(Word { value: name, .. }) |
Token::SingleQuotedString(name) => {
+ let storage = match self.parse_keyword(Keyword::STORAGE) {
+ true => {
+ let _ = self.consume_token(&Token::Eq);
+ let storage_token = self.next_token();
+ match &storage_token.token {
+ Token::Word(w) => match
w.value.to_uppercase().as_str() {
+ "DISK" => Some(StorageType::Disk),
+ "MEMORY" => Some(StorageType::Memory),
+ _ => self
+ .expected("Storage type (DISK or
MEMORY)", storage_token)?,
+ },
+ _ => self.expected("Token::Word",
storage_token)?,
+ }
+ }
+ false => None,
+ };
+
+ Ok(Some(SqlOption::TableSpace(TablespaceOption {
+ name,
+ storage,
+ })))
+ }
+ _ => {
+ return self.expected("Token::Word", value)?;
+ }
+ };
+
+ return tablespace;
+ }
+
+ if self.parse_keyword(Keyword::UNION) {
+ let _ = self.consume_token(&Token::Eq);
+ let value = self.next_token();
+
+ match value.token {
+ // UNION [=] (tbl_name[,tbl_name]...)
+ Token::LParen => {
+ let tables: Vec<Ident> =
+ self.parse_comma_separated0(Parser::parse_identifier,
Token::RParen)?;
+ self.expect_token(&Token::RParen)?;
+
+ return Ok(Some(SqlOption::NamedParenthesizedList(
+ NamedParenthesizedList {
+ key: Ident::new("UNION"),
+ value: None,
+ parameters: tables,
+ },
+ )));
+ }
+ _ => {
+ return self.expected("Token::LParen", value)?;
+ }
+ }
+ }
+
+ // Key/Value parameter option
+ let key = if self.parse_keywords(&[Keyword::DEFAULT,
Keyword::CHARSET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("DEFAULT CHARSET")
+ } else if self.parse_keyword(Keyword::CHARSET) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("CHARSET")
+ } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::CHARACTER,
Keyword::SET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("DEFAULT CHARACTER SET")
+ } else if self.parse_keywords(&[Keyword::CHARACTER, Keyword::SET]) {
+ // [DEFAULT] CHARACTER SET [=] charset_name
+ Ident::new("CHARACTER SET")
+ } else if self.parse_keywords(&[Keyword::DEFAULT, Keyword::COLLATE]) {
+ // [DEFAULT] COLLATE [=] collation_name
+ Ident::new("DEFAULT COLLATE")
+ } else if self.parse_keyword(Keyword::COLLATE) {
+ // [DEFAULT] COLLATE [=] collation_name
+ Ident::new("COLLATE")
+ } else if self.parse_keywords(&[Keyword::DATA, Keyword::DIRECTORY]) {
+ // {DATA | INDEX} DIRECTORY [=] 'absolute path to directory'
+ Ident::new("DATA DIRECTORY")
+ } else if self.parse_keywords(&[Keyword::INDEX, Keyword::DIRECTORY]) {
+ // {DATA | INDEX} DIRECTORY [=] 'absolute path to directory'
+ Ident::new("INDEX DIRECTORY")
+ } else if self.parse_keyword(Keyword::KEY_BLOCK_SIZE) {
+ // KEY_BLOCK_SIZE [=] value
+ Ident::new("KEY_BLOCK_SIZE")
+ } else if self.parse_keyword(Keyword::ROW_FORMAT) {
+ // ROW_FORMAT [=] {DEFAULT | DYNAMIC | FIXED | COMPRESSED |
REDUNDANT | COMPACT}
+ Ident::new("ROW_FORMAT")
+ } else if self.parse_keyword(Keyword::PACK_KEYS) {
+ // PACK_KEYS [=] {0 | 1 | DEFAULT}
+ Ident::new("PACK_KEYS")
+ } else if self.parse_keyword(Keyword::STATS_AUTO_RECALC) {
+ // STATS_AUTO_RECALC [=] {DEFAULT | 0 | 1}
+ Ident::new("STATS_AUTO_RECALC")
+ } else if self.parse_keyword(Keyword::STATS_PERSISTENT) {
+ //STATS_PERSISTENT [=] {DEFAULT | 0 | 1}
+ Ident::new("STATS_PERSISTENT")
+ } else if self.parse_keyword(Keyword::STATS_SAMPLE_PAGES) {
+ // STATS_SAMPLE_PAGES [=] value
+ Ident::new("STATS_SAMPLE_PAGES")
+ } else if self.parse_keyword(Keyword::DELAY_KEY_WRITE) {
+ // DELAY_KEY_WRITE [=] {0 | 1}
+ Ident::new("DELAY_KEY_WRITE")
+ } else if self.parse_keyword(Keyword::COMPRESSION) {
+ // COMPRESSION [=] {'ZLIB' | 'LZ4' | 'NONE'}
+ Ident::new("COMPRESSION")
+ } else if self.parse_keyword(Keyword::ENCRYPTION) {
+ // ENCRYPTION [=] {'Y' | 'N'}
+ Ident::new("ENCRYPTION")
+ } else if self.parse_keyword(Keyword::MAX_ROWS) {
+ // MAX_ROWS [=] value
+ Ident::new("MAX_ROWS")
+ } else if self.parse_keyword(Keyword::MIN_ROWS) {
+ // MIN_ROWS [=] value
+ Ident::new("MIN_ROWS")
+ } else if self.parse_keyword(Keyword::AUTOEXTEND_SIZE) {
+ // AUTOEXTEND_SIZE [=] value
+ Ident::new("AUTOEXTEND_SIZE")
+ } else if self.parse_keyword(Keyword::AVG_ROW_LENGTH) {
+ // AVG_ROW_LENGTH [=] value
+ Ident::new("AVG_ROW_LENGTH")
+ } else if self.parse_keyword(Keyword::CHECKSUM) {
+ // CHECKSUM [=] {0 | 1}
+ Ident::new("CHECKSUM")
+ } else if self.parse_keyword(Keyword::CONNECTION) {
+ // CONNECTION [=] 'connect_string'
+ Ident::new("CONNECTION")
+ } else if self.parse_keyword(Keyword::ENGINE_ATTRIBUTE) {
+ // ENGINE_ATTRIBUTE [=] 'string'
+ Ident::new("ENGINE_ATTRIBUTE")
+ } else if self.parse_keyword(Keyword::PASSWORD) {
+ // PASSWORD [=] 'string'
+ Ident::new("PASSWORD")
+ } else if self.parse_keyword(Keyword::SECONDARY_ENGINE_ATTRIBUTE) {
+ // SECONDARY_ENGINE_ATTRIBUTE [=] 'string'
+ Ident::new("SECONDARY_ENGINE_ATTRIBUTE")
+ } else if self.parse_keyword(Keyword::INSERT_METHOD) {
+ // INSERT_METHOD [=] { NO | FIRST | LAST }
+ Ident::new("INSERT_METHOD")
+ } else if self.parse_keyword(Keyword::AUTO_INCREMENT) {
+ Ident::new("AUTO_INCREMENT")
+ } else {
+ return Ok(None);
+ };
+
+ let _ = self.consume_token(&Token::Eq);
+
+ let value = match self
+ .maybe_parse(|parser| parser.parse_value())?
+ .map(Expr::Value)
+ {
+ Some(expr) => expr,
+ None => Expr::Identifier(self.parse_identifier()?),
+ };
+
+ Ok(Some(SqlOption::KeyValue { key, value }))
+ }
+
+ pub fn parse_plain_options(&mut self) -> Result<Vec<SqlOption>,
ParserError> {
Review Comment:
Should this rather be called `parse_sql_options` / `parse_sql_option`? not
sure its clear what we mean by plain option in this context?
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscr...@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscr...@datafusion.apache.org
For additional commands, e-mail: github-h...@datafusion.apache.org
