Applies some Clippy suggestions

lib/src/sparql/eval.rs

@@ -1056,7 +1056,7 @@ fn put_value(position: usize, value: EncodedTerm, tuple: &mut EncodedTuple) {
 }
 
 fn bind_variables_in_set(binding: &[Option<EncodedTerm>], set: &[usize]) -> Vec<usize> {
-    set.into_iter()
+    set.iter()
         .cloned()
         .filter(|key| *key < binding.len() && binding[*key].is_some())
         .collect()
@@ -1073,7 +1073,7 @@ fn unbind_variables(binding: &mut [Option<EncodedTerm>], variables: &[usize]) {
 fn combine_tuples(a: &[Option<EncodedTerm>], b: &[Option<EncodedTerm>]) -> Option<EncodedTuple> {
     if a.len() < b.len() {
         let mut result = b.to_owned();
-        for (key, a_value) in a.into_iter().enumerate() {
+        for (key, a_value) in a.iter().enumerate() {
             if let Some(a_value) = a_value {
                 match b[key] {
                     Some(ref b_value) => {
@@ -1088,7 +1088,7 @@ fn combine_tuples(a: &[Option<EncodedTerm>], b: &[Option<EncodedTerm>]) -> Optio
         Some(result)
     } else {
         let mut result = a.to_owned();
-        for (key, b_value) in b.into_iter().enumerate() {
+        for (key, b_value) in b.iter().enumerate() {
             if let Some(b_value) = b_value {
                 match a[key] {
                     Some(ref a_value) => {

lib/src/sparql/plan.rs

@@ -78,7 +78,7 @@ impl PlanNode {
             PlanNode::Init => (),
             PlanNode::StaticBindings { tuples } => {
                 for tuple in tuples {
-                    for (key, value) in tuple.into_iter().enumerate() {
+                    for (key, value) in tuple.iter().enumerate() {
                         if value.is_some() {
                             set.insert(key);
                         }
@@ -487,7 +487,7 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
             },
             GraphPattern::OrderBy(l, o) => {
                 let by: Result<Vec<_>> = o
-                    .into_iter()
+                    .iter()
                     .map(|comp| match comp {
                         OrderComparator::Asc(e) => {
                             Ok(Comparator::Asc(self.build_for_expression(e, variables)?))
@@ -828,7 +828,7 @@ impl<'a, S: EncodedQuadsStore> PlanBuilder<'a, S> {
     ) -> Result<Vec<TripleTemplate>> {
         let mut bnodes = Vec::default();
         template
-            .into_iter()
+            .iter()
             .map(|triple| {
                 Ok(TripleTemplate {
                     subject: self.template_value_from_term_or_variable(

lib/src/store/numeric_encoder.rs

@@ -300,13 +300,13 @@ impl From<f64> for EncodedTerm {
 
 impl From<i32> for EncodedTerm {
     fn from(value: i32) -> Self {
-        EncodedTerm::IntegerLiteral(value as i128)
+        EncodedTerm::IntegerLiteral(value.into())
     }
 }
 
 impl From<u32> for EncodedTerm {
     fn from(value: u32) -> Self {
-        EncodedTerm::IntegerLiteral(value as i128)
+        EncodedTerm::IntegerLiteral(value.into())
     }
 }