chore: Bump Rust toolchain

.github/workflows/rust.yml

@@ -11,7 +11,7 @@ jobs:
         uses: hecrj/setup-rust-action@v1
         with:
           components: rustfmt
-          rust-version: nightly-2022-03-22
+          rust-version: nightly-2023-12-13
       - uses: actions/checkout@v2
       - run: cargo fmt -- --check --config-path <(echo 'license_template_path = "HEADER"')
 
@@ -22,7 +22,7 @@ jobs:
         uses: hecrj/setup-rust-action@v1
         with:
           components: clippy
-          rust-version: nightly-2022-03-22
+          rust-version: nightly-2023-12-13
       - uses: actions/checkout@v2
       - run: cargo clippy --all-targets --all-features -- -D warnings
 
@@ -41,14 +41,14 @@ jobs:
         uses: hecrj/setup-rust-action@v1
         with:
           targets: 'thumbv6m-none-eabi'
-          rust-version: nightly-2022-03-22
+          rust-version: nightly-2023-12-13
       - uses: actions/checkout@master
       - run: cargo check --no-default-features --target thumbv6m-none-eabi
 
   test:
     strategy:
       matrix:
-        rust: [stable, beta, nightly, nightly-2022-03-22]
+        rust: [stable, beta, nightly, nightly-2023-12-13]
     runs-on: ubuntu-latest
     steps:
     - name: Setup Rust

rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "nightly-2023-12-13"
+components = ["rustfmt", "rustc-dev", "clippy"]
+profile = "minimal"

src/ast/mod.rs

@@ -140,7 +140,7 @@ impl fmt::Display for Ident {
                 }
                 f.write_char(q)
             }
-            Some(q) if q == '[' => write!(f, "[{}]", self.value),
+            Some('[') => write!(f, "[{}]", self.value),
             None => f.write_str(&self.value),
             _ => panic!("unexpected quote style"),
         }
@@ -1786,7 +1786,7 @@ impl fmt::Display for Statement {
             Statement::SetVariable { key_values } => {
                 f.write_str("SET ")?;
 
-                if let Some(key_value) = key_values.get(0) {
+                if let Some(key_value) = key_values.first() {
                     if key_value.hivevar {
                         let values: Vec<String> = key_value
                             .value

src/dialect/ansi.rs

@@ -17,13 +17,10 @@ pub struct AnsiDialect {}
 
 impl Dialect for AnsiDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch) || ('A'..='Z').contains(&ch)
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase()
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ('0'..='9').contains(&ch)
-            || ch == '_'
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '_'
     }
 }

src/dialect/clickhouse.rs

@@ -18,10 +18,10 @@ pub struct ClickHouseDialect {}
 impl Dialect for ClickHouseDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
         // See https://clickhouse.com/docs/en/sql-reference/syntax/#syntax-identifiers
-        ('a'..='z').contains(&ch) || ('A'..='Z').contains(&ch) || ch == '_'
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        self.is_identifier_start(ch) || ('0'..='9').contains(&ch)
+        self.is_identifier_start(ch) || ch.is_ascii_digit()
     }
 }

src/dialect/generic.rs

@@ -17,17 +17,13 @@ pub struct GenericDialect;
 
 impl Dialect for GenericDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ch == '_'
-            || ch == '#'
-            || ch == '@'
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_' || ch == '#' || ch == '@'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ('0'..='9').contains(&ch)
+        ch.is_ascii_lowercase()
+            || ch.is_ascii_uppercase()
+            || ch.is_ascii_digit()
             || ch == '@'
             || ch == '$'
             || ch == '#'

src/dialect/hive.rs

@@ -21,16 +21,13 @@ impl Dialect for HiveDialect {
     }
 
     fn is_identifier_start(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ('0'..='9').contains(&ch)
-            || ch == '$'
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == '$'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ('0'..='9').contains(&ch)
+        ch.is_ascii_lowercase()
+            || ch.is_ascii_uppercase()
+            || ch.is_ascii_digit()
             || ch == '_'
             || ch == '$'
             || ch == '{'

src/dialect/mssql.rs

@@ -23,17 +23,13 @@ impl Dialect for MsSqlDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
         // See https://docs.microsoft.com/en-us/sql/relational-databases/databases/database-identifiers?view=sql-server-2017#rules-for-regular-identifiers
         // We don't support non-latin "letters" currently.
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ch == '_'
-            || ch == '#'
-            || ch == '@'
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_' || ch == '#' || ch == '@'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ('0'..='9').contains(&ch)
+        ch.is_ascii_lowercase()
+            || ch.is_ascii_uppercase()
+            || ch.is_ascii_digit()
             || ch == '@'
             || ch == '$'
             || ch == '#'

src/dialect/mysql.rs

@@ -20,16 +20,16 @@ impl Dialect for MySqlDialect {
         // See https://dev.mysql.com/doc/refman/8.0/en/identifiers.html.
         // We don't yet support identifiers beginning with numbers, as that
         // makes it hard to distinguish numeric literals.
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
+        ch.is_ascii_lowercase()
+            || ch.is_ascii_uppercase()
             || ch == '_'
             || ch == '$'
             || ch == '@'
             || ('\u{0080}'..='\u{ffff}').contains(&ch)
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        self.is_identifier_start(ch) || ('0'..='9').contains(&ch)
+        self.is_identifier_start(ch) || ch.is_ascii_digit()
     }
 
     fn is_delimited_identifier_start(&self, ch: char) -> bool {

src/dialect/postgresql.rs

@@ -20,13 +20,13 @@ impl Dialect for PostgreSqlDialect {
         // See https://www.postgresql.org/docs/11/sql-syntax-lexical.html#SQL-SYNTAX-IDENTIFIERS
         // We don't yet support identifiers beginning with "letters with
         // diacritical marks and non-Latin letters"
-        ('a'..='z').contains(&ch) || ('A'..='Z').contains(&ch) || ch == '_'
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ('0'..='9').contains(&ch)
+        ch.is_ascii_lowercase()
+            || ch.is_ascii_uppercase()
+            || ch.is_ascii_digit()
             || ch == '$'
             || ch == '_'
     }

src/dialect/snowflake.rs

@@ -18,13 +18,13 @@ pub struct SnowflakeDialect;
 impl Dialect for SnowflakeDialect {
     // see https://docs.snowflake.com/en/sql-reference/identifiers-syntax.html
     fn is_identifier_start(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch) || ('A'..='Z').contains(&ch) || ch == '_'
+        ch.is_ascii_lowercase() || ch.is_ascii_uppercase() || ch == '_'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
-            || ('0'..='9').contains(&ch)
+        ch.is_ascii_lowercase()
+            || ch.is_ascii_uppercase()
+            || ch.is_ascii_digit()
             || ch == '$'
             || ch == '_'
     }

src/dialect/sqlite.rs

@@ -25,14 +25,14 @@ impl Dialect for SQLiteDialect {
 
     fn is_identifier_start(&self, ch: char) -> bool {
         // See https://www.sqlite.org/draft/tokenreq.html
-        ('a'..='z').contains(&ch)
-            || ('A'..='Z').contains(&ch)
+        ch.is_ascii_lowercase()
+            || ch.is_ascii_uppercase()
             || ch == '_'
             || ch == '$'
             || ('\u{007f}'..='\u{ffff}').contains(&ch)
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        self.is_identifier_start(ch) || ('0'..='9').contains(&ch)
+        self.is_identifier_start(ch) || ch.is_ascii_digit()
     }
 }

src/parser.rs

@@ -2919,7 +2919,11 @@ impl<'a> Parser<'a> {
     /// Parse a literal string
     pub fn parse_literal_string(&mut self) -> Result<String, ParserError> {
         match self.next_token() {
-            Token::Word(Word { value, keyword, .. }) if keyword == Keyword::NoKeyword => Ok(value),
+            Token::Word(Word {
+                value,
+                keyword: Keyword::NoKeyword,
+                ..
+            }) => Ok(value),
             Token::SingleQuotedString(s) => Ok(s),
             Token::EscapedStringLiteral(s) if dialect_of!(self is PostgreSqlDialect | GenericDialect) => {
                 Ok(s)
@@ -3823,13 +3827,7 @@ impl<'a> Parser<'a> {
             None
         };
         let object_name = match db_name {
-            Some(db_name) => ObjectName(
-                db_name
-                    .0
-                    .into_iter()
-                    .chain(table_name.0.into_iter())
-                    .collect(),
-            ),
+            Some(db_name) => ObjectName(db_name.0.into_iter().chain(table_name.0).collect()),
             None => table_name,
         };
         let filter = self.parse_show_statement_filter()?;

src/tokenizer.rs

@@ -214,7 +214,7 @@ impl Token {
         Token::Word(Word {
             value: word.to_string(),
             quote_style,
-            keyword: if quote_style == None {
+            keyword: if quote_style.is_none() {
                 let keyword = ALL_KEYWORDS.binary_search(&word_uppercase.as_str());
                 keyword.map_or(Keyword::NoKeyword, |x| ALL_KEYWORDS_INDEX[x])
             } else {
@@ -339,8 +339,12 @@ impl<'a> Tokenizer<'a> {
                 }
 
                 Token::Whitespace(Whitespace::Tab) => self.col += 4,
-                Token::Word(w) if w.quote_style == None => self.col += w.value.len() as u64,
-                Token::Word(w) if w.quote_style != None => self.col += w.value.len() as u64 + 2,
+                Token::Word(w) => {
+                    self.col += w.value.len() as u64;
+                    if w.quote_style.is_some() {
+                        self.col += 2;
+                    }
+                }
                 Token::Number(s, _) => self.col += s.len() as u64,
                 Token::SingleQuotedString(s) => self.col += s.len() as u64,
                 Token::Placeholder(s) => self.col += s.len() as u64,
@@ -420,7 +424,7 @@ impl<'a> Tokenizer<'a> {
                     chars.next(); // consume the first char
                     let s = self.tokenize_word(ch, chars);
 
-                    if s.chars().all(|x| ('0'..='9').contains(&x) || x == '.') {
+                    if s.chars().all(|x| x.is_ascii_digit() || x == '.') {
                         let mut s = peeking_take_while(&mut s.chars().peekable(), |ch| {
                             matches!(ch, '0'..='9' | '.')
                         });
@@ -458,15 +462,12 @@ impl<'a> Tokenizer<'a> {
                 }
                 // numbers and period
                 '0'..='9' | '.' => {
-                    let mut s = peeking_take_while(chars, |ch| matches!(ch, '0'..='9'));
+                    let mut s = peeking_take_while(chars, |ch| ch.is_ascii_digit());
 
                     // match binary literal that starts with 0x
                     if s == "0" && chars.peek() == Some(&'x') {
                         chars.next();
-                        let s2 = peeking_take_while(
-                            chars,
-                            |ch| matches!(ch, '0'..='9' | 'A'..='F' | 'a'..='f'),
-                        );
+                        let s2 = peeking_take_while(chars, |ch| ch.is_ascii_hexdigit());
                         return Ok(Some(Token::HexStringLiteral(s2)));
                     }
 
@@ -475,7 +476,7 @@ impl<'a> Tokenizer<'a> {
                         s.push('.');
                         chars.next();
                     }
-                    s += &peeking_take_while(chars, |ch| matches!(ch, '0'..='9'));
+                    s += &peeking_take_while(chars, |ch| ch.is_ascii_digit());
 
                     // No number -> Token::Period
                     if s == "." {

tests/sqlparser_mysql.rs

@@ -498,7 +498,7 @@ fn parse_escaped_string() {
     let sql = r#"SELECT 'I''m fine'"#;
 
     let projection = mysql().verified_only_select(sql).projection;
-    let item = projection.get(0).unwrap();
+    let item = projection.first().unwrap();
 
     match &item {
         SelectItem::UnnamedExpr(Expr::Value(value)) => {

tests/sqlparser_postgres.rs

@@ -1182,12 +1182,10 @@ fn parse_pg_regex_match_ops() {
 fn parse_array_index_expr() {
     #[cfg(feature = "bigdecimal")]
     let num: Vec<Expr> = (0..=10)
-        .into_iter()
         .map(|s| Expr::Value(Value::Number(bigdecimal::BigDecimal::from(s), false)))
         .collect();
     #[cfg(not(feature = "bigdecimal"))]
     let num: Vec<Expr> = (0..=10)
-        .into_iter()
         .map(|s| Expr::Value(Value::Number(s.to_string(), false)))
         .collect();