Enable clippy::pedantic

.clippy.toml

@@ -0,0 +1,9 @@
+doc-valid-idents = [
+	"SeaQL",
+	"SeaQuery",
+	"MySQL",
+	"SQLite",
+	"MariaDB",
+	"PostgreSQL",
+	"..",
+]

.github/workflows/rust.yml

@@ -55,7 +55,7 @@ jobs:
         with:
           toolchain: stable
           components: clippy
-      - run: cargo clippy --features=all-features --workspace -- -D warnings
+      - run: cargo clippy --features=all-features --workspace -- -D warnings -A clippy::semicolon_if_nothing_returned
       - run: cargo clippy --manifest-path sea-query-sqlx/Cargo.toml --workspace --features runtime-async-std-rustls --features=with-chrono,with-json,with-rust_decimal,with-bigdecimal,with-uuid,with-time,with-ipnetwork,with-mac_address,postgres-array,postgres-vector -- -D warnings
       - run: cargo clippy --manifest-path sea-query-rusqlite/Cargo.toml --all-features --workspace -- -D warnings
       - run: cargo clippy --manifest-path sea-query-postgres/Cargo.toml --all-features --workspace -- -D warnings

src/audit/common.rs

@@ -3,9 +3,9 @@ use crate::TableRef;
 
 pub(super) fn parse_audit_table(table_ref: &TableRef) -> Option<SchemaTable> {
     match table_ref {
-        TableRef::SubQuery(_, _) => None,
-        TableRef::FunctionCall(_, _) => None,
         TableRef::Table(tbl, _) => Some(tbl.clone()),
-        TableRef::ValuesList(_, _) => None,
+        TableRef::ValuesList(_, _) | TableRef::FunctionCall(_, _) | TableRef::SubQuery(_, _) => {
+            None
+        }
     }
 }

src/audit/insert.rs

@@ -22,7 +22,7 @@ impl AuditTrait for InsertStatement {
         });
 
         if let Some(InsertValueSource::Select(select)) = &self.source {
-            requests.append(&mut select.audit()?.requests)
+            requests.append(&mut select.audit()?.requests);
         }
 
         if let Some(with) = &self.with {

src/audit/mod.rs

@@ -71,25 +71,25 @@ impl QueryAccessAudit {
             .collect()
     }
 
-    /// Warning: this discards the schema part of SchemaTable.
+    /// Warning: this discards the schema part of [`SchemaTable`].
     /// Intended for testing only.
     pub fn selected_tables(&self) -> Vec<DynIden> {
         self.filter_table_with_access_type(AccessType::Select)
     }
 
-    /// Warning: this discards the schema part of SchemaTable.
+    /// Warning: this discards the schema part of [`SchemaTable`].
     /// Intended for testing only.
     pub fn inserted_tables(&self) -> Vec<DynIden> {
         self.filter_table_with_access_type(AccessType::Insert)
     }
 
-    /// Warning: this discards the schema part of SchemaTable.
+    /// Warning: this discards the schema part of [`SchemaTable`].
     /// Intended for testing only.
     pub fn updated_tables(&self) -> Vec<DynIden> {
         self.filter_table_with_access_type(AccessType::Update)
     }
 
-    /// Warning: this discards the schema part of SchemaTable.
+    /// Warning: this discards the schema part of [`SchemaTable`].
     /// Intended for testing only.
     pub fn deleted_tables(&self) -> Vec<DynIden> {
         self.filter_table_with_access_type(AccessType::Delete)

src/audit/select.rs

@@ -109,26 +109,26 @@ impl Walker {
 
     fn recurse_audit_expr(&mut self, expr: &Expr) -> Result<(), Error> {
         match expr {
-            Expr::Column(_) => (),
             Expr::Unary(_, expr) | Expr::AsEnum(_, expr) => self.recurse_audit_expr(expr)?,
             Expr::FunctionCall(function) => self.recurse_audit_function(function)?,
             Expr::Binary(left, _, right) => {
                 self.recurse_audit_expr(left)?;
                 self.recurse_audit_expr(right)?;
             }
             Expr::SubQuery(_, subquery) => self.recurse_audit_subquery(subquery)?,
-            Expr::Value(_) => (),
-            Expr::Values(_) => (),
-            Expr::Custom(_) => (),
             Expr::CustomWithExpr(_, exprs) | Expr::Tuple(exprs) => {
                 for expr in exprs {
                     self.recurse_audit_expr(expr)?;
                 }
             }
-            Expr::Keyword(_) => (),
             Expr::Case(case) => self.recurse_audit_case(case)?,
-            Expr::Constant(_) => (),
-            Expr::TypeName(_) => (),
+            Expr::Value(_)
+            | Expr::Column(_)
+            | Expr::Values(_)
+            | Expr::Custom(_)
+            | Expr::Keyword(_)
+            | Expr::Constant(_)
+            | Expr::TypeName(_) => (),
         }
         Ok(())
     }
@@ -213,13 +213,14 @@ impl Walker {
             ConditionHolderContents::Chain(chain) => {
                 for oper in chain {
                     match oper {
-                        LogicalChainOper::And(expr) => self.recurse_audit_expr(expr)?,
-                        LogicalChainOper::Or(expr) => self.recurse_audit_expr(expr)?,
+                        LogicalChainOper::Or(expr) | LogicalChainOper::And(expr) => {
+                            self.recurse_audit_expr(expr)?;
+                        }
                     }
                 }
             }
             ConditionHolderContents::Condition(condition) => {
-                self.recurse_audit_condition(condition)?
+                self.recurse_audit_condition(condition)?;
             }
         }
         Ok(())
@@ -262,7 +263,7 @@ fn wrap_result(access: Vec<QueryAccessRequest>) -> QueryAccessAudit {
                     AccessType::Insert => &mut insert_set,
                     AccessType::Update => &mut update_set,
                     AccessType::Delete => &mut delete_set,
-                    _ => todo!(),
+                    AccessType::Schema(_) => todo!(),
                 };
                 if set.contains(&access.schema_table) {
                     None

src/backend/foreign_key_builder.rs

@@ -15,7 +15,7 @@ pub trait ForeignKeyBuilder: QuotedBuilder + TableRefBuilder {
         create: &ForeignKeyCreateStatement,
         sql: &mut dyn SqlWriter,
     ) {
-        self.prepare_foreign_key_create_statement_internal(create, sql, Mode::Alter)
+        self.prepare_foreign_key_create_statement_internal(create, sql, Mode::Alter);
     }
 
     /// Translate [`ForeignKeyDropStatement`] into SQL statement.
@@ -24,7 +24,7 @@ pub trait ForeignKeyBuilder: QuotedBuilder + TableRefBuilder {
         drop: &ForeignKeyDropStatement,
         sql: &mut dyn SqlWriter,
     ) {
-        self.prepare_foreign_key_drop_statement_internal(drop, sql, Mode::Alter)
+        self.prepare_foreign_key_drop_statement_internal(drop, sql, Mode::Alter);
     }
 
     /// Translate [`ForeignKeyAction`] into SQL statement.
@@ -44,7 +44,7 @@ pub trait ForeignKeyBuilder: QuotedBuilder + TableRefBuilder {
                 ForeignKeyAction::SetDefault => "SET DEFAULT",
             }
         )
-        .unwrap()
+        .unwrap();
     }
 
     /// Translate [`TableRef`] into SQL statement.

src/backend/mod.rs

@@ -51,9 +51,9 @@ pub trait QuotedBuilder {
             Cow::Owned(s) => {
                 for char in s.chars() {
                     if char == qq {
-                        sql.write_char(char).unwrap()
+                        sql.write_char(char).unwrap();
                     }
-                    sql.write_char(char).unwrap()
+                    sql.write_char(char).unwrap();
                 }
             }
         };
@@ -93,7 +93,7 @@ pub trait EscapeBuilder {
                 '\r' => buffer.write_str("\\r"),
                 _ => buffer.write_char(c),
             }
-            .unwrap()
+            .unwrap();
         }
     }
 
@@ -164,45 +164,31 @@ impl Oper {
     pub(crate) fn is_logical(&self) -> bool {
         matches!(
             self,
-            Oper::UnOper(UnOper::Not) | Oper::BinOper(BinOper::And) | Oper::BinOper(BinOper::Or)
+            Oper::UnOper(UnOper::Not) | Oper::BinOper(BinOper::And | BinOper::Or)
         )
     }
 
     pub(crate) fn is_between(&self) -> bool {
-        matches!(
-            self,
-            Oper::BinOper(BinOper::Between) | Oper::BinOper(BinOper::NotBetween)
-        )
+        matches!(self, Oper::BinOper(BinOper::Between | BinOper::NotBetween))
     }
 
     pub(crate) fn is_like(&self) -> bool {
-        matches!(
-            self,
-            Oper::BinOper(BinOper::Like) | Oper::BinOper(BinOper::NotLike)
-        )
+        matches!(self, Oper::BinOper(BinOper::Like | BinOper::NotLike))
     }
 
     pub(crate) fn is_in(&self) -> bool {
-        matches!(
-            self,
-            Oper::BinOper(BinOper::In) | Oper::BinOper(BinOper::NotIn)
-        )
+        matches!(self, Oper::BinOper(BinOper::In | BinOper::NotIn))
     }
 
     pub(crate) fn is_is(&self) -> bool {
-        matches!(
-            self,
-            Oper::BinOper(BinOper::Is) | Oper::BinOper(BinOper::IsNot)
-        )
+        matches!(self, Oper::BinOper(BinOper::Is | BinOper::IsNot))
     }
 
     pub(crate) fn is_shift(&self) -> bool {
-        matches!(
-            self,
-            Oper::BinOper(BinOper::LShift) | Oper::BinOper(BinOper::RShift)
-        )
+        matches!(self, Oper::BinOper(BinOper::LShift | BinOper::RShift))
     }
 
+    #[allow(clippy::match_wildcard_for_single_variants)]
     pub(crate) fn is_arithmetic(&self) -> bool {
         match self {
             Oper::BinOper(b) => {
@@ -215,6 +201,7 @@ impl Oper {
         }
     }
 
+    #[allow(clippy::match_wildcard_for_single_variants)]
     pub(crate) fn is_comparison(&self) -> bool {
         match self {
             Oper::BinOper(b) => {

src/backend/mysql/foreign_key.rs

@@ -5,7 +5,7 @@ impl ForeignKeyBuilder for MysqlQueryBuilder {
         match table_ref {
             // Support only "naked" table names with no schema or alias.
             TableRef::Table(TableName(None, _), None) => {
-                self.prepare_table_ref_iden(table_ref, sql)
+                self.prepare_table_ref_iden(table_ref, sql);
             }
             _ => panic!("Not supported"),
         }

src/backend/mysql/index.rs

@@ -62,7 +62,7 @@ impl IndexBuilder for MysqlQueryBuilder {
         match table_ref {
             // Support only "naked" table names with no schema or alias.
             TableRef::Table(TableName(None, _), None) => {
-                self.prepare_table_ref_iden(table_ref, sql)
+                self.prepare_table_ref_iden(table_ref, sql);
             }
             _ => panic!("Not supported"),
         }

src/backend/mysql/query.rs

@@ -2,7 +2,7 @@ use super::*;
 use crate::extension::mysql::*;
 
 impl QueryBuilder for MysqlQueryBuilder {
-    fn values_list_tuple_prefix(&self) -> &str {
+    fn values_list_tuple_prefix(&self) -> &'static str {
         "ROW"
     }
 
@@ -21,24 +21,24 @@ impl QueryBuilder for MysqlQueryBuilder {
         }
         for (i, hint) in select.index_hints.iter().enumerate() {
             if i != 0 {
-                write!(sql, " ").unwrap()
+                write!(sql, " ").unwrap();
             }
             match hint.r#type {
                 IndexHintType::Use => {
                     write!(sql, "USE INDEX ",).unwrap();
-                    self.prepare_index_hint_scope(&hint.scope, sql);
+                    Self::prepare_index_hint_scope(hint.scope, sql);
                     write!(sql, "(").unwrap();
                     self.prepare_iden(&hint.index, sql);
                 }
                 IndexHintType::Ignore => {
                     write!(sql, "IGNORE INDEX ",).unwrap();
-                    self.prepare_index_hint_scope(&hint.scope, sql);
+                    Self::prepare_index_hint_scope(hint.scope, sql);
                     write!(sql, "(").unwrap();
                     self.prepare_iden(&hint.index, sql);
                 }
                 IndexHintType::Force => {
                     write!(sql, "FORCE INDEX ",).unwrap();
-                    self.prepare_index_hint_scope(&hint.scope, sql);
+                    Self::prepare_index_hint_scope(hint.scope, sql);
                     write!(sql, "(").unwrap();
                     self.prepare_iden(&hint.index, sql);
                 }
@@ -90,19 +90,15 @@ impl QueryBuilder for MysqlQueryBuilder {
         column: &DynIden,
         sql: &mut dyn SqlWriter,
     ) {
-        use std::ops::Deref;
-
         if !from.is_empty() {
-            if let Some(table) = table {
+            if let Some(TableRef::Table(TableName(None, table), None)) = table.as_deref() {
                 // Support only "naked" table names with no schema or alias.
-                if let TableRef::Table(TableName(None, table), None) = table.deref() {
-                    let column_name = ColumnName::from((table.clone(), column.clone()));
-                    self.prepare_column_ref(&ColumnRef::Column(column_name), sql);
-                    return;
-                }
+                let column_name = ColumnName::from((table.clone(), column.clone()));
+                self.prepare_column_ref(&ColumnRef::Column(column_name), sql);
+                return;
             }
         }
-        self.prepare_iden(column, sql)
+        self.prepare_iden(column, sql);
     }
 
     fn prepare_update_condition(
@@ -129,11 +125,11 @@ impl QueryBuilder for MysqlQueryBuilder {
             None => (),
             Some(NullOrdering::Last) => {
                 self.prepare_simple_expr(&order_expr.expr, sql);
-                write!(sql, " IS NULL ASC, ").unwrap()
+                write!(sql, " IS NULL ASC, ").unwrap();
             }
             Some(NullOrdering::First) => {
                 self.prepare_simple_expr(&order_expr.expr, sql);
-                write!(sql, " IS NULL DESC, ").unwrap()
+                write!(sql, " IS NULL DESC, ").unwrap();
             }
         }
         if !matches!(order_expr.order, Order::Field(_)) {
@@ -157,19 +153,19 @@ impl QueryBuilder for MysqlQueryBuilder {
     ) {
         match on_conflict_action {
             Some(OnConflictAction::DoNothing(pk_cols)) => {
-                if !pk_cols.is_empty() {
+                if pk_cols.is_empty() {
+                    write!(sql, " IGNORE").unwrap();
+                } else {
                     self.prepare_on_conflict_do_update_keywords(sql);
                     pk_cols.iter().fold(true, |first, pk_col| {
                         if !first {
-                            write!(sql, ", ").unwrap()
+                            write!(sql, ", ").unwrap();
                         }
                         self.prepare_iden(pk_col, sql);
                         write!(sql, " = ").unwrap();
                         self.prepare_iden(pk_col, sql);
                         false
                     });
-                } else {
-                    write!(sql, " IGNORE").unwrap();
                 }
             }
             _ => self.prepare_on_conflict_action_common(on_conflict_action, sql),
@@ -194,17 +190,17 @@ impl QueryBuilder for MysqlQueryBuilder {
 
     fn prepare_returning(&self, _returning: &Option<ReturningClause>, _sql: &mut dyn SqlWriter) {}
 
-    fn random_function(&self) -> &str {
+    fn random_function(&self) -> &'static str {
         "RAND"
     }
 
-    fn insert_default_keyword(&self) -> &str {
+    fn insert_default_keyword(&self) -> &'static str {
         "()"
     }
 }
 
 impl MysqlQueryBuilder {
-    fn prepare_index_hint_scope(&self, index_hint_scope: &IndexHintScope, sql: &mut dyn SqlWriter) {
+    fn prepare_index_hint_scope(index_hint_scope: IndexHintScope, sql: &mut dyn SqlWriter) {
         match index_hint_scope {
             IndexHintScope::Join => {
                 write!(sql, "FOR JOIN ").unwrap();