clippy fix

core/storage/btree.rs

@@ -90,9 +90,9 @@ impl BTreeCursor {
         Ok(CursorResult::Ok(page.cell_count() == 0))
     }
 
-    fn get_next_record<'a>(
+    fn get_next_record(
         &mut self,
-        predicate: Option<(SeekKey<'a>, SeekOp)>,
+        predicate: Option<(SeekKey<'_>, SeekOp)>,
     ) -> Result<CursorResult<(Option<u64>, Option<OwnedRecord>)>> {
         loop {
             let mem_page = self.get_mem_page();
@@ -230,9 +230,9 @@ impl BTreeCursor {
         }
     }
 
-    fn seek<'a>(
+    fn seek(
         &mut self,
-        key: SeekKey<'a>,
+        key: SeekKey<'_>,
         op: SeekOp,
     ) -> Result<CursorResult<(Option<u64>, Option<OwnedRecord>)>> {
         match self.move_to(key.clone(), op.clone())? {
@@ -368,7 +368,7 @@ impl BTreeCursor {
         }
     }
 
-    pub fn move_to<'a>(&mut self, key: SeekKey<'a>, cmp: SeekOp) -> Result<CursorResult<()>> {
+    pub fn move_to(&mut self, key: SeekKey<'_>, cmp: SeekOp) -> Result<CursorResult<()>> {
         // For a table with N rows, we can find any row by row id in O(log(N)) time by starting at the root page and following the B-tree pointers.
         // B-trees consist of interior pages and leaf pages. Interior pages contain pointers to other pages, while leaf pages contain the actual row data.
         //

core/translate/emitter.rs

@@ -4,7 +4,7 @@ use std::rc::Rc;
 
 use sqlite3_parser::ast;
 
-use crate::schema::{BTreeTable, Column, PseudoTable, Table};
+use crate::schema::{Column, PseudoTable, Table};
 use crate::storage::sqlite3_ondisk::DatabaseHeader;
 use crate::translate::expr::resolve_ident_pseudo_table;
 use crate::translate::plan::Search;

core/translate/expr.rs

@@ -1,15 +1,11 @@
 use crate::{function::JsonFunc, Result};
 use sqlite3_parser::ast::{self, UnaryOperator};
-use std::rc::Rc;
 
 use super::optimizer::CachedResult;
 use crate::function::{AggFunc, Func, FuncCtx, ScalarFunc};
 use crate::schema::{PseudoTable, Table, Type};
 use crate::util::normalize_ident;
-use crate::{
-    schema::BTreeTable,
-    vdbe::{builder::ProgramBuilder, BranchOffset, Insn},
-};
+use crate::vdbe::{builder::ProgramBuilder, BranchOffset, Insn};
 
 use super::plan::{Aggregate, BTreeTableReference};
 

core/translate/optimizer.rs

@@ -2,11 +2,7 @@ use std::{collections::HashMap, rc::Rc};
 
 use sqlite3_parser::ast;
 
-use crate::{
-    schema::{BTreeTable, Index},
-    util::normalize_ident,
-    Result,
-};
+use crate::{schema::Index, util::normalize_ident, Result};
 
 use super::plan::{
     get_table_ref_bitmask_for_ast_expr, get_table_ref_bitmask_for_operator, BTreeTableReference,
@@ -58,16 +54,16 @@ fn _operator_is_already_ordered_by(
     match operator {
         Operator::Scan {
             table_reference, ..
-        } => Ok(key.is_primary_key_of(&table_reference)),
+        } => Ok(key.is_primary_key_of(table_reference)),
         Operator::Search {
             table_reference,
             search,
             ..
         } => match search {
-            Search::PrimaryKeyEq { .. } => Ok(key.is_primary_key_of(&table_reference)),
-            Search::PrimaryKeySearch { .. } => Ok(key.is_primary_key_of(&table_reference)),
+            Search::PrimaryKeyEq { .. } => Ok(key.is_primary_key_of(table_reference)),
+            Search::PrimaryKeySearch { .. } => Ok(key.is_primary_key_of(table_reference)),
             Search::IndexSearch { index, .. } => {
-                let index_idx = key.check_index_scan(&table_reference, available_indexes)?;
+                let index_idx = key.check_index_scan(table_reference, available_indexes)?;
                 let index_is_the_same = index_idx
                     .map(|i| Rc::ptr_eq(&available_indexes[i], index))
                     .unwrap_or(false);

core/translate/planner.rs

@@ -1,12 +1,6 @@
 use super::plan::{Aggregate, BTreeTableReference, Direction, Operator, Plan, ProjectionColumn};
-use crate::{
-    function::Func,
-    schema::{BTreeTable, Schema},
-    util::normalize_ident,
-    Result,
-};
+use crate::{function::Func, schema::Schema, util::normalize_ident, Result};
 use sqlite3_parser::ast::{self, FromClause, JoinType, ResultColumn};
-use std::rc::Rc;
 
 pub struct OperatorIdCounter {
     id: usize,
@@ -279,13 +273,7 @@ pub fn prepare_select_plan<'a>(schema: &Schema, select: ast::Select) -> Result<P
             Ok(Plan {
                 root_operator: operator,
                 referenced_tables,
-                available_indexes: schema
-                    .indexes
-                    .clone()
-                    .into_iter()
-                    .map(|(_, v)| v)
-                    .flatten()
-                    .collect(),
+                available_indexes: schema.indexes.clone().into_values().flatten().collect(),
             })
         }
         _ => todo!(),