Update Rust toolchain version to 1.76 (gluesql#1487)

* Update Rust toolchain version to 1.76 * Make clippy happy
langyo · May 15, 2024 · 23132bb · 23132bb
1 parent c4f905e
commit 23132bb
Show file tree

Hide file tree

Showing 18 changed files with 66 additions and 107 deletions.
diff --git a/core/src/ast/query.rs b/core/src/ast/query.rs
@@ -254,10 +254,7 @@ impl Select {
         let group_by = if group_by.is_empty() {
             "".to_owned()
         } else {
-            format!(
-                "GROUP BY {}",
-                group_by.iter().map(|item| to_sql(item)).join(", ")
-            )
+            format!("GROUP BY {}", group_by.iter().map(to_sql).join(", "))
         };
 
         let having = match having {

diff --git a/core/src/ast_builder/index_item/mod.rs b/core/src/ast_builder/index_item/mod.rs
@@ -54,9 +54,8 @@ impl<'a> Prebuild<IndexItem> for IndexItemNode<'a> {
             } => {
                 let (index_operator, expr) = cmp_expr.unzip();
                 let expr_result: Option<Expr> = expr.map(ExprNode::try_into).transpose()?;
-                let cmp_expr_result: Option<(IndexOperator, Expr)> = index_operator
-                    .zip(expr_result)
-                    .map(|(index_operator, expr)| (index_operator, expr));
+                let cmp_expr_result: Option<(IndexOperator, Expr)> =
+                    index_operator.zip(expr_result);
 
                 Ok(IndexItem::NonClustered {
                     name,

diff --git a/core/src/data/key.rs b/core/src/data/key.rs
@@ -95,28 +95,6 @@ impl Ord for Key {
 
 impl PartialOrd for Key {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        match (self, other) {
-            (Key::I8(l), Key::I8(r)) => Some(l.cmp(r)),
-            (Key::I16(l), Key::I16(r)) => Some(l.cmp(r)),
-            (Key::I32(l), Key::I32(r)) => Some(l.cmp(r)),
-            (Key::I64(l), Key::I64(r)) => Some(l.cmp(r)),
-            (Key::U8(l), Key::U8(r)) => Some(l.cmp(r)),
-            (Key::U16(l), Key::U16(r)) => Some(l.cmp(r)),
-            (Key::U32(l), Key::U32(r)) => Some(l.cmp(r)),
-            (Key::U64(l), Key::U64(r)) => Some(l.cmp(r)),
-            (Key::U128(l), Key::U128(r)) => Some(l.cmp(r)),
-            (Key::Decimal(l), Key::Decimal(r)) => Some(l.cmp(r)),
-            (Key::Bool(l), Key::Bool(r)) => Some(l.cmp(r)),
-            (Key::Str(l), Key::Str(r)) => Some(l.cmp(r)),
-            (Key::Bytea(l), Key::Bytea(r)) => Some(l.cmp(r)),
-            (Key::Inet(l), Key::Inet(r)) => Some(l.cmp(r)),
-            (Key::Date(l), Key::Date(r)) => Some(l.cmp(r)),
-            (Key::Timestamp(l), Key::Timestamp(r)) => Some(l.cmp(r)),
-            (Key::Time(l), Key::Time(r)) => Some(l.cmp(r)),
-            (Key::Interval(l), Key::Interval(r)) => l.partial_cmp(r),
-            (Key::Uuid(l), Key::Uuid(r)) => Some(l.cmp(r)),
-            _ => None,
-        };
         Some(self.cmp(other))
     }
 }

diff --git a/core/src/data/schema.rs b/core/src/data/schema.rs
@@ -101,7 +101,7 @@ impl Schema {
             })
             .collect::<Result<Vec<_>>>()?;
 
-        let create_table = statements.get(0).ok_or(SchemaParseError::CannotParseDDL)?;
+        let create_table = statements.first().ok_or(SchemaParseError::CannotParseDDL)?;
         let create_table = translate(create_table)?;
 
         match create_table {

diff --git a/core/src/data/value/literal.rs b/core/src/data/value/literal.rs
@@ -573,7 +573,7 @@ mod tests {
 
     #[test]
     fn evaluate_cmp_with_literal() {
-        let num = |n| Literal::Number(Cow::Owned(BigDecimal::try_from(n).unwrap()));
+        let num = |n| Literal::Number(Cow::Owned(BigDecimal::from(n)));
         let text = |v: &str| Literal::Text(Cow::Owned(v.to_owned()));
 
         let test = |value: Value, literal, expected| {

diff --git a/core/src/data/value/mod.rs b/core/src/data/value/mod.rs
@@ -878,7 +878,7 @@ impl Value {
         }
         let from = &String::from(self);
         let sub = &String::from(sub_val);
-        let position = str_position(&from[(start - 1) as usize..].to_owned(), sub) as i64;
+        let position = str_position(&from[(start - 1) as usize..], sub) as i64;
         let position = match position {
             0 => 0,
             _ => position + start - 1,
@@ -887,7 +887,7 @@ impl Value {
     }
 }
 
-fn str_position(from_str: &String, sub_str: &String) -> usize {
+fn str_position(from_str: &str, sub_str: &str) -> usize {
     if from_str.is_empty() || sub_str.is_empty() {
         return 0;
     }

diff --git a/core/src/executor/aggregate/state.rs b/core/src/executor/aggregate/state.rs
@@ -222,30 +222,23 @@ impl<'a, T: GStore> State<'a, T> {
             values, contexts, ..
         } = self;
 
-        stream::iter(
-            values
-                .into_iter()
-                .map(|(k, v)| (k, v))
-                .chunks(size)
-                .into_iter()
-                .enumerate(),
-        )
-        .then(|(i, entries)| {
-            let next = contexts.get(i).map(Rc::clone);
+        stream::iter(values.into_iter().chunks(size).into_iter().enumerate())
+            .then(|(i, entries)| {
+                let next = contexts.get(i).map(Rc::clone);
 
-            async move {
-                let aggregated = stream::iter(entries)
-                    .then(|((_, aggr), (_, aggr_value))| async move {
-                        aggr_value.export().await.map(|value| (aggr, value))
-                    })
-                    .try_collect::<HashMap<&'a Aggregate, Value>>()
-                    .await?;
+                async move {
+                    let aggregated = stream::iter(entries)
+                        .then(|((_, aggr), (_, aggr_value))| async move {
+                            aggr_value.export().await.map(|value| (aggr, value))
+                        })
+                        .try_collect::<HashMap<&'a Aggregate, Value>>()
+                        .await?;
 
-                Ok((Some(aggregated), next))
-            }
-        })
-        .try_collect::<Vec<(Option<ValuesMap<'a>>, Option<Rc<RowContext<'a>>>)>>()
-        .await
+                    Ok((Some(aggregated), next))
+                }
+            })
+            .try_collect::<Vec<(Option<ValuesMap<'a>>, Option<Rc<RowContext<'a>>>)>>()
+            .await
     }
 
     pub async fn accumulate(

diff --git a/core/src/executor/join.rs b/core/src/executor/join.rs
@@ -139,7 +139,7 @@ async fn join<'a, T: GStore>(
                                 storage,
                                 table_alias,
                                 filter_context.as_ref().map(Rc::clone),
-                                Some(&project_context).map(Rc::clone),
+                                Some(Rc::clone(&project_context)),
                                 where_clause,
                                 row,
                             )
@@ -166,7 +166,7 @@ async fn join<'a, T: GStore>(
                             let rows = stream::iter(rows)
                                 .filter_map(|row| {
                                     let filter_context = filter_context.as_ref().map(Rc::clone);
-                                    let project_context = Some(&project_context).map(Rc::clone);
+                                    let project_context = Some(Rc::clone(&project_context));
 
                                     async {
                                         check_where_clause(
@@ -248,14 +248,10 @@ impl<'a> JoinExecutor<'a> {
                         filter_context,
                     ));
 
-                    let hash_key: Key = evaluate(
-                        storage,
-                        Some(&filter_context).map(Rc::clone),
-                        None,
-                        key_expr,
-                    )
-                    .await?
-                    .try_into()?;
+                    let hash_key: Key =
+                        evaluate(storage, Some(Rc::clone(&filter_context)), None, key_expr)
+                            .await?
+                            .try_into()?;
 
                     if matches!(hash_key, Key::None) {
                         return Ok(None);

diff --git a/core/src/mock.rs b/core/src/mock.rs
@@ -90,6 +90,7 @@ impl AlterTable for MockStorage {}
 impl Index for MockStorage {}
 impl IndexMut for MockStorage {}
 impl Transaction for MockStorage {}
+impl Metadata for MockStorage {}
 
 #[cfg(test)]
 mod tests {
@@ -158,5 +159,3 @@ mod tests {
         assert!(matches!(block_on(storage.fetch_schema("Foo")), Ok(None)));
     }
 }
-
-impl Metadata for MockStorage {}
diff --git a/core/src/translate/data_type.rs b/core/src/translate/data_type.rs
@@ -29,7 +29,7 @@ pub fn translate_data_type(sql_data_type: &SqlDataType) -> Result<DataType> {
         SqlDataType::Uuid => Ok(DataType::Uuid),
         SqlDataType::Decimal(SqlExactNumberInfo::None) => Ok(DataType::Decimal),
         SqlDataType::Custom(name, _idents) => {
-            let name = name.0.get(0).map(|v| v.value.to_uppercase());
+            let name = name.0.first().map(|v| v.value.to_uppercase());
 
             match name.as_deref() {
                 Some("MAP") => Ok(DataType::Map),

diff --git a/core/src/translate/mod.rs b/core/src/translate/mod.rs
@@ -213,7 +213,7 @@ pub fn translate(sql_statement: &SqlStatement) -> Result<Statement> {
         SqlStatement::ShowFunctions { filter: None } => {
             Ok(Statement::ShowVariable(Variable::Functions))
         }
-        SqlStatement::ShowVariable { variable } => match (variable.len(), variable.get(0)) {
+        SqlStatement::ShowVariable { variable } => match (variable.len(), variable.first()) {
             (1, Some(keyword)) => match keyword.value.to_uppercase().as_str() {
                 "VERSION" => Ok(Statement::ShowVariable(Variable::Version)),
                 v => Err(TranslateError::UnsupportedShowVariableKeyword(v.to_owned()).into()),
@@ -280,7 +280,7 @@ pub fn translate_assignment(sql_assignment: &SqlAssignment) -> Result<Assignment
 
     Ok(Assignment {
         id: id
-            .get(0)
+            .first()
             .ok_or(TranslateError::UnreachableEmptyIdent)?
             .value
             .to_owned(),
@@ -306,7 +306,7 @@ fn translate_object_name(sql_object_name: &SqlObjectName) -> Result<String> {
     }
 
     sql_object_name
-        .get(0)
+        .first()
         .map(|v| v.value.to_owned())
         .ok_or_else(|| TranslateError::UnreachableEmptyObject.into())
 }

diff --git a/core/src/translate/query.rs b/core/src/translate/query.rs
@@ -80,7 +80,7 @@ fn translate_select(sql_select: &SqlSelect) -> Result<Select> {
         return Err(TranslateError::SelectDistinctNotSupported.into());
     }
 
-    let from = match from.get(0) {
+    let from = match from.first() {
         Some(sql_table_with_joins) => translate_table_with_joins(sql_table_with_joins)?,
         None => TableWithJoins {
             relation: TableFactor::Series {
@@ -170,7 +170,7 @@ fn translate_table_factor(sql_table_factor: &SqlTableFactor) -> Result<TableFact
             })
             .collect::<Result<Vec<_>>>()?;
 
-        match translate_function_arg_exprs(function_arg_exprs)?.get(0) {
+        match translate_function_arg_exprs(function_arg_exprs)?.first() {
             Some(expr) => Ok(translate_expr(expr)?),
             None => Err(TranslateError::LackOfArgs.into()),
         }

diff --git a/rust-toolchain.toml b/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "1.72"
+channel = "1.76"
 components = ["rustfmt", "clippy"]
diff --git a/storages/json-storage/src/store_mut.rs b/storages/json-storage/src/store_mut.rs
@@ -69,7 +69,6 @@ impl StoreMut for JsonStorage {
                 .map_storage_err(JsonStorageError::TableDoesNotExist)?;
 
             let file = OpenOptions::new()
-                .write(true)
                 .append(true)
                 .open(self.jsonl_path(&schema.table_name))
                 .map_storage_err()?;

diff --git a/storages/sled-storage/src/alter_table.rs b/storages/sled-storage/src/alter_table.rs
@@ -176,10 +176,9 @@ impl AlterTable for SledStorage {
                 .iter()
                 .any(|ColumnDef { name, .. }| name == new_column_name)
             {
-                return Err(
+                return Err(ConflictableTransactionError::Abort(
                     AlterTableError::AlreadyExistingColumn(new_column_name.to_owned()).into(),
-                )
-                .map_err(ConflictableTransactionError::Abort);
+                ));
             }
 
             let i = column_defs
@@ -282,8 +281,9 @@ impl AlterTable for SledStorage {
             {
                 let adding_column = column_def.name.to_owned();
 
-                return Err(AlterTableError::AlreadyExistingColumn(adding_column).into())
-                    .map_err(ConflictableTransactionError::Abort);
+                return Err(ConflictableTransactionError::Abort(
+                    AlterTableError::AlreadyExistingColumn(adding_column).into(),
+                ));
             }
 
             let ColumnDef {
@@ -304,8 +304,9 @@ impl AlterTable for SledStorage {
                 }
                 (None, true) => Value::Null,
                 (None, false) => {
-                    return Err(AlterTableError::DefaultValueRequired(column_def.clone()).into())
-                        .map_err(ConflictableTransactionError::Abort);
+                    return Err(ConflictableTransactionError::Abort(
+                        AlterTableError::DefaultValueRequired(column_def.clone()).into(),
+                    ));
                 }
             };
 
@@ -324,10 +325,9 @@ impl AlterTable for SledStorage {
                 let values = match row {
                     DataRow::Vec(values) => values,
                     DataRow::Map(_) => {
-                        return Err(Error::StorageMsg(
+                        return Err(ConflictableTransactionError::Abort(Error::StorageMsg(
                             "conflict - add_column failed: schemaless row found".to_owned(),
-                        ))
-                        .map_err(ConflictableTransactionError::Abort);
+                        )));
                     }
                 };
                 let row = values
@@ -439,10 +439,9 @@ impl AlterTable for SledStorage {
                     return Ok(TxPayload::Success);
                 }
                 (None, false) => {
-                    return Err(
+                    return Err(ConflictableTransactionError::Abort(
                         AlterTableError::DroppingColumnNotFound(column_name.to_owned()).into(),
-                    )
-                    .map_err(ConflictableTransactionError::Abort);
+                    ));
                 }
             };
 
@@ -461,10 +460,9 @@ impl AlterTable for SledStorage {
                 let values = match row {
                     DataRow::Vec(values) => values,
                     DataRow::Map(_) => {
-                        return Err(Error::StorageMsg(
+                        return Err(ConflictableTransactionError::Abort(Error::StorageMsg(
                             "conflict - drop_column failed: schemaless row found".to_owned(),
-                        ))
-                        .map_err(ConflictableTransactionError::Abort);
+                        )));
                     }
                 };
 

diff --git a/storages/sled-storage/src/index_mut.rs b/storages/sled-storage/src/index_mut.rs
@@ -81,8 +81,9 @@ impl IndexMut for SledStorage {
                 .map_err(ConflictableTransactionError::Abort)?;
 
             if indexes.iter().any(|index| index.name == index_name) {
-                return Err(IndexError::IndexNameAlreadyExists(index_name.to_owned()).into())
-                    .map_err(ConflictableTransactionError::Abort);
+                return Err(ConflictableTransactionError::Abort(
+                    IndexError::IndexNameAlreadyExists(index_name.to_owned()).into(),
+                ));
             }
 
             let index = SchemaIndex {
@@ -180,8 +181,9 @@ impl IndexMut for SledStorage {
             let index = match index.into_iter().next() {
                 Some(index) => index,
                 None => {
-                    return Err(IndexError::IndexNameDoesNotExist(index_name.to_owned()).into())
-                        .map_err(ConflictableTransactionError::Abort);
+                    return Err(ConflictableTransactionError::Abort(
+                        IndexError::IndexNameDoesNotExist(index_name.to_owned()).into(),
+                    ));
                 }
             };
 

diff --git a/storages/sled-storage/src/lock.rs b/storages/sled-storage/src/lock.rs
@@ -121,10 +121,9 @@ pub fn acquire(
             autocommit,
         } => (*txid, *created_at, *autocommit),
         State::Idle => {
-            return Err(Error::StorageMsg(
+            return Err(ConflictableTransactionError::Abort(Error::StorageMsg(
                 "conflict - cannot acquire lock from idle state".to_owned(),
-            ))
-            .map_err(ConflictableTransactionError::Abort);
+            )));
         }
     };
 
@@ -135,24 +134,23 @@ pub fn acquire(
         .as_millis();
 
     if tx_timeout.map(|tx_timeout| now - created_at >= tx_timeout) == Some(true) {
-        return Err(Error::StorageMsg(
+        return Err(ConflictableTransactionError::Abort(Error::StorageMsg(
             "acquire failed - expired transaction has used (timeout)".to_owned(),
-        ))
-        .map_err(ConflictableTransactionError::Abort);
+        )));
     } else if gc_txid.is_some() && Some(txid) <= gc_txid {
-        return Err(Error::StorageMsg(
+        return Err(ConflictableTransactionError::Abort(Error::StorageMsg(
             "acquire failed - expired transaction has used (txid)".to_owned(),
-        ))
-        .map_err(ConflictableTransactionError::Abort);
+        )));
     }
 
     let txid = match lock_txid {
         Some(lock_txid) => {
             if tx_timeout.map(|tx_timeout| now - lock_created_at >= tx_timeout) == Some(true) {
                 return Ok(LockAcquired::RollbackAndRetry { lock_txid });
             } else if txid != lock_txid {
-                return Err(Error::StorageMsg("database is locked".to_owned()))
-                    .map_err(ConflictableTransactionError::Abort);
+                return Err(ConflictableTransactionError::Abort(Error::StorageMsg(
+                    "database is locked".to_owned(),
+                )));
             }
 
             txid