chore: Fix clippy issues

MazterQyou · MazterQyou · commit 01f890295ed4 · 2023-12-19T09:33:58.000+04:00
diff --git a/src/ast/mod.rs b/src/ast/mod.rs
@@ -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
diff --git a/src/dialect/ansi.rs b/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 == '_'
     }
 }
diff --git a/src/dialect/clickhouse.rs b/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()
     }
 }
diff --git a/src/dialect/generic.rs b/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 == '#'
diff --git a/src/dialect/hive.rs b/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 == '{'
diff --git a/src/dialect/mssql.rs b/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 == '#'
diff --git a/src/dialect/mysql.rs b/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 {
diff --git a/src/dialect/postgresql.rs b/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 == '_'
     }
diff --git a/src/dialect/snowflake.rs b/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 == '_'
     }
diff --git a/src/dialect/sqlite.rs b/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()
     }
 }
diff --git a/src/parser.rs b/src/parser.rs
@@ -3827,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()?;
diff --git a/src/tokenizer.rs b/src/tokenizer.rs
@@ -424,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' | '.')
                         });
@@ -462,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)));
                     }
 
@@ -479,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 == "." {
diff --git a/tests/sqlparser_mysql.rs b/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)) => {
diff --git a/tests/sqlparser_postgres.rs b/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();
 

Original file line number	Diff line number	Diff line change
`@@ -17,13 +17,10 @@ pub struct AnsiDialect {}`
`17`	`17`
`18`	`18`	`impl Dialect for AnsiDialect {`
`19`	`19`	`fn is_identifier_start(&self, ch: char) -> bool {`
`20`		`- ('a'..='z').contains(&ch) \|\| ('A'..='Z').contains(&ch)`
	`20`	`+ ch.is_ascii_lowercase() \|\| ch.is_ascii_uppercase()`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`fn is_identifier_part(&self, ch: char) -> bool {`
`24`		`- ('a'..='z').contains(&ch)`
`25`		`- \|\| ('A'..='Z').contains(&ch)`
`26`		`- \|\| ('0'..='9').contains(&ch)`
`27`		`- \|\| ch == '_'`
	`24`	`+ ch.is_ascii_lowercase() \|\| ch.is_ascii_uppercase() \|\| ch.is_ascii_digit() \|\| ch == '_'`
`28`	`25`	`}`
`29`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,10 +18,10 @@ pub struct ClickHouseDialect {}`
`18`	`18`	`impl Dialect for ClickHouseDialect {`
`19`	`19`	`fn is_identifier_start(&self, ch: char) -> bool {`
`20`	`20`	`// See https://clickhouse.com/docs/en/sql-reference/syntax/#syntax-identifiers`
`21`		`- ('a'..='z').contains(&ch) \|\| ('A'..='Z').contains(&ch) \|\| ch == '_'`
	`21`	`+ ch.is_ascii_lowercase() \|\| ch.is_ascii_uppercase() \|\| ch == '_'`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`fn is_identifier_part(&self, ch: char) -> bool {`
`25`		`- self.is_identifier_start(ch) \|\| ('0'..='9').contains(&ch)`
	`25`	`+ self.is_identifier_start(ch) \|\| ch.is_ascii_digit()`
`26`	`26`	`}`
`27`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,14 +25,14 @@ impl Dialect for SQLiteDialect {`
`25`	`25`
`26`	`26`	`fn is_identifier_start(&self, ch: char) -> bool {`
`27`	`27`	`// See https://www.sqlite.org/draft/tokenreq.html`
`28`		`- ('a'..='z').contains(&ch)`
`29`		`- \|\| ('A'..='Z').contains(&ch)`
	`28`	`+ ch.is_ascii_lowercase()`
	`29`	`+ \|\| ch.is_ascii_uppercase()`
`30`	`30`	`\|\| ch == '_'`
`31`	`31`	`\|\| ch == '$'`
`32`	`32`	`\|\| ('\u{007f}'..='\u{ffff}').contains(&ch)`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`fn is_identifier_part(&self, ch: char) -> bool {`
`36`		`- self.is_identifier_start(ch) \|\| ('0'..='9').contains(&ch)`
	`36`	`+ self.is_identifier_start(ch) \|\| ch.is_ascii_digit()`
`37`	`37`	`}`
`38`	`38`	`}`