From b12a19e197e4039552a9166b1a610fc2b974d646 Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 00:13:37 +0300 Subject: [PATCH 1/9] Switch to the Rust 2018 edition This requires Rust 1.31 (from last year) to build, but is otherwise compatible with the 2015-edition code. --- Cargo.toml | 1 + examples/cli.rs | 4 ++-- examples/parse_select.rs | 2 -- src/dialect/ansi_sql.rs | 2 +- src/dialect/generic_sql.rs | 2 +- src/dialect/postgresql.rs | 2 +- src/lib.rs | 5 ----- src/sqlast/mod.rs | 2 +- src/sqlparser.rs | 2 ++ tests/sqlparser_ansi.rs | 3 --- tests/sqlparser_generic.rs | 3 --- tests/sqlparser_postgres.rs | 5 +---- 12 files changed, 10 insertions(+), 23 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index ef748a7118..68fe0f7fb0 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,6 +12,7 @@ include = [ "src/**/*.rs", "Cargo.toml", ] +edition = "2018" [lib] name = "sqlparser" diff --git a/examples/cli.rs b/examples/cli.rs index 545e8218fd..e832991461 100644 --- a/examples/cli.rs +++ b/examples/cli.rs @@ -1,5 +1,5 @@ -extern crate simple_logger; -extern crate sqlparser; +use simple_logger; + ///! A small command-line app to run the parser. /// Run with `cargo run --example cli` use std::fs; diff --git a/examples/parse_select.rs b/examples/parse_select.rs index a87abb9bec..99ae76d50d 100644 --- a/examples/parse_select.rs +++ b/examples/parse_select.rs @@ -1,5 +1,3 @@ -extern crate sqlparser; - use sqlparser::dialect::GenericSqlDialect; use sqlparser::sqlparser::*; diff --git a/src/dialect/ansi_sql.rs b/src/dialect/ansi_sql.rs index 4026cf61cb..522ed0ef19 100644 --- a/src/dialect/ansi_sql.rs +++ b/src/dialect/ansi_sql.rs @@ -1,4 +1,4 @@ -use dialect::Dialect; +use crate::dialect::Dialect; pub struct AnsiSqlDialect {} diff --git a/src/dialect/generic_sql.rs b/src/dialect/generic_sql.rs index 54275d69f5..fe48ab2d21 100644 --- a/src/dialect/generic_sql.rs +++ b/src/dialect/generic_sql.rs @@ -1,4 +1,4 @@ -use dialect::Dialect; +use crate::dialect::Dialect; pub struct GenericSqlDialect {} impl Dialect for GenericSqlDialect { diff --git a/src/dialect/postgresql.rs b/src/dialect/postgresql.rs index 2b64c1f0ac..dac3740d9c 100644 --- a/src/dialect/postgresql.rs +++ b/src/dialect/postgresql.rs @@ -1,4 +1,4 @@ -use dialect::Dialect; +use crate::dialect::Dialect; pub struct PostgreSqlDialect {} diff --git a/src/lib.rs b/src/lib.rs index 5ffc5a8eb3..2c9f988310 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -35,11 +35,6 @@ //! println!("AST: {:?}", ast); //! ``` -#[macro_use] -extern crate log; -extern crate chrono; -extern crate uuid; - pub mod dialect; pub mod sqlast; pub mod sqlparser; diff --git a/src/sqlast/mod.rs b/src/sqlast/mod.rs index eef10fcdbc..9426eb0479 100644 --- a/src/sqlast/mod.rs +++ b/src/sqlast/mod.rs @@ -483,7 +483,7 @@ impl ToString for FileFormat { } } -use sqlparser::ParserError; +use crate::sqlparser::ParserError; use std::str::FromStr; impl FromStr for FileFormat { type Err = ParserError; diff --git a/src/sqlparser.rs b/src/sqlparser.rs index d59048c8ae..27824110aa 100644 --- a/src/sqlparser.rs +++ b/src/sqlparser.rs @@ -14,6 +14,8 @@ //! SQL Parser +use log::debug; + use super::dialect::keywords; use super::dialect::Dialect; use super::sqlast::*; diff --git a/tests/sqlparser_ansi.rs b/tests/sqlparser_ansi.rs index 73054fb78e..82248729e7 100644 --- a/tests/sqlparser_ansi.rs +++ b/tests/sqlparser_ansi.rs @@ -1,6 +1,3 @@ -extern crate log; -extern crate sqlparser; - use sqlparser::dialect::AnsiSqlDialect; use sqlparser::sqlast::*; use sqlparser::sqlparser::*; diff --git a/tests/sqlparser_generic.rs b/tests/sqlparser_generic.rs index ea60e6d47d..390d47c0b7 100644 --- a/tests/sqlparser_generic.rs +++ b/tests/sqlparser_generic.rs @@ -1,6 +1,3 @@ -extern crate log; -extern crate sqlparser; - use sqlparser::dialect::*; use sqlparser::sqlast::*; use sqlparser::sqlparser::*; diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs index 4c35a3cfc2..08071e82a9 100644 --- a/tests/sqlparser_postgres.rs +++ b/tests/sqlparser_postgres.rs @@ -1,13 +1,10 @@ -extern crate log; -extern crate sqlparser; +use log::debug; use sqlparser::dialect::PostgreSqlDialect; use sqlparser::sqlast::*; use sqlparser::sqlparser::*; use sqlparser::sqltokenizer::*; -use log::*; - #[test] fn test_prev_index() { let sql: &str = "SELECT version()"; From 0634ec4a83d9bce7ba1e879d9a543db5171b5d90 Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 00:07:43 +0300 Subject: [PATCH 2/9] Apply suggestions from `cargo fix --edition-idioms` --- src/sqlparser.rs | 2 +- src/sqltokenizer.rs | 18 +++++++++--------- tests/sqlparser_generic.rs | 2 +- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/sqlparser.rs b/src/sqlparser.rs index 27824110aa..529e6724fe 100644 --- a/src/sqlparser.rs +++ b/src/sqlparser.rs @@ -56,7 +56,7 @@ impl Parser { } /// Parse a SQL statement and produce an Abstract Syntax Tree (AST) - pub fn parse_sql(dialect: &Dialect, sql: String) -> Result, ParserError> { + pub fn parse_sql(dialect: &dyn Dialect, sql: String) -> Result, ParserError> { let mut tokenizer = Tokenizer::new(dialect, &sql); let tokens = tokenizer.tokenize()?; let mut parser = Parser::new(tokens); diff --git a/src/sqltokenizer.rs b/src/sqltokenizer.rs index 83105736ce..cab8f22eea 100644 --- a/src/sqltokenizer.rs +++ b/src/sqltokenizer.rs @@ -212,7 +212,7 @@ pub struct TokenizerError(String); /// SQL Tokenizer pub struct Tokenizer<'a> { - dialect: &'a Dialect, + dialect: &'a dyn Dialect, pub query: String, pub line: u64, pub col: u64, @@ -220,7 +220,7 @@ pub struct Tokenizer<'a> { impl<'a> Tokenizer<'a> { /// Create a new SQL tokenizer for the specified SQL statement - pub fn new(dialect: &'a Dialect, query: &str) -> Self { + pub fn new(dialect: &'a dyn Dialect, query: &str) -> Self { Self { dialect, query: query.to_string(), @@ -256,7 +256,7 @@ impl<'a> Tokenizer<'a> { } /// Get the next token or return None - fn next_token(&self, chars: &mut Peekable) -> Result, TokenizerError> { + fn next_token(&self, chars: &mut Peekable>) -> Result, TokenizerError> { //println!("next_token: {:?}", chars.peek()); match chars.peek() { Some(&ch) => match ch { @@ -312,11 +312,11 @@ impl<'a> Tokenizer<'a> { Ok(Some(Token::make_word(&s, Some(quote_start)))) } // numbers - '0'...'9' => { + '0'..='9' => { let mut s = String::new(); while let Some(&ch) = chars.peek() { match ch { - '0'...'9' | '.' => { + '0'..='9' | '.' => { chars.next(); // consume s.push(ch); } @@ -436,7 +436,7 @@ impl<'a> Tokenizer<'a> { } /// Tokenize an identifier or keyword, after the first char is already consumed. - fn tokenize_word(&self, first_char: char, chars: &mut Peekable) -> String { + fn tokenize_word(&self, first_char: char, chars: &mut Peekable>) -> String { let mut s = String::new(); s.push(first_char); while let Some(&ch) = chars.peek() { @@ -451,7 +451,7 @@ impl<'a> Tokenizer<'a> { } /// Read a single quoted string, starting with the opening quote. - fn tokenize_single_quoted_string(&self, chars: &mut Peekable) -> String { + fn tokenize_single_quoted_string(&self, chars: &mut Peekable>) -> String { //TODO: handle escaped quotes in string //TODO: handle newlines in string //TODO: handle EOF before terminating quote @@ -475,7 +475,7 @@ impl<'a> Tokenizer<'a> { fn tokenize_multiline_comment( &self, - chars: &mut Peekable, + chars: &mut Peekable>, ) -> Result, TokenizerError> { let mut s = String::new(); let mut maybe_closing_comment = false; @@ -506,7 +506,7 @@ impl<'a> Tokenizer<'a> { fn consume_and_return( &self, - chars: &mut Peekable, + chars: &mut Peekable>, t: Token, ) -> Result, TokenizerError> { chars.next(); diff --git a/tests/sqlparser_generic.rs b/tests/sqlparser_generic.rs index 390d47c0b7..5799cd4ddc 100644 --- a/tests/sqlparser_generic.rs +++ b/tests/sqlparser_generic.rs @@ -1070,7 +1070,7 @@ fn parse_sql_expr(sql: &str) -> ASTNode { generic_ast } -fn parse_sql_expr_with(dialect: &Dialect, sql: &str) -> ASTNode { +fn parse_sql_expr_with(dialect: &dyn Dialect, sql: &str) -> ASTNode { let mut tokenizer = Tokenizer::new(dialect, &sql); let tokens = tokenizer.tokenize().unwrap(); let mut parser = Parser::new(tokens); From 3df2223d953cf5782f86c2e0c0b59be6d8667c17 Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 00:43:32 +0300 Subject: [PATCH 3/9] Fix clippy if_same_then_else lint https://rust-lang.github.io/rust-clippy/master/#if_same_then_else There was a bug in parsing `TIME` (not followed by {WITH | WITHOUT} TIME ZONE) -- that parsed as SQLType::Timestamp instead of SQLType::Time --- src/sqlparser.rs | 60 +++++++++++------------------------------------- 1 file changed, 13 insertions(+), 47 deletions(-) diff --git a/src/sqlparser.rs b/src/sqlparser.rs index 529e6724fe..52e50c96cd 100644 --- a/src/sqlparser.rs +++ b/src/sqlparser.rs @@ -703,9 +703,8 @@ impl Parser { }; let allow_null = if self.parse_keywords(vec!["NOT", "NULL"]) { false - } else if self.parse_keyword("NULL") { - true } else { + let _ = self.parse_keyword("NULL"); true }; debug!("default: {:?}", default); @@ -1016,11 +1015,8 @@ impl Parser { "FLOAT" => Ok(SQLType::Float(self.parse_optional_precision()?)), "REAL" => Ok(SQLType::Real), "DOUBLE" => { - if self.parse_keyword("PRECISION") { - Ok(SQLType::Double) - } else { - Ok(SQLType::Double) - } + let _ = self.parse_keyword("PRECISION"); + Ok(SQLType::Double) } "SMALLINT" => Ok(SQLType::SmallInt), "INT" | "INTEGER" => Ok(SQLType::Int), @@ -1036,50 +1032,20 @@ impl Parser { "UUID" => Ok(SQLType::Uuid), "DATE" => Ok(SQLType::Date), "TIMESTAMP" => { - if self.parse_keyword("WITH") { - if self.parse_keywords(vec!["TIME", "ZONE"]) { - Ok(SQLType::Timestamp) - } else { - parser_err!(format!( - "Expecting 'time zone', found: {:?}", - self.peek_token() - )) - } - } else if self.parse_keyword("WITHOUT") { - if self.parse_keywords(vec!["TIME", "ZONE"]) { - Ok(SQLType::Timestamp) - } else { - parser_err!(format!( - "Expecting 'time zone', found: {:?}", - self.peek_token() - )) - } - } else { - Ok(SQLType::Timestamp) + // TBD: we throw away "with/without timezone" information + if self.parse_keyword("WITH") || self.parse_keyword("WITHOUT") { + self.expect_keyword("TIME")?; + self.expect_keyword("ZONE")?; } + Ok(SQLType::Timestamp) } "TIME" => { - if self.parse_keyword("WITH") { - if self.parse_keywords(vec!["TIME", "ZONE"]) { - Ok(SQLType::Time) - } else { - parser_err!(format!( - "Expecting 'time zone', found: {:?}", - self.peek_token() - )) - } - } else if self.parse_keyword("WITHOUT") { - if self.parse_keywords(vec!["TIME", "ZONE"]) { - Ok(SQLType::Time) - } else { - parser_err!(format!( - "Expecting 'time zone', found: {:?}", - self.peek_token() - )) - } - } else { - Ok(SQLType::Timestamp) + // TBD: we throw away "with/without timezone" information + if self.parse_keyword("WITH") || self.parse_keyword("WITHOUT") { + self.expect_keyword("TIME")?; + self.expect_keyword("ZONE")?; } + Ok(SQLType::Time) } "REGCLASS" => Ok(SQLType::Regclass), "TEXT" => { From c223eaf0aa51be6b6b136099dd7ae3382e5a67fd Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 01:29:05 +0300 Subject: [PATCH 4/9] Fix a bunch of trivial clippy lints --- examples/cli.rs | 6 +-- src/dialect/keywords.rs | 8 ++-- src/sqlast/mod.rs | 16 +++----- src/sqlparser.rs | 73 +++++++++++++++++-------------------- src/sqltokenizer.rs | 4 +- tests/sqlparser_generic.rs | 26 ++++++------- tests/sqlparser_postgres.rs | 21 +++++------ 7 files changed, 70 insertions(+), 84 deletions(-) diff --git a/examples/cli.rs b/examples/cli.rs index e832991461..d8e4877211 100644 --- a/examples/cli.rs +++ b/examples/cli.rs @@ -14,8 +14,8 @@ fn main() { .nth(1) .expect("No arguments provided!\n\nUsage: cargo run --example cli FILENAME.sql"); - let contents = - fs::read_to_string(&filename).expect(&format!("Unable to read the file {}", &filename)); + let contents = fs::read_to_string(&filename) + .unwrap_or_else(|_| panic!("Unable to read the file {}", &filename)); let without_bom = if contents.chars().nth(0).unwrap() as u64 != 0xfeff { contents.as_str() } else { @@ -31,7 +31,7 @@ fn main() { "Round-trip:\n'{}'", statements .iter() - .map(|s| s.to_string()) + .map(std::string::ToString::to_string) .collect::>() .join("\n") ); diff --git a/src/dialect/keywords.rs b/src/dialect/keywords.rs index e270e8a9fd..3856aa34ee 100644 --- a/src/dialect/keywords.rs +++ b/src/dialect/keywords.rs @@ -365,9 +365,9 @@ keyword!( ); /// special case of keyword where the it is an invalid identifier -pub const END_EXEC: &'static str = "END-EXEC"; +pub const END_EXEC: &str = "END-EXEC"; -pub const ALL_KEYWORDS: &'static [&'static str] = &[ +pub const ALL_KEYWORDS: &[&str] = &[ ABS, ADD, ASC, @@ -716,7 +716,7 @@ pub const ALL_KEYWORDS: &'static [&'static str] = &[ /// These keywords can't be used as a table alias, so that `FROM table_name alias` /// can be parsed unambiguously without looking ahead. -pub const RESERVED_FOR_TABLE_ALIAS: &'static [&'static str] = &[ +pub const RESERVED_FOR_TABLE_ALIAS: &[&str] = &[ // Reserved as both a table and a column alias: WITH, SELECT, WHERE, GROUP, ORDER, UNION, EXCEPT, INTERSECT, // Reserved only as a table alias in the `FROM`/`JOIN` clauses: @@ -725,7 +725,7 @@ pub const RESERVED_FOR_TABLE_ALIAS: &'static [&'static str] = &[ /// Can't be used as a column alias, so that `SELECT alias` /// can be parsed unambiguously without looking ahead. -pub const RESERVED_FOR_COLUMN_ALIAS: &'static [&'static str] = &[ +pub const RESERVED_FOR_COLUMN_ALIAS: &[&str] = &[ // Reserved as both a table and a column alias: WITH, SELECT, WHERE, GROUP, ORDER, UNION, EXCEPT, INTERSECT, // Reserved only as a column alias in the `SELECT` clause: diff --git a/src/sqlast/mod.rs b/src/sqlast/mod.rs index 9426eb0479..c511561997 100644 --- a/src/sqlast/mod.rs +++ b/src/sqlast/mod.rs @@ -271,10 +271,10 @@ impl ToString for SQLStatement { values, } => { let mut s = format!("INSERT INTO {}", table_name.to_string()); - if columns.len() > 0 { + if !columns.is_empty() { s += &format!(" ({})", columns.join(", ")); } - if values.len() > 0 { + if !values.is_empty() { s += &format!( " VALUES({})", values @@ -307,12 +307,12 @@ impl ToString for SQLStatement { ); } s += " FROM stdin; "; - if values.len() > 0 { + if !values.is_empty() { s += &format!( "\n{}", values .iter() - .map(|v| v.clone().unwrap_or("\\N".to_string())) + .map(|v| v.clone().unwrap_or_else(|| "\\N".to_string())) .collect::>() .join("\t") ); @@ -381,13 +381,7 @@ impl ToString for SQLStatement { file_format.as_ref().map(|f| f.to_string()).unwrap(), location.as_ref().unwrap() ), - SQLStatement::SQLCreateTable { - name, - columns, - external: _, - file_format: _, - location: _, - } => format!( + SQLStatement::SQLCreateTable { name, columns, .. } => format!( "CREATE TABLE {} ({})", name.to_string(), columns diff --git a/src/sqlparser.rs b/src/sqlparser.rs index 52e50c96cd..48960644e9 100644 --- a/src/sqlparser.rs +++ b/src/sqlparser.rs @@ -49,10 +49,7 @@ pub struct Parser { impl Parser { /// Parse the specified tokens pub fn new(tokens: Vec) -> Self { - Parser { - tokens: tokens, - index: 0, - } + Parser { tokens, index: 0 } } /// Parse a SQL statement and produce an Abstract Syntax Tree (AST) @@ -235,7 +232,7 @@ impl Parser { t )), }, - None => parser_err!(format!("Prefix parser expected a keyword but hit EOF")), + None => parser_err!("Prefix parser expected a keyword but hit EOF"), } } @@ -405,21 +402,21 @@ impl Parser { /// Convert a token operator to an AST operator pub fn to_sql_operator(&self, tok: &Token) -> Result { match tok { - &Token::Eq => Ok(SQLOperator::Eq), - &Token::Neq => Ok(SQLOperator::NotEq), - &Token::Lt => Ok(SQLOperator::Lt), - &Token::LtEq => Ok(SQLOperator::LtEq), - &Token::Gt => Ok(SQLOperator::Gt), - &Token::GtEq => Ok(SQLOperator::GtEq), - &Token::Plus => Ok(SQLOperator::Plus), - &Token::Minus => Ok(SQLOperator::Minus), - &Token::Mult => Ok(SQLOperator::Multiply), - &Token::Div => Ok(SQLOperator::Divide), - &Token::Mod => Ok(SQLOperator::Modulus), - &Token::SQLWord(ref k) if k.keyword == "AND" => Ok(SQLOperator::And), - &Token::SQLWord(ref k) if k.keyword == "OR" => Ok(SQLOperator::Or), - //&Token::SQLWord(ref k) if k.keyword == "NOT" => Ok(SQLOperator::Not), - &Token::SQLWord(ref k) if k.keyword == "LIKE" => Ok(SQLOperator::Like), + Token::Eq => Ok(SQLOperator::Eq), + Token::Neq => Ok(SQLOperator::NotEq), + Token::Lt => Ok(SQLOperator::Lt), + Token::LtEq => Ok(SQLOperator::LtEq), + Token::Gt => Ok(SQLOperator::Gt), + Token::GtEq => Ok(SQLOperator::GtEq), + Token::Plus => Ok(SQLOperator::Plus), + Token::Minus => Ok(SQLOperator::Minus), + Token::Mult => Ok(SQLOperator::Multiply), + Token::Div => Ok(SQLOperator::Divide), + Token::Mod => Ok(SQLOperator::Modulus), + Token::SQLWord(ref k) if k.keyword == "AND" => Ok(SQLOperator::And), + Token::SQLWord(ref k) if k.keyword == "OR" => Ok(SQLOperator::Or), + //Token::SQLWord(ref k) if k.keyword == "NOT" => Ok(SQLOperator::Not), + Token::SQLWord(ref k) if k.keyword == "LIKE" => Ok(SQLOperator::Like), _ => parser_err!(format!("Unsupported SQL operator {:?}", tok)), } } @@ -438,19 +435,17 @@ impl Parser { debug!("get_precedence() {:?}", tok); match tok { - &Token::SQLWord(ref k) if k.keyword == "OR" => Ok(5), - &Token::SQLWord(ref k) if k.keyword == "AND" => Ok(10), - &Token::SQLWord(ref k) if k.keyword == "NOT" => Ok(15), - &Token::SQLWord(ref k) if k.keyword == "IS" => Ok(17), - &Token::SQLWord(ref k) if k.keyword == "IN" => Ok(20), - &Token::SQLWord(ref k) if k.keyword == "BETWEEN" => Ok(20), - &Token::SQLWord(ref k) if k.keyword == "LIKE" => Ok(20), - &Token::Eq | &Token::Lt | &Token::LtEq | &Token::Neq | &Token::Gt | &Token::GtEq => { - Ok(20) - } - &Token::Plus | &Token::Minus => Ok(30), - &Token::Mult | &Token::Div | &Token::Mod => Ok(40), - &Token::DoubleColon => Ok(50), + Token::SQLWord(k) if k.keyword == "OR" => Ok(5), + Token::SQLWord(k) if k.keyword == "AND" => Ok(10), + Token::SQLWord(k) if k.keyword == "NOT" => Ok(15), + Token::SQLWord(k) if k.keyword == "IS" => Ok(17), + Token::SQLWord(k) if k.keyword == "IN" => Ok(20), + Token::SQLWord(k) if k.keyword == "BETWEEN" => Ok(20), + Token::SQLWord(k) if k.keyword == "LIKE" => Ok(20), + Token::Eq | Token::Lt | Token::LtEq | Token::Neq | Token::Gt | Token::GtEq => Ok(20), + Token::Plus | Token::Minus => Ok(30), + Token::Mult | Token::Div | Token::Mod => Ok(40), + Token::DoubleColon => Ok(50), _ => Ok(0), } } @@ -484,7 +479,7 @@ impl Parser { loop { match self.token_at(index) { Some(Token::Whitespace(_)) => { - index = index + 1; + index += 1; } Some(_) => { return Some(index); @@ -507,7 +502,7 @@ impl Parser { pub fn next_token_no_skip(&mut self) -> Option { if self.index < self.tokens.len() { - self.index = self.index + 1; + self.index += 1; Some(self.tokens[self.index - 1].clone()) } else { None @@ -532,7 +527,7 @@ impl Parser { /// Get the previous token and decrement the token index fn prev_token_no_skip(&mut self) -> Option { if self.index > 0 { - self.index = self.index - 1; + self.index -= 1; Some(self.tokens[self.index].clone()) } else { None @@ -878,7 +873,7 @@ impl Parser { } }, //TODO: parse the timestamp here (see parse_timestamp_value()) - Token::Number(ref n) if n.contains(".") => match n.parse::() { + Token::Number(ref n) if n.contains('.') => match n.parse::() { Ok(n) => Ok(Value::Double(n)), Err(e) => parser_err!(format!("Could not parse '{}' as f64: {}", n, e)), }, @@ -953,7 +948,7 @@ impl Parser { Some(token) => match token { Token::Plus | Token::Minus => { let tz = self.parse_timezone_offset()?; - let offset = FixedOffset::east(tz as i32 * 3600); + let offset = FixedOffset::east(i32::from(tz) * 3600); Ok(Value::Timestamp(DateTime::from_utc(date_time, offset))) } _ => Ok(Value::DateTime(date_time)), @@ -1256,7 +1251,7 @@ impl Parser { break; } } - return Ok(cte); + Ok(cte) } /// Parse a "query body", which is an expression with roughly the diff --git a/src/sqltokenizer.rs b/src/sqltokenizer.rs index cab8f22eea..03e0db64ae 100644 --- a/src/sqltokenizer.rs +++ b/src/sqltokenizer.rs @@ -138,9 +138,9 @@ impl Token { let is_keyword = quote_style == None && ALL_KEYWORDS.contains(&word_uppercase.as_str()); Token::SQLWord(SQLWord { value: word.to_string(), - quote_style: quote_style, + quote_style, keyword: if is_keyword { - word_uppercase.to_string() + word_uppercase } else { "".to_string() }, diff --git a/tests/sqlparser_generic.rs b/tests/sqlparser_generic.rs index 5799cd4ddc..5b02e157f0 100644 --- a/tests/sqlparser_generic.rs +++ b/tests/sqlparser_generic.rs @@ -446,9 +446,9 @@ fn parse_create_table() { SQLStatement::SQLCreateTable { name, columns, - external: _, - file_format: _, - location: _, + external: false, + file_format: None, + location: None, } => { assert_eq!("uk_cities", name.to_string()); assert_eq!(3, columns.len()); @@ -841,14 +841,13 @@ fn parse_ctes() { cte_sqls[0], cte_sqls[1] ); - fn assert_ctes_in_select(expected: &Vec<&str>, sel: &SQLQuery) { - for i in 0..1 { - let Cte { - ref query, - ref alias, - } = sel.ctes[i]; - assert_eq!(expected[i], query.to_string()); + fn assert_ctes_in_select(expected: &[&str], sel: &SQLQuery) { + let mut i = 0; + for exp in expected { + let Cte { query, alias } = &sel.ctes[i]; + assert_eq!(*exp, query.to_string()); assert_eq!(if i == 0 { "a" } else { "b" }, alias); + i += 1; } } @@ -858,7 +857,7 @@ fn parse_ctes() { let sql = &format!("SELECT ({})", with); let select = verified_only_select(sql); match expr_from_projection(only(&select.projection)) { - &ASTNode::SQLSubquery(ref subquery) => { + ASTNode::SQLSubquery(ref subquery) => { assert_ctes_in_select(&cte_sqls, subquery.as_ref()); } _ => panic!("Expected subquery"), @@ -1006,7 +1005,7 @@ fn parse_invalid_subquery_without_parens() { ); } -fn only<'a, T>(v: &'a Vec) -> &'a T { +fn only(v: &[T]) -> &T { assert_eq!(1, v.len()); v.first().unwrap() } @@ -1074,6 +1073,5 @@ fn parse_sql_expr_with(dialect: &dyn Dialect, sql: &str) -> ASTNode { let mut tokenizer = Tokenizer::new(dialect, &sql); let tokens = tokenizer.tokenize().unwrap(); let mut parser = Parser::new(tokens); - let ast = parser.parse_expr().unwrap(); - ast + parser.parse_expr().unwrap() } diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs index 08071e82a9..45f43e24c3 100644 --- a/tests/sqlparser_postgres.rs +++ b/tests/sqlparser_postgres.rs @@ -163,9 +163,9 @@ fn parse_create_table_with_defaults() { SQLStatement::SQLCreateTable { name, columns, - external: _, - file_format: _, - location: _, + external: false, + file_format: None, + location: None, } => { assert_eq!("public.customer", name.to_string()); assert_eq!(10, columns.len()); @@ -210,9 +210,9 @@ fn parse_create_table_from_pg_dump() { SQLStatement::SQLCreateTable { name, columns, - external: _, - file_format: _, - location: _, + external: false, + file_format: None, + location: None, } => { assert_eq!("public.customer", name.to_string()); @@ -273,9 +273,9 @@ fn parse_create_table_with_inherit() { SQLStatement::SQLCreateTable { name, columns, - external: _, - file_format: _, - location: _, + external: false, + file_format: None, + location: None, } => { assert_eq!("bazaar.settings", name.to_string()); @@ -407,8 +407,7 @@ fn parse_sql_statements(sql: &str) -> Result, ParserError> { fn parse_sql_expr(sql: &str) -> ASTNode { debug!("sql: {}", sql); let mut parser = parser(sql); - let ast = parser.parse_expr().unwrap(); - ast + parser.parse_expr().unwrap() } fn parser(sql: &str) -> Parser { From a3a8626e6bde2d7924f3428aa06101d00f54efbb Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 02:22:59 +0300 Subject: [PATCH 5/9] Fix a clippy lint and reduce duplication in SQLType::to_string() --- src/sqlast/sqltype.rs | 40 ++++++++++++++-------------------------- 1 file changed, 14 insertions(+), 26 deletions(-) diff --git a/src/sqlast/sqltype.rs b/src/sqlast/sqltype.rs index 42285c0e55..fc7cdd8f28 100644 --- a/src/sqlast/sqltype.rs +++ b/src/sqlast/sqltype.rs @@ -19,14 +19,14 @@ pub enum SQLType { Blob(usize), /// Decimal type with optional precision and scale e.g. DECIMAL(10,2) Decimal(Option, Option), + /// Floating point with optional precision e.g. FLOAT(8) + Float(Option), /// Small integer SmallInt, /// Integer Int, /// Big integer BigInt, - /// Floating point with optional precision e.g. FLOAT(8) - Float(Option), /// Floating point e.g. REAL Real, /// Double e.g. DOUBLE PRECISION @@ -54,20 +54,8 @@ pub enum SQLType { impl ToString for SQLType { fn to_string(&self) -> String { match self { - SQLType::Char(size) => { - if let Some(size) = size { - format!("char({})", size) - } else { - "char".to_string() - } - } - SQLType::Varchar(size) => { - if let Some(size) = size { - format!("character varying({})", size) - } else { - "character varying".to_string() - } - } + SQLType::Char(size) => format_type_with_optional_length("char", size), + SQLType::Varchar(size) => format_type_with_optional_length("character varying", size), SQLType::Uuid => "uuid".to_string(), SQLType::Clob(size) => format!("clob({})", size), SQLType::Binary(size) => format!("binary({})", size), @@ -76,22 +64,14 @@ impl ToString for SQLType { SQLType::Decimal(precision, scale) => { if let Some(scale) = scale { format!("numeric({},{})", precision.unwrap(), scale) - } else if let Some(precision) = precision { - format!("numeric({})", precision) } else { - format!("numeric") + format_type_with_optional_length("numeric", precision) } } + SQLType::Float(size) => format_type_with_optional_length("float", size), SQLType::SmallInt => "smallint".to_string(), SQLType::Int => "int".to_string(), SQLType::BigInt => "bigint".to_string(), - SQLType::Float(size) => { - if let Some(size) = size { - format!("float({})", size) - } else { - "float".to_string() - } - } SQLType::Real => "real".to_string(), SQLType::Double => "double".to_string(), SQLType::Boolean => "boolean".to_string(), @@ -106,3 +86,11 @@ impl ToString for SQLType { } } } + +fn format_type_with_optional_length(sql_type: &str, len: &Option) -> String { + let mut s = sql_type.to_string(); + if let Some(len) = len { + s += &format!("({})", len); + } + s +} From dee30aabe04c56aa2c8a9fa810ed509a14d2330a Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 02:56:22 +0300 Subject: [PATCH 6/9] Fix the clippy `assert!(false)` lint https://rust-lang.github.io/rust-clippy/master/index.html#assertions_on_constants While I don't feel it's valid, fixing it lets us act on the other, more useful, lints. --- tests/sqlparser_ansi.rs | 2 +- tests/sqlparser_generic.rs | 14 ++++++-------- tests/sqlparser_postgres.rs | 20 ++++++++++---------- 3 files changed, 17 insertions(+), 19 deletions(-) diff --git a/tests/sqlparser_ansi.rs b/tests/sqlparser_ansi.rs index 82248729e7..f16dcccf8c 100644 --- a/tests/sqlparser_ansi.rs +++ b/tests/sqlparser_ansi.rs @@ -14,6 +14,6 @@ fn parse_simple_select() { }) => { assert_eq!(3, projection.len()); } - _ => assert!(false), + _ => unreachable!(), } } diff --git a/tests/sqlparser_generic.rs b/tests/sqlparser_generic.rs index 5b02e157f0..29bcdc73de 100644 --- a/tests/sqlparser_generic.rs +++ b/tests/sqlparser_generic.rs @@ -10,8 +10,7 @@ fn parse_delete_statement() { SQLStatement::SQLDelete { table_name, .. } => { assert_eq!(SQLObjectName(vec!["\"table\"".to_string()]), table_name); } - - _ => assert!(false), + _ => unreachable!(), } } @@ -38,8 +37,7 @@ fn parse_where_delete_statement() { selection.unwrap(), ); } - - _ => assert!(false), + _ => unreachable!(), } } @@ -468,7 +466,7 @@ fn parse_create_table() { assert_eq!(SQLType::Double, c_lng.data_type); assert_eq!(true, c_lng.allow_null); } - _ => assert!(false), + _ => unreachable!(), } } @@ -519,7 +517,7 @@ fn parse_create_external_table() { assert_eq!(FileFormat::TEXTFILE, file_format.unwrap()); assert_eq!("/tmp/example.csv", location.unwrap()); } - _ => assert!(false), + _ => unreachable!(), } } @@ -975,7 +973,7 @@ fn parse_create_view() { assert_eq!("SELECT foo FROM bar", query.to_string()); assert!(!materialized); } - _ => assert!(false), + _ => unreachable!(), } } @@ -992,7 +990,7 @@ fn parse_create_materialized_view() { assert_eq!("SELECT foo FROM bar", query.to_string()); assert!(materialized); } - _ => assert!(false), + _ => unreachable!(), } } diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs index 45f43e24c3..13e21187e9 100644 --- a/tests/sqlparser_postgres.rs +++ b/tests/sqlparser_postgres.rs @@ -39,7 +39,7 @@ fn parse_simple_insert() { values ); } - _ => assert!(false), + _ => unreachable!(), } } @@ -64,7 +64,7 @@ fn parse_common_insert() { values ); } - _ => assert!(false), + _ => unreachable!(), } } @@ -89,7 +89,7 @@ fn parse_complex_insert() { values ); } - _ => assert!(false), + _ => unreachable!(), } } @@ -131,7 +131,7 @@ fn parse_insert_with_columns() { values ); } - _ => assert!(false), + _ => unreachable!(), } } @@ -140,7 +140,7 @@ fn parse_insert_invalid() { let sql = String::from("INSERT public.customer (id, name, active) VALUES (1, 2, 3)"); match Parser::parse_sql(&PostgreSqlDialect {}, sql) { Err(_) => {} - _ => assert!(false), + _ => unreachable!(), } } @@ -185,7 +185,7 @@ fn parse_create_table_with_defaults() { assert_eq!(SQLType::Varchar(Some(45)), c_lng.data_type); assert_eq!(false, c_lng.allow_null); } - _ => assert!(false), + _ => unreachable!(), } } @@ -254,7 +254,7 @@ fn parse_create_table_from_pg_dump() { c_release_year.data_type ); } - _ => assert!(false), + _ => unreachable!(), } } @@ -293,7 +293,7 @@ fn parse_create_table_with_inherit() { assert_eq!(false, c_name.is_primary); assert_eq!(true, c_name.is_unique); } - _ => assert!(false), + _ => unreachable!(), } } @@ -308,7 +308,7 @@ fn parse_alter_table_constraint_primary_key() { SQLStatement::SQLAlterTable { name, .. } => { assert_eq!(name.to_string(), "bazaar.address"); } - _ => assert!(false), + _ => unreachable!(), } } @@ -321,7 +321,7 @@ fn parse_alter_table_constraint_foreign_key() { SQLStatement::SQLAlterTable { name, .. } => { assert_eq!(name.to_string(), "public.customer"); } - _ => assert!(false), + _ => unreachable!(), } } From 08bbce8992b2f5a86880ede500c580476c0ce0bd Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 03:06:36 +0300 Subject: [PATCH 7/9] Use assert_matches! instead of matching manually To fix clippy warnings about assert!(true / false) --- Cargo.toml | 1 + tests/sqlparser_generic.rs | 37 +++++++++++++++---------------------- 2 files changed, 16 insertions(+), 22 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 68fe0f7fb0..53463a9e96 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -25,3 +25,4 @@ uuid = "0.7.1" [dev-dependencies] simple_logger = "1.0.1" +matches = "0.1" diff --git a/tests/sqlparser_generic.rs b/tests/sqlparser_generic.rs index 29bcdc73de..3a4019fde1 100644 --- a/tests/sqlparser_generic.rs +++ b/tests/sqlparser_generic.rs @@ -1,3 +1,5 @@ +use matches::assert_matches; + use sqlparser::dialect::*; use sqlparser::sqlast::*; use sqlparser::sqlparser::*; @@ -227,23 +229,17 @@ fn parse_not_precedence() { use self::ASTNode::*; // NOT has higher precedence than OR/AND, so the following must parse as (NOT true) OR true let sql = "NOT true OR true"; - match verified_expr(sql) { - SQLBinaryExpr { - op: SQLOperator::Or, - .. - } => assert!(true), - _ => assert!(false), - }; + assert_matches!(verified_expr(sql), SQLBinaryExpr { + op: SQLOperator::Or, + .. + }); // But NOT has lower precedence than comparison operators, so the following parses as NOT (a IS NULL) let sql = "NOT a IS NULL"; - match verified_expr(sql) { - SQLUnary { - operator: SQLOperator::Not, - .. - } => assert!(true), - _ => assert!(false), - }; + assert_matches!(verified_expr(sql), SQLUnary { + operator: SQLOperator::Not, + .. + }); } #[test] @@ -950,14 +946,11 @@ fn parse_multiple_statements() { fn parse_scalar_subqueries() { use self::ASTNode::*; let sql = "(SELECT 1) + (SELECT 2)"; - match verified_expr(sql) { - SQLBinaryExpr { - op: SQLOperator::Plus, .. - //left: box SQLSubquery { .. }, - //right: box SQLSubquery { .. }, - } => assert!(true), - _ => assert!(false), - }; + assert_matches!(verified_expr(sql), SQLBinaryExpr { + op: SQLOperator::Plus, .. + //left: box SQLSubquery { .. }, + //right: box SQLSubquery { .. }, + }); } #[test] From 50a23101735d479b2c21286c6eeac911d09e7207 Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 02:40:02 +0300 Subject: [PATCH 8/9] Rename SQLStatement::SQLSelect to SQLQuery The name was confusing: SQLStatement::SQLSelect( SQLQuery { body: SQLSetExpr::Select(SQLSelect) } ) Fix the `large_enum_variant` clippy lint for `SQLStatement::SQLQuery` `SQLStatement::SQLCreateView`, and `SQLSetExpr::Select`, while we're changing the AST anyway https://rust-lang.github.io/rust-clippy/master/index.html#large_enum_variant --- src/sqlast/mod.rs | 6 +++--- src/sqlast/query.rs | 2 +- src/sqlparser.rs | 6 +++--- tests/sqlparser_ansi.rs | 19 +++++++++++-------- tests/sqlparser_generic.rs | 6 +++--- 5 files changed, 21 insertions(+), 18 deletions(-) diff --git a/src/sqlast/mod.rs b/src/sqlast/mod.rs index c511561997..57408f3e7a 100644 --- a/src/sqlast/mod.rs +++ b/src/sqlast/mod.rs @@ -202,7 +202,7 @@ impl ToString for ASTNode { #[derive(Debug, Clone, PartialEq)] pub enum SQLStatement { /// SELECT - SQLSelect(SQLQuery), + SQLQuery(Box), /// INSERT SQLInsert { /// TABLE @@ -240,7 +240,7 @@ pub enum SQLStatement { SQLCreateView { /// View name name: SQLObjectName, - query: SQLQuery, + query: Box, materialized: bool, }, /// CREATE TABLE @@ -264,7 +264,7 @@ pub enum SQLStatement { impl ToString for SQLStatement { fn to_string(&self) -> String { match self { - SQLStatement::SQLSelect(s) => s.to_string(), + SQLStatement::SQLQuery(s) => s.to_string(), SQLStatement::SQLInsert { table_name, columns, diff --git a/src/sqlast/query.rs b/src/sqlast/query.rs index dbcb0b6bd5..93270566d3 100644 --- a/src/sqlast/query.rs +++ b/src/sqlast/query.rs @@ -50,7 +50,7 @@ impl ToString for SQLQuery { #[derive(Debug, Clone, PartialEq)] pub enum SQLSetExpr { /// Restricted SELECT .. FROM .. HAVING (no ORDER BY or set operations) - Select(SQLSelect), + Select(Box), /// Parenthesized SELECT subquery, which may include more set operations /// in its body and an optional ORDER BY / LIMIT. Query(Box), diff --git a/src/sqlparser.rs b/src/sqlparser.rs index 48960644e9..390dd12a0a 100644 --- a/src/sqlparser.rs +++ b/src/sqlparser.rs @@ -90,7 +90,7 @@ impl Parser { Token::SQLWord(ref w) if w.keyword != "" => match w.keyword.as_ref() { "SELECT" | "WITH" => { self.prev_token(); - Ok(SQLStatement::SQLSelect(self.parse_query()?)) + Ok(SQLStatement::SQLQuery(Box::new(self.parse_query()?))) } "CREATE" => Ok(self.parse_create()?), "DELETE" => Ok(self.parse_delete()?), @@ -655,7 +655,7 @@ impl Parser { // Some dialects allow WITH here, followed by some keywords (e.g. MS SQL) // or `(k1=v1, k2=v2, ...)` (Postgres) self.expect_keyword("AS")?; - let query = self.parse_query()?; + let query = Box::new(self.parse_query()?); // Optional `WITH [ CASCADED | LOCAL ] CHECK OPTION` is widely supported here. Ok(SQLStatement::SQLCreateView { name, @@ -1266,7 +1266,7 @@ impl Parser { // We parse the expression using a Pratt parser, as in `parse_expr()`. // Start by parsing a restricted SELECT or a `(subquery)`: let mut expr = if self.parse_keyword("SELECT") { - SQLSetExpr::Select(self.parse_select()?) + SQLSetExpr::Select(Box::new(self.parse_select()?)) } else if self.consume_token(&Token::LParen) { // CTEs are not allowed here, but the parser currently accepts them let subquery = self.parse_query()?; diff --git a/tests/sqlparser_ansi.rs b/tests/sqlparser_ansi.rs index f16dcccf8c..17bccb34b6 100644 --- a/tests/sqlparser_ansi.rs +++ b/tests/sqlparser_ansi.rs @@ -5,15 +5,18 @@ use sqlparser::sqlparser::*; #[test] fn parse_simple_select() { let sql = String::from("SELECT id, fname, lname FROM customer WHERE id = 1"); - let ast = Parser::parse_sql(&AnsiSqlDialect {}, sql).unwrap(); + let mut ast = Parser::parse_sql(&AnsiSqlDialect {}, sql).unwrap(); assert_eq!(1, ast.len()); - match ast.first().unwrap() { - SQLStatement::SQLSelect(SQLQuery { - body: SQLSetExpr::Select(SQLSelect { projection, .. }), - .. - }) => { - assert_eq!(3, projection.len()); - } + match ast.pop().unwrap() { + SQLStatement::SQLQuery(q) => match *q { + SQLQuery { + body: SQLSetExpr::Select(select), + .. + } => { + assert_eq!(3, select.projection.len()); + } + _ => unreachable!(), + }, _ => unreachable!(), } } diff --git a/tests/sqlparser_generic.rs b/tests/sqlparser_generic.rs index 3a4019fde1..d5c52194a5 100644 --- a/tests/sqlparser_generic.rs +++ b/tests/sqlparser_generic.rs @@ -1003,8 +1003,8 @@ fn only(v: &[T]) -> &T { fn verified_query(query: &str) -> SQLQuery { match verified_stmt(query) { - SQLStatement::SQLSelect(select) => select, - _ => panic!("Expected SELECT"), + SQLStatement::SQLQuery(query) => *query, + _ => panic!("Expected SQLQuery"), } } @@ -1017,7 +1017,7 @@ fn expr_from_projection(item: &SQLSelectItem) -> &ASTNode { fn verified_only_select(query: &str) -> SQLSelect { match verified_query(query).body { - SQLSetExpr::Select(s) => s, + SQLSetExpr::Select(s) => *s, _ => panic!("Expected SQLSetExpr::Select"), } } From 098d1c4a17c43357a24cd82831e1e23b4454a640 Mon Sep 17 00:00:00 2001 From: Nickolay Ponomarev Date: Sun, 21 Apr 2019 04:39:25 +0300 Subject: [PATCH 9/9] Enable clippy lints by default in RLS --- examples/cli.rs | 2 ++ examples/parse_select.rs | 2 ++ src/lib.rs | 1 + tests/sqlparser_ansi.rs | 2 ++ tests/sqlparser_generic.rs | 2 ++ tests/sqlparser_postgres.rs | 2 ++ 6 files changed, 11 insertions(+) diff --git a/examples/cli.rs b/examples/cli.rs index d8e4877211..f486a8aa04 100644 --- a/examples/cli.rs +++ b/examples/cli.rs @@ -1,3 +1,5 @@ +#![warn(clippy::all)] + use simple_logger; ///! A small command-line app to run the parser. diff --git a/examples/parse_select.rs b/examples/parse_select.rs index 99ae76d50d..6a0a450635 100644 --- a/examples/parse_select.rs +++ b/examples/parse_select.rs @@ -1,3 +1,5 @@ +#![warn(clippy::all)] + use sqlparser::dialect::GenericSqlDialect; use sqlparser::sqlparser::*; diff --git a/src/lib.rs b/src/lib.rs index 2c9f988310..fc90be855c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -34,6 +34,7 @@ //! //! println!("AST: {:?}", ast); //! ``` +#![warn(clippy::all)] pub mod dialect; pub mod sqlast; diff --git a/tests/sqlparser_ansi.rs b/tests/sqlparser_ansi.rs index 17bccb34b6..ab80ae926f 100644 --- a/tests/sqlparser_ansi.rs +++ b/tests/sqlparser_ansi.rs @@ -1,3 +1,5 @@ +#![warn(clippy::all)] + use sqlparser::dialect::AnsiSqlDialect; use sqlparser::sqlast::*; use sqlparser::sqlparser::*; diff --git a/tests/sqlparser_generic.rs b/tests/sqlparser_generic.rs index d5c52194a5..baaac85fd6 100644 --- a/tests/sqlparser_generic.rs +++ b/tests/sqlparser_generic.rs @@ -1,3 +1,5 @@ +#![warn(clippy::all)] + use matches::assert_matches; use sqlparser::dialect::*; diff --git a/tests/sqlparser_postgres.rs b/tests/sqlparser_postgres.rs index 13e21187e9..98cdb902b4 100644 --- a/tests/sqlparser_postgres.rs +++ b/tests/sqlparser_postgres.rs @@ -1,3 +1,5 @@ +#![warn(clippy::all)] + use log::debug; use sqlparser::dialect::PostgreSqlDialect;