diff --git a/minisql/src/internals/table.rs b/minisql/src/internals/table.rs
index 9dc05de..aff4b37 100644
--- a/minisql/src/internals/table.rs
+++ b/minisql/src/internals/table.rs
@@ -41,7 +41,7 @@ impl Table {
     }
 
     pub fn table_name(&self) -> &TableName {
-        &self.schema.table_name()
+        self.schema.table_name()
     }
 
     // ======Selection======
@@ -69,18 +69,18 @@ impl Table {
             .collect()
     }
 
-    pub fn select_all_rows<'a>(&'a self, selected_columns: Vec<Column>) -> impl Iterator<Item=RestrictedRow> + 'a {
+    pub fn select_all_rows(&self, selected_columns: Vec<Column>) -> impl Iterator<Item=RestrictedRow> + '_ {
         self.rows
             .values()
             .map(move |row| row.restrict_columns(&selected_columns))
     }
 
-    pub fn select_rows_where_eq<'a>(
-        &'a self,
+    pub fn select_rows_where_eq(
+        &self,
         selected_columns: Vec<Column>,
         column: Column,
         value: Value,
-    ) -> DbResult<impl Iterator<Item=RestrictedRow> + 'a> {
+    ) -> DbResult<impl Iterator<Item=RestrictedRow> + '_> {
         let restrict_columns_of_row = move |row: Row| row.restrict_columns(&selected_columns);
         match value {
             Value::Indexable(value) => match self.fetch_ids_from_index(column, &value)? {
@@ -116,10 +116,7 @@ impl Table {
         }
 
         for (column, column_index) in &mut self.indexes {
-            match &row[*column] {
-                Value::Indexable(val) => column_index.add(val.clone(), id),
-                _ => {},
-            }
+            if let Value::Indexable(val) = &row[*column] { column_index.add(val.clone(), id) }
         }
 
         let _ = self.rows.insert(id, row);
diff --git a/minisql/src/interpreter.rs b/minisql/src/interpreter.rs
index 27f697e..b3d3471 100644
--- a/minisql/src/interpreter.rs
+++ b/minisql/src/interpreter.rs
@@ -55,7 +55,7 @@ impl State {
         }
     }
 
-    pub fn db_schema<'a>(&'a self) -> DbSchema {
+    pub fn db_schema(&self) -> DbSchema {
         let mut schema: DbSchema = Vec::new();
         for (table_name, &table_position) in &self.table_name_position_mapping {
             let table_schema = self.tables[table_position].schema();
@@ -64,11 +64,11 @@ impl State {
         schema
     }
 
-    fn table_at<'a>(&'a self, table_position: TablePosition) -> &'a Table {
+    fn table_at(&self, table_position: TablePosition) -> &Table {
         &self.tables[table_position]
     }
 
-    fn table_at_mut<'a>(&'a mut self, table_position: TablePosition) -> &'a mut Table {
+    fn table_at_mut(&mut self, table_position: TablePosition) -> &mut Table {
         &mut self.tables[table_position]
     }
 
diff --git a/minisql/src/restricted_row.rs b/minisql/src/restricted_row.rs
index 8ea9aca..77cafcb 100644
--- a/minisql/src/restricted_row.rs
+++ b/minisql/src/restricted_row.rs
@@ -28,6 +28,10 @@ impl RestrictedRow {
         self.0.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
     pub fn iter(&self) -> impl Iterator<Item=&(Column, Value)> {
         self.0.iter()
     }
diff --git a/parser/src/core.rs b/parser/src/core.rs
index ec0c140..9001e8f 100644
--- a/parser/src/core.rs
+++ b/parser/src/core.rs
@@ -1,6 +1,6 @@
 use minisql::{operation::Operation, interpreter::DbSchema};
 use crate::syntax::RawQuerySyntax;
-use nom::{branch::alt, multi::many0, IResult};
+use nom::{branch::alt, IResult};
 use thiserror::Error;
 
 use crate::{parsing::{create::parse_create, delete::parse_delete, index::parse_create_index, insert::parse_insert, select::parse_select}, validation::{validate_operation, ValidationError}};
@@ -13,7 +13,7 @@ pub enum Error {
     ValidationError(#[from] ValidationError)
 }
 
-pub fn parse_statement<'a>(input: &'a str) -> IResult<&str, RawQuerySyntax> {
+fn parse_statement<'a>(input: &'a str) -> IResult<&str, RawQuerySyntax> {
     alt((
         parse_insert,
         parse_create,
@@ -25,10 +25,6 @@ pub fn parse_statement<'a>(input: &'a str) -> IResult<&str, RawQuerySyntax> {
     ))(input)
 }
 
-pub fn parse_statements<'a>(input: &'a str) -> IResult<&str, Vec<RawQuerySyntax>> {
-    many0(parse_statement)(input)
-}
-
 pub fn parse_and_validate(str_query: String, db_schema: &DbSchema) -> Result<Operation, Error> {
     let (_, op) = parse_statement(str_query.as_str())
         .map_err(|err| {
diff --git a/proto/src/reader/frontend.rs b/proto/src/reader/frontend.rs
index bb2ffc8..4d0cf52 100644
--- a/proto/src/reader/frontend.rs
+++ b/proto/src/reader/frontend.rs
@@ -24,15 +24,15 @@ where
     R: AsyncBufRead + Unpin + Send,
 {
     async fn peek_special_message(&mut self) -> Result<Option<SpecialMessage>, ProtoPeekError> {
-        if let Some(cancel) = try_get_cancel_request(&mut self).await? {
+        if let Some(cancel) = try_get_cancel_request(self).await? {
             return Ok(Some(cancel));
         }
 
-        if let Some(ssl) = try_get_ssl_request(&mut self).await? {
+        if let Some(ssl) = try_get_ssl_request(self).await? {
             return Ok(Some(ssl));
         }
 
-        if let Some(startup) = try_get_startup_message(&mut self).await? {
+        if let Some(startup) = try_get_startup_message(self).await? {
             return Ok(Some(startup));
         }
 
@@ -43,11 +43,12 @@ where
         &mut self,
         msg: &SpecialMessage,
     ) -> Result<(), ProtoConsumeError> {
-        Ok(match msg {
+        match msg {
             SpecialMessage::CancelRequest(_) => consume_cancel_request(self),
             SpecialMessage::SSLRequest => consume_ssl_request(self),
             SpecialMessage::StartupMessage(_) => consume_startup_message(self).await?,
-        })
+        };
+        Ok(())
     }
 }
 
diff --git a/proto/src/writer/oneway.rs b/proto/src/writer/oneway.rs
index 30d2665..f4782f2 100644
--- a/proto/src/writer/oneway.rs
+++ b/proto/src/writer/oneway.rs
@@ -20,12 +20,12 @@ where
 {
     async fn write_proto(&mut self, message: T) -> Result<(), ProtoWriteError> {
         let variant = message.variant();
-        let mut data = message.serialize()?;
+        let data = message.serialize()?;
         let length = data.len() as i32 + 4;
 
         self.inner.write_u8(variant).await?;
         self.inner.write_i32(length).await?;
-        self.inner.write_all(&mut data).await?;
+        self.inner.write_all(&data).await?;
 
         Ok(())
     }