diff --git a/src/lib/filtering.rs b/src/lib/filtering.rs
index f31b1ab..0d3af8a 100644
--- a/src/lib/filtering.rs
+++ b/src/lib/filtering.rs
@@ -116,17 +116,31 @@ impl FilteringRule {
 
         let value = match filter_operator {
             FilterOperator::In | FilterOperator::NotIn => {
-                let values = value.split(',').map(|v| v.trim().to_string()).collect::<Vec<String>>();
-                let first = values.first().ok_or(eyre::eyre!("No values found for IN/NOT IN filter"))?;
+                let values = value
+                    .split(',')
+                    .map(|v| v.trim().to_string())
+                    .collect::<Vec<String>>();
+                let first = values
+                    .first()
+                    .ok_or(eyre::eyre!("No values found for IN/NOT IN filter"))?;
 
                 if first.parse::<i64>().is_ok() {
-                    let values = values.iter().map(|v| v.parse::<i64>()).collect::<Result<Vec<i64>, _>>()?;
+                    let values = values
+                        .iter()
+                        .map(|v| v.parse::<i64>())
+                        .collect::<Result<Vec<i64>, _>>()?;
                     FilterValue::IntList(values)
                 } else if first.parse::<f64>().is_ok() {
-                    let values = values.iter().map(|v| v.parse::<f64>()).collect::<Result<Vec<f64>, _>>()?;
+                    let values = values
+                        .iter()
+                        .map(|v| v.parse::<f64>())
+                        .collect::<Result<Vec<f64>, _>>()?;
                     FilterValue::FloatList(values)
                 } else if first.to_lowercase() == "true" || first.to_lowercase() == "false" {
-                    let values = values.iter().map(|v| v.parse::<bool>()).collect::<Result<Vec<bool>, _>>()?;
+                    let values = values
+                        .iter()
+                        .map(|v| v.parse::<bool>())
+                        .collect::<Result<Vec<bool>, _>>()?;
                     FilterValue::BoolList(values)
                 } else {
                     FilterValue::StringList(values)
@@ -148,7 +162,8 @@ impl FilteringRule {
             }
         };
 
-        let filter_column = Filtering::filter_column(column.clone(), filter_operator.clone(), value.clone())?;
+        let filter_column =
+            Filtering::filter_column(column.clone(), filter_operator.clone(), value.clone())?;
 
         Ok(FilteringRule {
             filter_column,
@@ -190,7 +205,11 @@ pub struct Filtering {
 }
 
 impl Filtering {
-    fn filter_column(column: ColumnName, operator: FilterOperator, value: FilterValue) -> eyre::Result<FilterColumn> {
+    fn filter_column(
+        column: ColumnName,
+        operator: FilterOperator,
+        value: FilterValue,
+    ) -> eyre::Result<FilterColumn> {
         match column {
             ColumnName::String(c) => {
                 if let Some(value) = Self::handle_null(operator.clone(), c) {
@@ -201,19 +220,29 @@ impl Filtering {
                         if let Some(value) = Self::handle_like(operator.clone(), c, v.clone()) {
                             return value;
                         }
-                        if let Some(value) = Self::handle_starts_with(operator.clone(), c, v.clone()) {
+                        if let Some(value) =
+                            Self::handle_starts_with(operator.clone(), c, v.clone())
+                        {
                             return value;
                         }
-                        if let Some(value) = Self::handle_ends_with(operator.clone(), c, v.clone()) {
+                        if let Some(value) = Self::handle_ends_with(operator.clone(), c, v.clone())
+                        {
                             return value;
                         }
                         Ok(FilterColumn::String(c, format!("'{}'", v)))
                     }
                     FilterValue::StringList(v) => {
-                        let v = v.iter().map(|v| format!("'{}'", v)).collect::<Vec<String>>();
+                        let v = v
+                            .iter()
+                            .map(|v| format!("'{}'", v))
+                            .collect::<Vec<String>>();
                         Ok(FilterColumn::StringList(c, v))
                     }
-                    _ => Err(eyre::eyre!("Invalid value: '{}' for column: '{}' of type String", value.to_string(), c)),
+                    _ => Err(eyre::eyre!(
+                        "Invalid value: '{}' for column: '{}' of type String",
+                        value.to_string(),
+                        c
+                    )),
                 }
             }
             ColumnName::Int(c) => {
@@ -223,7 +252,11 @@ impl Filtering {
                 match value {
                     FilterValue::Int(v) => Ok(FilterColumn::Int(c, v)),
                     FilterValue::IntList(v) => Ok(FilterColumn::IntList(c, v)),
-                    _ => Err(eyre::eyre!("Invalid value: '{}' for column: '{}' of type Int", value.to_string(), c)),
+                    _ => Err(eyre::eyre!(
+                        "Invalid value: '{}' for column: '{}' of type Int",
+                        value.to_string(),
+                        c
+                    )),
                 }
             }
             ColumnName::Float(c) => {
@@ -233,7 +266,11 @@ impl Filtering {
                 match value {
                     FilterValue::Float(v) => Ok(FilterColumn::Float(c, v)),
                     FilterValue::FloatList(v) => Ok(FilterColumn::FloatList(c, v)),
-                    _ => Err(eyre::eyre!("Invalid value: '{}' for column: '{}' of type Float", value.to_string(), c)),
+                    _ => Err(eyre::eyre!(
+                        "Invalid value: '{}' for column: '{}' of type Float",
+                        value.to_string(),
+                        c
+                    )),
                 }
             }
             ColumnName::Bool(c) => {
@@ -243,34 +280,53 @@ impl Filtering {
                 match value {
                     FilterValue::Bool(v) => Ok(FilterColumn::Bool(c, v)),
                     FilterValue::BoolList(v) => Ok(FilterColumn::BoolList(c, v)),
-                    _ => Err(eyre::eyre!("Invalid value: '{}' for column: '{}' of type Bool", value.to_string(), c)),
+                    _ => Err(eyre::eyre!(
+                        "Invalid value: '{}' for column: '{}' of type Bool",
+                        value.to_string(),
+                        c
+                    )),
                 }
             }
         }
     }
 
-    fn handle_null(operator: FilterOperator, c: &'static str) -> Option<eyre::Result<FilterColumn>> {
+    fn handle_null(
+        operator: FilterOperator,
+        c: &'static str,
+    ) -> Option<eyre::Result<FilterColumn>> {
         if operator == FilterOperator::IsNull || operator == FilterOperator::IsNotNull {
             return Some(Ok(FilterColumn::String(c, "".to_string())));
         };
         None
     }
 
-    fn handle_like(operator: FilterOperator, c: &'static str, v: String) -> Option<eyre::Result<FilterColumn>> {
+    fn handle_like(
+        operator: FilterOperator,
+        c: &'static str,
+        v: String,
+    ) -> Option<eyre::Result<FilterColumn>> {
         if operator == FilterOperator::Like || operator == FilterOperator::NotLike {
             return Some(Ok(FilterColumn::String(c, format!("'%{}%'", v))));
         };
         None
     }
 
-    fn handle_starts_with(operator: FilterOperator, c: &'static str, v: String) -> Option<eyre::Result<FilterColumn>> {
+    fn handle_starts_with(
+        operator: FilterOperator,
+        c: &'static str,
+        v: String,
+    ) -> Option<eyre::Result<FilterColumn>> {
         if operator == FilterOperator::StartsWith {
             return Some(Ok(FilterColumn::String(c, format!("'{}%'", v))));
         };
         None
     }
 
-    fn handle_ends_with(operator: FilterOperator, c: &'static str, v: String) -> Option<eyre::Result<FilterColumn>> {
+    fn handle_ends_with(
+        operator: FilterOperator,
+        c: &'static str,
+        v: String,
+    ) -> Option<eyre::Result<FilterColumn>> {
         if operator == FilterOperator::EndsWith {
             return Some(Ok(FilterColumn::String(c, format!("'%{}'", v))));
         };
@@ -289,138 +345,206 @@ impl Filtering {
         }
     }
 
-    fn sql_str_in(case_insensitive: bool, column: &str, operator: &str, value: Vec<String>) -> String {
+    fn sql_str_in(
+        case_insensitive: bool,
+        column: &str,
+        operator: &str,
+        value: Vec<String>,
+    ) -> String {
         if case_insensitive {
-            format!("LOWER({}) {} ({})", column, operator, value.into_iter().map(|v| format!("LOWER('{}')", v)).collect::<Vec<String>>().join(", "))
+            format!(
+                "LOWER({}) {} ({})",
+                column,
+                operator,
+                value
+                    .into_iter()
+                    .map(|v| format!("LOWER('{}')", v))
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            )
         } else {
-            format!("{} {} ({})", column, operator, value.into_iter().map(|v| format!("'{}'", v)).collect::<Vec<String>>().join(", "))
+            format!(
+                "{} {} ({})",
+                column,
+                operator,
+                value
+                    .into_iter()
+                    .map(|v| format!("'{}'", v))
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            )
         }
     }
 
     fn sql_str_in_int(column: &str, operator: &str, value: Vec<i64>) -> String {
-        format!("{} {} ({})", column, operator, value.into_iter().map(|v| v.to_string()).collect::<Vec<String>>().join(", "))
+        format!(
+            "{} {} ({})",
+            column,
+            operator,
+            value
+                .into_iter()
+                .map(|v| v.to_string())
+                .collect::<Vec<String>>()
+                .join(", ")
+        )
     }
 
     fn sql_str_in_float(column: &str, operator: &str, value: Vec<f64>) -> String {
-        format!("{} {} ({})", column, operator, value.into_iter().map(|v| v.to_string()).collect::<Vec<String>>().join(", "))
+        format!(
+            "{} {} ({})",
+            column,
+            operator,
+            value
+                .into_iter()
+                .map(|v| v.to_string())
+                .collect::<Vec<String>>()
+                .join(", ")
+        )
     }
 
     fn sql_str_in_bool(column: &str, operator: &str, value: Vec<bool>) -> String {
-        format!("{} {} ({})", column, operator, value.into_iter().map(|v| v.to_string()).collect::<Vec<String>>().join(", "))
+        format!(
+            "{} {} ({})",
+            column,
+            operator,
+            value
+                .into_iter()
+                .map(|v| v.to_string())
+                .collect::<Vec<String>>()
+                .join(", ")
+        )
     }
 
     fn sql_str_null(column: &str, operator: &str) -> String {
         format!("{} {}", column, operator)
     }
 
-    fn operators(cs: bool, filter_operator: FilterOperator, filter_column: FilterColumn) -> eyre::Result<String> {
+    fn operators(
+        cs: bool,
+        filter_operator: FilterOperator,
+        filter_column: FilterColumn,
+    ) -> eyre::Result<String> {
         match filter_operator {
-            FilterOperator::Equal => {
-                match filter_column {
-                    FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "=", v)),
-                    FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, "=", v.to_string())),
-                    FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, "=", v.to_string())),
-                    FilterColumn::Bool(c, v) => Ok(Filtering::sql_str(c, "=", v.to_string())),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator Equal", filter_column.to_string())),
-                }
-            }
-            FilterOperator::NotEqual => {
-                match filter_column {
-                    FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "!=", v)),
-                    FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, "!=", v.to_string())),
-                    FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, "!=", v.to_string())),
-                    FilterColumn::Bool(c, v) => Ok(Filtering::sql_str(c, "!=", v.to_string())),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator NotEqual", filter_column.to_string())),
-                }
-            }
-            FilterOperator::GreaterThan => {
-                match filter_column {
-                    FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, ">", v.to_string())),
-                    FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, ">", v.to_string())),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator GreaterThan", filter_column.to_string())),
-                }
-            }
-            FilterOperator::GreaterThanOrEqual => {
-                match filter_column {
-                    FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, ">=", v.to_string())),
-                    FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, ">=", v.to_string())),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator GreaterThanOrEqual", filter_column.to_string())),
-                }
-            }
-            FilterOperator::LessThan => {
-                match filter_column {
-                    FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, "<", v.to_string())),
-                    FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, "<", v.to_string())),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator LessThan", filter_column.to_string())),
-                }
-            }
-            FilterOperator::LessThanOrEqual => {
-                match filter_column {
-                    FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, "<=", v.to_string())),
-                    FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, "<=", v.to_string())),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator LessThanOrEqual", filter_column.to_string())),
-                }
-            }
-            FilterOperator::Like => {
-                match filter_column {
-                    FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "LIKE", v)),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator Like", filter_column.to_string())),
-                }
-            }
-            FilterOperator::NotLike => {
-                match filter_column {
-                    FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "NOT LIKE", v)),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator NotLike", filter_column.to_string())),
-                }
-            }
-            FilterOperator::In => {
-                match filter_column {
-                    FilterColumn::StringList(c, v) => Ok(Filtering::sql_str_in(cs, c, "IN", v)),
-                    FilterColumn::IntList(c, v) => Ok(Filtering::sql_str_in_int(c, "IN", v)),
-                    FilterColumn::FloatList(c, v) => Ok(Filtering::sql_str_in_float(c, "IN", v)),
-                    FilterColumn::BoolList(c, v) => Ok(Filtering::sql_str_in_bool(c, "IN", v)),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator In", filter_column.to_string()))
-                }
-            }
-            FilterOperator::NotIn => {
-                match filter_column {
-                    FilterColumn::StringList(c, v) => Ok(Filtering::sql_str_in(cs, c, "NOT IN", v)),
-                    FilterColumn::IntList(c, v) => Ok(Filtering::sql_str_in_int(c, "NOT IN", v)),
-                    FilterColumn::FloatList(c, v) => Ok(Filtering::sql_str_in_float(c, "NOT IN", v)),
-                    FilterColumn::BoolList(c, v) => Ok(Filtering::sql_str_in_bool(c, "NOT IN", v)),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator NotIn", filter_column.to_string()))
-                }
-            }
-            FilterOperator::IsNull => {
-                match filter_column {
-                    FilterColumn::String(c, _) => Ok(Filtering::sql_str_null(c, "IS NULL")),
-                    FilterColumn::Int(c, _) => Ok(Filtering::sql_str_null(c, "IS NULL")),
-                    FilterColumn::Float(c, _) => Ok(Filtering::sql_str_null(c, "IS NULL")),
-                    FilterColumn::Bool(c, _) => Ok(Filtering::sql_str_null(c, "IS NULL")),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator IsNull", filter_column.to_string())),
-                }
-            }
-            FilterOperator::IsNotNull => {
-                match filter_column {
-                    FilterColumn::String(c, _) => Ok(Filtering::sql_str_null(c, "IS NOT NULL")),
-                    FilterColumn::Int(c, _) => Ok(Filtering::sql_str_null(c, "IS NOT NULL")),
-                    FilterColumn::Float(c, _) => Ok(Filtering::sql_str_null(c, "IS NOT NULL")),
-                    FilterColumn::Bool(c, _) => Ok(Filtering::sql_str_null(c, "IS NOT NULL")),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator IsNotNull", filter_column.to_string())),
-                }
-            }
-            FilterOperator::StartsWith => {
-                match filter_column {
-                    FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "LIKE", v)),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator Like", filter_column.to_string())),
-                }
-            }
-            FilterOperator::EndsWith => {
-                match filter_column {
-                    FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "LIKE", v)),
-                    _ => Err(eyre::eyre!("Invalid column type '{}' for filter operator Like", filter_column.to_string())),
-                }
-            }
+            FilterOperator::Equal => match filter_column {
+                FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "=", v)),
+                FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, "=", v.to_string())),
+                FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, "=", v.to_string())),
+                FilterColumn::Bool(c, v) => Ok(Filtering::sql_str(c, "=", v.to_string())),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator Equal",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::NotEqual => match filter_column {
+                FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "!=", v)),
+                FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, "!=", v.to_string())),
+                FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, "!=", v.to_string())),
+                FilterColumn::Bool(c, v) => Ok(Filtering::sql_str(c, "!=", v.to_string())),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator NotEqual",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::GreaterThan => match filter_column {
+                FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, ">", v.to_string())),
+                FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, ">", v.to_string())),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator GreaterThan",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::GreaterThanOrEqual => match filter_column {
+                FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, ">=", v.to_string())),
+                FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, ">=", v.to_string())),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator GreaterThanOrEqual",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::LessThan => match filter_column {
+                FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, "<", v.to_string())),
+                FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, "<", v.to_string())),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator LessThan",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::LessThanOrEqual => match filter_column {
+                FilterColumn::Int(c, v) => Ok(Filtering::sql_str(c, "<=", v.to_string())),
+                FilterColumn::Float(c, v) => Ok(Filtering::sql_str(c, "<=", v.to_string())),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator LessThanOrEqual",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::Like => match filter_column {
+                FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "LIKE", v)),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator Like",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::NotLike => match filter_column {
+                FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "NOT LIKE", v)),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator NotLike",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::In => match filter_column {
+                FilterColumn::StringList(c, v) => Ok(Filtering::sql_str_in(cs, c, "IN", v)),
+                FilterColumn::IntList(c, v) => Ok(Filtering::sql_str_in_int(c, "IN", v)),
+                FilterColumn::FloatList(c, v) => Ok(Filtering::sql_str_in_float(c, "IN", v)),
+                FilterColumn::BoolList(c, v) => Ok(Filtering::sql_str_in_bool(c, "IN", v)),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator In",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::NotIn => match filter_column {
+                FilterColumn::StringList(c, v) => Ok(Filtering::sql_str_in(cs, c, "NOT IN", v)),
+                FilterColumn::IntList(c, v) => Ok(Filtering::sql_str_in_int(c, "NOT IN", v)),
+                FilterColumn::FloatList(c, v) => Ok(Filtering::sql_str_in_float(c, "NOT IN", v)),
+                FilterColumn::BoolList(c, v) => Ok(Filtering::sql_str_in_bool(c, "NOT IN", v)),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator NotIn",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::IsNull => match filter_column {
+                FilterColumn::String(c, _) => Ok(Filtering::sql_str_null(c, "IS NULL")),
+                FilterColumn::Int(c, _) => Ok(Filtering::sql_str_null(c, "IS NULL")),
+                FilterColumn::Float(c, _) => Ok(Filtering::sql_str_null(c, "IS NULL")),
+                FilterColumn::Bool(c, _) => Ok(Filtering::sql_str_null(c, "IS NULL")),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator IsNull",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::IsNotNull => match filter_column {
+                FilterColumn::String(c, _) => Ok(Filtering::sql_str_null(c, "IS NOT NULL")),
+                FilterColumn::Int(c, _) => Ok(Filtering::sql_str_null(c, "IS NOT NULL")),
+                FilterColumn::Float(c, _) => Ok(Filtering::sql_str_null(c, "IS NOT NULL")),
+                FilterColumn::Bool(c, _) => Ok(Filtering::sql_str_null(c, "IS NOT NULL")),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator IsNotNull",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::StartsWith => match filter_column {
+                FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "LIKE", v)),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator Like",
+                    filter_column.to_string()
+                )),
+            },
+            FilterOperator::EndsWith => match filter_column {
+                FilterColumn::String(c, v) => Ok(Filtering::sql_str_i(cs, c, "LIKE", v)),
+                _ => Err(eyre::eyre!(
+                    "Invalid column type '{}' for filter operator Like",
+                    filter_column.to_string()
+                )),
+            },
         }
     }
 
@@ -458,7 +582,11 @@ impl Filtering {
                 }
             }
 
-            let sql_string = Filtering::operators(case_insensitive, rule.filter_operator.clone(), rule.filter_column.clone());
+            let sql_string = Filtering::operators(
+                case_insensitive,
+                rule.filter_operator.clone(),
+                rule.filter_column.clone(),
+            );
             match sql_string {
                 Ok(v) => sql.push_str(v.as_str()),
                 Err(e) => eprintln!("{}", e),
diff --git a/src/lib/mod.rs b/src/lib/mod.rs
index c6aef07..272dc4f 100644
--- a/src/lib/mod.rs
+++ b/src/lib/mod.rs
@@ -164,7 +164,10 @@ impl PgFilters {
         let sorting = Sorting::new(sorting_columns);
 
         let filters = filtering_rules.map(|filtering_rules| {
-            Filtering::new(filtering_rules.filtering_rules, filtering_rules.case_insensitive)
+            Filtering::new(
+                filtering_rules.filtering_rules,
+                filtering_rules.case_insensitive,
+            )
         });
 
         PgFilters {
diff --git a/src/lib/pagination.rs b/src/lib/pagination.rs
index 4b294ca..3a7730e 100644
--- a/src/lib/pagination.rs
+++ b/src/lib/pagination.rs
@@ -68,8 +68,8 @@ impl Pagination {
         };
         let next_page = if current_page < total_pages && total_pages > 0 {
             current_page + 1
-        } else if current_page < total_pages{
-            total_pages    
+        } else if current_page < total_pages {
+            total_pages
         } else {
             current_page
         };
@@ -120,7 +120,11 @@ impl Paginate {
         per_page_limit: i64,
         total_records: i64,
     ) -> Paginate {
-        let per_page_limit = if per_page_limit > 0 { per_page_limit } else { 10 };
+        let per_page_limit = if per_page_limit > 0 {
+            per_page_limit
+        } else {
+            10
+        };
         let per_page = if per_page > per_page_limit {
             per_page_limit
         } else {
@@ -130,7 +134,11 @@ impl Paginate {
 
         let total_records = if total_records > 0 { total_records } else { 0 };
 
-        let total_pages = if total_records > 0 { (total_records as f64 / per_page as f64).ceil() as i64 } else { 0 };
+        let total_pages = if total_records > 0 {
+            (total_records as f64 / per_page as f64).ceil() as i64
+        } else {
+            0
+        };
         let current_page = if current_page < 1 { 1 } else { current_page };
         let current_page = if current_page > total_pages && total_pages > 0 {
             total_pages
diff --git a/tests/integration/integration_test.rs b/tests/integration/integration_test.rs
index 31513d9..0c0f79d 100644
--- a/tests/integration/integration_test.rs
+++ b/tests/integration/integration_test.rs
@@ -1,6 +1,10 @@
 use crate::integration::{get_client, setup_data};
-use pg_filters::{filtering::{FilteringRule, ColumnName}, sorting::{SortedColumn}, PaginationOptions, PgFilters};
 use pg_filters::FilteringOptions;
+use pg_filters::{
+    filtering::{ColumnName, FilteringRule},
+    sorting::SortedColumn,
+    PaginationOptions, PgFilters,
+};
 
 #[tokio::test]
 async fn test_string_int() {
@@ -28,11 +32,14 @@ async fn test_string_int() {
     let query = format!("SELECT * FROM person {}", sql);
     let rows = client.query(query.as_str(), &[]).await.unwrap();
 
-    let rows: Vec<(String, i32)> = rows.iter().map(|row| {
-        let name: String = row.get("name");
-        let age: i32 = row.get("age");
-        (name, age)
-    }).collect();
+    let rows: Vec<(String, i32)> = rows
+        .iter()
+        .map(|row| {
+            let name: String = row.get("name");
+            let age: i32 = row.get("age");
+            (name, age)
+        })
+        .collect();
 
     let expected_rows = vec![
         ("name19".to_string(), 19),
@@ -76,21 +83,21 @@ async fn test_float_bool() {
     let query = format!("SELECT * FROM person {}", sql);
     let rows = client.query(query.as_str(), &[]).await.unwrap();
 
-    let rows: Vec<(String, f64, bool)> = rows.iter().map(|row| {
-        let name: String = row.get("name");
-        let capacity: f64 = row.get("capacity");
-        let active: bool = row.get("active");
-        (name, capacity, active)
-    }).collect();
+    let rows: Vec<(String, f64, bool)> = rows
+        .iter()
+        .map(|row| {
+            let name: String = row.get("name");
+            let capacity: f64 = row.get("capacity");
+            let active: bool = row.get("active");
+            (name, capacity, active)
+        })
+        .collect();
 
-    let expected_rows = vec![
-        ("name4".to_string(), 4.0, true),
-    ];
+    let expected_rows = vec![("name4".to_string(), 4.0, true)];
 
     assert_eq!(rows, expected_rows);
 }
 
-
 #[tokio::test]
 async fn test_in() {
     let client = get_client().await;
@@ -107,20 +114,26 @@ async fn test_in() {
             SortedColumn::new("age", "desc"),
             SortedColumn::new("name", "asc"),
         ],
-        Some(FilteringOptions::new(vec![
-            FilteringRule::new("where", ColumnName::Int("age"), "in", "11,12,13"),
-        ])),
+        Some(FilteringOptions::new(vec![FilteringRule::new(
+            "where",
+            ColumnName::Int("age"),
+            "in",
+            "11,12,13",
+        )])),
     );
 
     let sql = filters.sql();
     let query = format!("SELECT * FROM person {}", sql);
     let rows = client.query(query.as_str(), &[]).await.unwrap();
 
-    let rows: Vec<(String, i32)> = rows.iter().map(|row| {
-        let name: String = row.get("name");
-        let age: i32 = row.get("age");
-        (name, age)
-    }).collect();
+    let rows: Vec<(String, i32)> = rows
+        .iter()
+        .map(|row| {
+            let name: String = row.get("name");
+            let age: i32 = row.get("age");
+            (name, age)
+        })
+        .collect();
 
     let expected_rows = vec![
         ("name13".to_string(), 13),
@@ -131,7 +144,6 @@ async fn test_in() {
     assert_eq!(rows, expected_rows);
 }
 
-
 #[tokio::test]
 async fn test_starts_with() {
     let client = get_client().await;
@@ -159,11 +171,14 @@ async fn test_starts_with() {
     let query = format!("SELECT * FROM person {}", sql);
     let rows = client.query(query.as_str(), &[]).await.unwrap();
 
-    let rows: Vec<(String, i32)> = rows.iter().map(|row| {
-        let name: String = row.get("name");
-        let age: i32 = row.get("age");
-        (name, age)
-    }).collect();
+    let rows: Vec<(String, i32)> = rows
+        .iter()
+        .map(|row| {
+            let name: String = row.get("name");
+            let age: i32 = row.get("age");
+            (name, age)
+        })
+        .collect();
 
     let expected_rows = vec![
         ("name19".to_string(), 19),
diff --git a/tests/integration/mod.rs b/tests/integration/mod.rs
index 2cb3065..d86786d 100644
--- a/tests/integration/mod.rs
+++ b/tests/integration/mod.rs
@@ -1,7 +1,7 @@
 use testcontainers_modules::postgres::Postgres;
-use testcontainers_modules::testcontainers::ContainerAsync;
 use testcontainers_modules::testcontainers::core::error;
 use testcontainers_modules::testcontainers::runners::AsyncRunner;
+use testcontainers_modules::testcontainers::ContainerAsync;
 use tokio::sync::OnceCell;
 use tokio_postgres::{Client, NoTls};
 
@@ -11,10 +11,14 @@ async fn get_client() -> Client {
     let container = get_container().await.as_ref().unwrap();
     let port = container.get_host_port_ipv4(5432).await.unwrap();
     let host = container.get_host().await.unwrap();
-    let connection_string = format!("host={} user=postgres password=postgres port={}", host, port);
+    let connection_string = format!(
+        "host={} user=postgres password=postgres port={}",
+        host, port
+    );
 
-    let (client, connection) =
-        tokio_postgres::connect(connection_string.as_str(), NoTls).await.unwrap();
+    let (client, connection) = tokio_postgres::connect(connection_string.as_str(), NoTls)
+        .await
+        .unwrap();
 
     tokio::spawn(async move {
         if let Err(e) = connection.await {
@@ -26,7 +30,8 @@ async fn get_client() -> Client {
 
 pub async fn get_container() -> &'static error::Result<ContainerAsync<Postgres>> {
     static ONCE: OnceCell<error::Result<ContainerAsync<Postgres>>> = OnceCell::const_new();
-    ONCE.get_or_init(|| async { Postgres::default().start().await }).await
+    ONCE.get_or_init(|| async { Postgres::default().start().await })
+        .await
 }
 
 pub async fn setup_data() -> &'static bool {
@@ -77,4 +82,3 @@ async fn create_rows() {
             .unwrap();
     }
 }
-
diff --git a/tests/mod.rs b/tests/mod.rs
index 8da8976..0edbbbb 100644
--- a/tests/mod.rs
+++ b/tests/mod.rs
@@ -1,2 +1,2 @@
+pub mod integration;
 pub mod unit;
-pub mod integration;
\ No newline at end of file
diff --git a/tests/unit/combined_test.rs b/tests/unit/combined_test.rs
index 922a0f5..0ce151d 100644
--- a/tests/unit/combined_test.rs
+++ b/tests/unit/combined_test.rs
@@ -1,7 +1,9 @@
+use pg_filters::filtering::FilterColumn;
 use pg_filters::{
-    filtering::{ConditionalOperator, FilteringRule, FilterOperator}, FilteringOptions, PaginationOptions, PgFilters, sorting::{SortedColumn, SortOrder}
+    filtering::{ConditionalOperator, FilterOperator, FilteringRule},
+    sorting::{SortOrder, SortedColumn},
+    FilteringOptions, PaginationOptions, PgFilters,
 };
-use pg_filters::filtering::FilterColumn;
 
 #[test]
 fn test_filtering_with_sorting_with_pagination() {
@@ -27,7 +29,7 @@ fn test_filtering_with_sorting_with_pagination() {
                 filter_operator: FilterOperator::GreaterThan,
                 conditional_operator: ConditionalOperator::Or,
             }),
-        ]))
+        ])),
     );
 
     let sql = filters.sql();
@@ -61,7 +63,7 @@ fn test_filtering_with_case_sensitive() {
                 filter_operator: FilterOperator::GreaterThan,
                 conditional_operator: ConditionalOperator::Or,
             }),
-        ]))
+        ])),
     );
 
     let sql = filters.sql();
@@ -71,7 +73,6 @@ fn test_filtering_with_case_sensitive() {
     );
 }
 
-
 #[test]
 fn test_filtering_without_sorting_with_pagination() {
     let filters = PgFilters::new(
@@ -97,7 +98,10 @@ fn test_filtering_without_sorting_with_pagination() {
     );
 
     let sql = filters.sql();
-    assert_eq!(sql, " WHERE LOWER(name) = LOWER('John') OR age > 18 LIMIT 10 OFFSET 0");
+    assert_eq!(
+        sql,
+        " WHERE LOWER(name) = LOWER('John') OR age > 18 LIMIT 10 OFFSET 0"
+    );
 }
 
 #[test]
@@ -123,7 +127,10 @@ fn test_filtering_with_sorting_without_pagination() {
     );
 
     let sql = filters.sql();
-    assert_eq!(sql, " WHERE LOWER(name) = LOWER('John') OR age > 18 ORDER BY name ASC");
+    assert_eq!(
+        sql,
+        " WHERE LOWER(name) = LOWER('John') OR age > 18 ORDER BY name ASC"
+    );
 }
 
 #[test]
@@ -162,7 +169,7 @@ fn test_filtering_with_sorting_with_pagination_with_empty_filters() {
             column: "name".to_string(),
             order: SortOrder::Asc,
         }],
-        Some(FilteringOptions::new(vec![]))
+        Some(FilteringOptions::new(vec![])),
     );
 
     let sql = filters.sql();
@@ -234,7 +241,10 @@ fn test_filtering_with_sorting_with_pagination_with_empty_sorting() {
     );
 
     let sql = filters.sql();
-    assert_eq!(sql, " WHERE LOWER(name) = LOWER('John') OR age > 18 LIMIT 10 OFFSET 0");
+    assert_eq!(
+        sql,
+        " WHERE LOWER(name) = LOWER('John') OR age > 18 LIMIT 10 OFFSET 0"
+    );
 }
 
 #[test]
diff --git a/tests/unit/filtering_rule_test.rs b/tests/unit/filtering_rule_test.rs
index d3f6477..80c2201 100644
--- a/tests/unit/filtering_rule_test.rs
+++ b/tests/unit/filtering_rule_test.rs
@@ -1,10 +1,21 @@
-use pg_filters::filtering::{ColumnName, ConditionalOperator, FilterOperator, FilteringRule, FilterColumn};
+use pg_filters::filtering::{
+    ColumnName, ConditionalOperator, FilterColumn, FilterOperator, FilteringRule,
+};
 
 #[test]
 fn test_filtering_rule() {
-    let filtering_rule = FilteringRule::new("and".into(), ColumnName::String("name"), "=".into(), "John".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "and".into(),
+        ColumnName::String("name"),
+        "=".into(),
+        "John".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("name", "'John'".to_string()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("name", "'John'".to_string())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::Equal);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -14,7 +25,8 @@ fn test_filtering_rule() {
 
 #[test]
 fn test_filtering_rule_with_int_value() {
-    let filtering_rule = FilteringRule::new("or".into(), ColumnName::Int("age"), ">".into(), "18".into()).unwrap();
+    let filtering_rule =
+        FilteringRule::new("or".into(), ColumnName::Int("age"), ">".into(), "18".into()).unwrap();
 
     assert_eq!(filtering_rule.filter_column, FilterColumn::Int("age", 18));
     assert_eq!(filtering_rule.filter_operator, FilterOperator::GreaterThan);
@@ -23,10 +35,18 @@ fn test_filtering_rule_with_int_value() {
 
 #[test]
 fn test_filtering_rule_with_float_value() {
-    let filtering_rule =
-        FilteringRule::new("and".into(), ColumnName::Float("height"), ">=".into(), "5.5".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "and".into(),
+        ColumnName::Float("height"),
+        ">=".into(),
+        "5.5".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::Float("height", 5.5));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::Float("height", 5.5)
+    );
     assert_eq!(
         filtering_rule.filter_operator,
         FilterOperator::GreaterThanOrEqual
@@ -39,20 +59,36 @@ fn test_filtering_rule_with_float_value() {
 
 #[test]
 fn test_filtering_rule_with_bool_value() {
-    let filtering_rule =
-        FilteringRule::new("or".into(), ColumnName::Bool("is_active"), "=".into(), "true".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "or".into(),
+        ColumnName::Bool("is_active"),
+        "=".into(),
+        "true".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::Bool("is_active", true));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::Bool("is_active", true)
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::Equal);
     assert_eq!(filtering_rule.conditional_operator, ConditionalOperator::Or);
 }
 
 #[test]
 fn test_filtering_rule_with_null_value() {
-    let filtering_rule =
-        FilteringRule::new("and".into(), ColumnName::String("email"), "is null".into(), "".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "and".into(),
+        ColumnName::String("email"),
+        "is null".into(),
+        "".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("email", "".into()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("email", "".into())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::IsNull);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -62,20 +98,36 @@ fn test_filtering_rule_with_null_value() {
 
 #[test]
 fn test_filtering_rule_with_not_null_value() {
-    let filtering_rule =
-        FilteringRule::new("or".into(), ColumnName::String("email"), "is not null".into(), "".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "or".into(),
+        ColumnName::String("email"),
+        "is not null".into(),
+        "".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("email", "".into()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("email", "".into())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::IsNotNull);
     assert_eq!(filtering_rule.conditional_operator, ConditionalOperator::Or);
 }
 
 #[test]
 fn test_filtering_rule_with_like_value() {
-    let filtering_rule =
-        FilteringRule::new("and".into(), ColumnName::String("name"), "like".into(), "John".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "and".into(),
+        ColumnName::String("name"),
+        "like".into(),
+        "John".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("name", "'%John%'".into()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("name", "'%John%'".into())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::Like);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -85,10 +137,18 @@ fn test_filtering_rule_with_like_value() {
 
 #[test]
 fn test_filtering_rule_with_not_like_value() {
-    let filtering_rule =
-        FilteringRule::new("or".into(), ColumnName::String("name"), "not like".into(), "John".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "or".into(),
+        ColumnName::String("name"),
+        "not like".into(),
+        "John".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("name", "'%John%'".into()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("name", "'%John%'".into())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::NotLike);
     assert_eq!(filtering_rule.conditional_operator, ConditionalOperator::Or);
 }
@@ -100,9 +160,13 @@ fn test_filtering_rule_with_string_in_value() {
         ColumnName::String("name"),
         "in".into(),
         "John,Jane".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::StringList("name", vec!["'John'".into(), "'Jane'".into()]));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::StringList("name", vec!["'John'".into(), "'Jane'".into()])
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::In);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -117,9 +181,13 @@ fn test_filtering_rule_with_int_in_value() {
         ColumnName::Int("name"),
         "in".into(),
         "1,2,3".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::IntList("name", vec![1,2,3]));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::IntList("name", vec![1, 2, 3])
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::In);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -134,9 +202,13 @@ fn test_filtering_rule_with_float_in_value() {
         ColumnName::Float("name"),
         "in".into(),
         "1.1,2.2,3.0".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::FloatList("name", vec![1.1,2.2,3.0]));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::FloatList("name", vec![1.1, 2.2, 3.0])
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::In);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -151,9 +223,13 @@ fn test_filtering_rule_with_bool_in_value() {
         ColumnName::Bool("name"),
         "in".into(),
         "true,false".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::BoolList("name", vec![true, false]));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::BoolList("name", vec![true, false])
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::In);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -168,9 +244,13 @@ fn test_filtering_rule_with_string_not_in_value() {
         ColumnName::String("name"),
         "not in".into(),
         "John,Jane".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::StringList("name", vec!["'John'".into(), "'Jane'".into()]));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::StringList("name", vec!["'John'".into(), "'Jane'".into()])
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::NotIn);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -185,9 +265,13 @@ fn test_filtering_rule_with_int_not_in_value() {
         ColumnName::Int("name"),
         "not in".into(),
         "1,2,3".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::IntList("name", vec![1,2,3]));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::IntList("name", vec![1, 2, 3])
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::NotIn);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -202,9 +286,13 @@ fn test_filtering_rule_with_float_not_in_value() {
         ColumnName::Float("name"),
         "not in".into(),
         "1.1,2.2,3.0".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::FloatList("name", vec![1.1,2.2,3.0]));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::FloatList("name", vec![1.1, 2.2, 3.0])
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::NotIn);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -219,9 +307,13 @@ fn test_filtering_rule_with_bool_not_in_value() {
         ColumnName::Bool("name"),
         "not in".into(),
         "true,false".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::BoolList("name", vec![true, false]));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::BoolList("name", vec![true, false])
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::NotIn);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -231,9 +323,18 @@ fn test_filtering_rule_with_bool_not_in_value() {
 
 #[test]
 fn test_filtering_rule_with_invalid_filter_operator() {
-    let filtering_rule = FilteringRule::new("and".into(), ColumnName::String("name"), "}".into(), "John".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "and".into(),
+        ColumnName::String("name"),
+        "}".into(),
+        "John".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("name", "'John'".into()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("name", "'John'".into())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::Equal);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -243,9 +344,18 @@ fn test_filtering_rule_with_invalid_filter_operator() {
 
 #[test]
 fn test_filtering_rule_with_invalid_conditional_operator() {
-    let filtering_rule = FilteringRule::new("}".into(), ColumnName::String("name"), "=".into(), "John".into()).unwrap();
+    let filtering_rule = FilteringRule::new(
+        "}".into(),
+        ColumnName::String("name"),
+        "=".into(),
+        "John".into(),
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("name", "'John'".into()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("name", "'John'".into())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::Equal);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -260,9 +370,13 @@ fn test_filtering_rule_with_starts_with_value() {
         ColumnName::String("name"),
         "starts with".into(),
         "John".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("name", "'John%'".into()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("name", "'John%'".into())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::StartsWith);
     assert_eq!(
         filtering_rule.conditional_operator,
@@ -277,9 +391,13 @@ fn test_filtering_rule_with_ends_with_value() {
         ColumnName::String("name"),
         "ends with".into(),
         "John".into(),
-    ).unwrap();
+    )
+    .unwrap();
 
-    assert_eq!(filtering_rule.filter_column, FilterColumn::String("name", "'%John'".into()));
+    assert_eq!(
+        filtering_rule.filter_column,
+        FilterColumn::String("name", "'%John'".into())
+    );
     assert_eq!(filtering_rule.filter_operator, FilterOperator::EndsWith);
     assert_eq!(filtering_rule.conditional_operator, ConditionalOperator::Or);
 }
diff --git a/tests/unit/filtering_test.rs b/tests/unit/filtering_test.rs
index 3dce2a7..0674fb2 100644
--- a/tests/unit/filtering_test.rs
+++ b/tests/unit/filtering_test.rs
@@ -1,105 +1,136 @@
-use pg_filters::{filtering::{
-    ConditionalOperator, Filtering, FilteringRule, FilterOperator
-}, FilteringOptions};
 use pg_filters::filtering::FilterColumn;
+use pg_filters::{
+    filtering::{ConditionalOperator, FilterOperator, Filtering, FilteringRule},
+    FilteringOptions,
+};
 
 #[test]
 fn test_filtering() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-    ],  true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 2);
-    assert_eq!(filtering.sql, " WHERE LOWER(name) = LOWER('John') OR age > 18");
+    assert_eq!(
+        filtering.sql,
+        " WHERE LOWER(name) = LOWER('John') OR age > 18"
+    );
 }
 
 #[test]
 fn test_filtering_case_sensitive() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-    ],  false);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        false,
+    );
     assert_eq!(filtering.filters.len(), 2);
     assert_eq!(filtering.sql, " WHERE name = 'John' OR age > 18");
 }
 
 #[test]
 fn test_filtering_with_bool() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Bool("completed", true),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-    ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Bool("completed", true),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 2);
-    assert_eq!(filtering.sql, " WHERE LOWER(name) = LOWER('John') OR completed = true");
+    assert_eq!(
+        filtering.sql,
+        " WHERE LOWER(name) = LOWER('John') OR completed = true"
+    );
 }
 
 #[test]
 fn test_filtering_with_float() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Float("value", 1.1),
-            filter_operator: FilterOperator::LessThanOrEqual,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-    ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Float("value", 1.1),
+                filter_operator: FilterOperator::LessThanOrEqual,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 2);
-    assert_eq!(filtering.sql, " WHERE LOWER(name) = LOWER('John') OR value <= 1.1");
+    assert_eq!(
+        filtering.sql,
+        " WHERE LOWER(name) = LOWER('John') OR value <= 1.1"
+    );
 }
 
 #[test]
 fn test_filtering_with_duplicate_columns() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'Doe'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'Doe'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 2);
-    assert_eq!(filtering.sql, " WHERE LOWER(name) = LOWER('John') OR LOWER(name) = LOWER('Doe')");
+    assert_eq!(
+        filtering.sql,
+        " WHERE LOWER(name) = LOWER('John') OR LOWER(name) = LOWER('Doe')"
+    );
 }
 
 #[test]
 fn test_filtering_with_single_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "'John'".to_string()),
-        filter_operator: FilterOperator::Equal,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "'John'".to_string()),
+            filter_operator: FilterOperator::Equal,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE LOWER(name) = LOWER('John')");
 }
@@ -113,59 +144,74 @@ fn test_filtering_with_empty_rules() {
 
 #[test]
 fn test_filtering_with_multiple_rules() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 2);
-    assert_eq!(filtering.sql, " WHERE LOWER(name) = LOWER('John') OR age > 18");
+    assert_eq!(
+        filtering.sql,
+        " WHERE LOWER(name) = LOWER('John') OR age > 18"
+    );
 }
 
 #[test]
 fn test_filtering_with_multiple_rules_swapped() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::And,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 2);
-    assert_eq!(filtering.sql, " WHERE LOWER(name) = LOWER('John') AND age > 18");
+    assert_eq!(
+        filtering.sql,
+        " WHERE LOWER(name) = LOWER('John') AND age > 18"
+    );
 }
 
 #[test]
 fn test_filtering_with_multiple_rules_and_different_operators() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        Ok(FilteringRule {
-           filter_column: FilterColumn::String("city", "'New York'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("city", "'New York'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 3);
     assert_eq!(
         filtering.sql,
@@ -175,23 +221,26 @@ fn test_filtering_with_multiple_rules_and_different_operators() {
 
 #[test]
 fn test_filtering_with_multiple_rules_and_different_operators_swapped() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-           filter_column: FilterColumn::String("city", "'New York'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("city", "'New York'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 3);
     assert_eq!(
         filtering.sql,
@@ -201,23 +250,26 @@ fn test_filtering_with_multiple_rules_and_different_operators_swapped() {
 
 #[test]
 fn test_filtering_with_multiple_rules_and_different_operators_swapped_and_mixed() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-           filter_column: FilterColumn::String("city", "'New York'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("city", "'New York'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 3);
     assert_eq!(
         filtering.sql,
@@ -227,210 +279,276 @@ fn test_filtering_with_multiple_rules_and_different_operators_swapped_and_mixed(
 
 #[test]
 fn test_filtering_with_equal_to_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "'John'".to_string()),
-        filter_operator: FilterOperator::Equal,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "'John'".to_string()),
+            filter_operator: FilterOperator::Equal,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE LOWER(name) = LOWER('John')");
 }
 
 #[test]
 fn test_filtering_with_not_equal_to_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "'John'".to_string()),
-        filter_operator: FilterOperator::NotEqual,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "'John'".to_string()),
+            filter_operator: FilterOperator::NotEqual,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE LOWER(name) != LOWER('John')");
 }
 
 #[test]
 fn test_filtering_with_greater_than_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::Int("age", 18),
-        filter_operator: FilterOperator::GreaterThan,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::Int("age", 18),
+            filter_operator: FilterOperator::GreaterThan,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE age > 18");
 }
 
 #[test]
 fn test_filtering_with_greater_than_or_equal_to_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::Int("age", 18),
-        filter_operator: FilterOperator::GreaterThanOrEqual,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::Int("age", 18),
+            filter_operator: FilterOperator::GreaterThanOrEqual,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE age >= 18");
 }
 
 #[test]
 fn test_filtering_with_less_than_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::Int("age", 18),
-        filter_operator: FilterOperator::LessThan,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::Int("age", 18),
+            filter_operator: FilterOperator::LessThan,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE age < 18");
 }
 
 #[test]
 fn test_filtering_with_less_than_or_equal_to_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::Int("age", 18),
-        filter_operator: FilterOperator::LessThanOrEqual,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::Int("age", 18),
+            filter_operator: FilterOperator::LessThanOrEqual,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE age <= 18");
 }
 
 #[test]
 fn test_filtering_with_like_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "'%John%'".to_string()),
-        filter_operator: FilterOperator::Like,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "'%John%'".to_string()),
+            filter_operator: FilterOperator::Like,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE LOWER(name) LIKE LOWER('%John%')");
 }
 
 #[test]
 fn test_filtering_with_not_like_rule() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "'%John%'".to_string()),
-        filter_operator: FilterOperator::NotLike,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "'%John%'".to_string()),
+            filter_operator: FilterOperator::NotLike,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE LOWER(name) NOT LIKE LOWER('%John%')");
 }
 
 #[test]
 fn test_filtering_with_is_null() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "".to_string()),
-        filter_operator: FilterOperator::IsNull,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "".to_string()),
+            filter_operator: FilterOperator::IsNull,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE name IS NULL");
 }
 
 #[test]
 fn test_filtering_with_is_not_null() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "".to_string()),
-        filter_operator: FilterOperator::IsNotNull,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "".to_string()),
+            filter_operator: FilterOperator::IsNotNull,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE name IS NOT NULL");
 }
 
 #[test]
 fn test_filtering_with_in_as_string() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::StringList("name", vec!["John".to_string(), "Doe".to_string()]),
-        filter_operator: FilterOperator::In,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::StringList(
+                "name",
+                vec!["John".to_string(), "Doe".to_string()],
+            ),
+            filter_operator: FilterOperator::In,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
-    assert_eq!(filtering.sql, " WHERE LOWER(name) IN (LOWER('John'), LOWER('Doe'))");
+    assert_eq!(
+        filtering.sql,
+        " WHERE LOWER(name) IN (LOWER('John'), LOWER('Doe'))"
+    );
 }
 
 #[test]
 fn test_filtering_with_in_as_int() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::IntList("age", vec![21, 22, 23]),
-        filter_operator: FilterOperator::In,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::IntList("age", vec![21, 22, 23]),
+            filter_operator: FilterOperator::In,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE age IN (21, 22, 23)");
 }
 
 #[test]
 fn test_filtering_with_in_as_float() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::FloatList("age", vec![2.1, 2.2, 2.3]),
-        filter_operator: FilterOperator::In,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::FloatList("age", vec![2.1, 2.2, 2.3]),
+            filter_operator: FilterOperator::In,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE age IN (2.1, 2.2, 2.3)");
 }
 
 #[test]
 fn test_filtering_with_in_as_bool() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::BoolList("age", vec![true, false]),
-        filter_operator: FilterOperator::In,
-        conditional_operator: ConditionalOperator::And,
-    }) ], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::BoolList("age", vec![true, false]),
+            filter_operator: FilterOperator::In,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE age IN (true, false)");
 }
 
 #[test]
 fn test_filtering_with_not_in() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::StringList("name", vec!["John".to_string(), "Doe".to_string()]),
-        filter_operator: FilterOperator::NotIn,
-        conditional_operator: ConditionalOperator::And,
-    })], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::StringList(
+                "name",
+                vec!["John".to_string(), "Doe".to_string()],
+            ),
+            filter_operator: FilterOperator::NotIn,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
-    assert_eq!(filtering.sql, " WHERE LOWER(name) NOT IN (LOWER('John'), LOWER('Doe'))");
+    assert_eq!(
+        filtering.sql,
+        " WHERE LOWER(name) NOT IN (LOWER('John'), LOWER('Doe'))"
+    );
 }
 
 #[test]
 fn test_filtering_with_starts_with() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "'John%'".to_string()),
-        filter_operator: FilterOperator::StartsWith,
-        conditional_operator: ConditionalOperator::And,
-    })], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "'John%'".to_string()),
+            filter_operator: FilterOperator::StartsWith,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE LOWER(name) LIKE LOWER('John%')");
 }
 
 #[test]
 fn test_filtering_with_ends_with() {
-    let filtering = Filtering::new(vec![Ok(FilteringRule {
-        filter_column: FilterColumn::String("name", "'%John'".to_string()),
-        filter_operator: FilterOperator::EndsWith,
-        conditional_operator: ConditionalOperator::And,
-    })], true);
+    let filtering = Filtering::new(
+        vec![Ok(FilteringRule {
+            filter_column: FilterColumn::String("name", "'%John'".to_string()),
+            filter_operator: FilterOperator::EndsWith,
+            conditional_operator: ConditionalOperator::And,
+        })],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 1);
     assert_eq!(filtering.sql, " WHERE LOWER(name) LIKE LOWER('%John')");
 }
 
 #[test]
 fn test_filtering_with_multiple_rules_and_different_operators_and_values() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        Ok(FilteringRule {
-           filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
-            filter_operator: FilterOperator::Like,
-            conditional_operator: ConditionalOperator::And,
-        }),
-    ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
+                filter_operator: FilterOperator::Like,
+                conditional_operator: ConditionalOperator::And,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 3);
     assert_eq!(
         filtering.sql,
@@ -440,23 +558,26 @@ fn test_filtering_with_multiple_rules_and_different_operators_and_values() {
 
 #[test]
 fn test_filtering_with_multiple_rules_and_different_operators_and_values_swapped() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-           filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
-            filter_operator: FilterOperator::Like,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-    ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
+                filter_operator: FilterOperator::Like,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 3);
     assert_eq!(
         filtering.sql,
@@ -466,23 +587,26 @@ fn test_filtering_with_multiple_rules_and_different_operators_and_values_swapped
 
 #[test]
 fn test_filtering_with_multiple_rules_and_different_operators_and_values_swapped_and_mixed() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-           filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
-            filter_operator: FilterOperator::Like,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
+                filter_operator: FilterOperator::Like,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 3);
     assert_eq!(
         filtering.sql,
@@ -493,28 +617,31 @@ fn test_filtering_with_multiple_rules_and_different_operators_and_values_swapped
 #[test]
 fn test_filtering_with_multiple_rules_and_different_operators_and_values_swapped_and_mixed_and_repeated(
 ) {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-           filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
-            filter_operator: FilterOperator::Like,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'Doe'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
+                filter_operator: FilterOperator::Like,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'Doe'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 4);
     assert_eq!(
         filtering.sql,
@@ -524,28 +651,31 @@ fn test_filtering_with_multiple_rules_and_different_operators_and_values_swapped
 
 #[test]
 fn test_filtering_with_many_rules_and_conditions_with_no_duplicates_with_or_and_and() {
-    let filtering = Filtering::new(vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::Int("age", 18),
-            filter_operator: FilterOperator::GreaterThan,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        Ok(FilteringRule {
-           filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
-            filter_operator: FilterOperator::Like,
-            conditional_operator: ConditionalOperator::Or,
-        }),
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'Doe'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::And,
-        }),
-        ], true);
+    let filtering = Filtering::new(
+        vec![
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'John'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::Int("age", 18),
+                filter_operator: FilterOperator::GreaterThan,
+                conditional_operator: ConditionalOperator::And,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("city", "'%New York%'".to_string()),
+                filter_operator: FilterOperator::Like,
+                conditional_operator: ConditionalOperator::Or,
+            }),
+            Ok(FilteringRule {
+                filter_column: FilterColumn::String("name", "'Doe'".to_string()),
+                filter_operator: FilterOperator::Equal,
+                conditional_operator: ConditionalOperator::And,
+            }),
+        ],
+        true,
+    );
     assert_eq!(filtering.filters.len(), 4);
     assert_eq!(
         filtering.sql,
@@ -555,14 +685,11 @@ fn test_filtering_with_many_rules_and_conditions_with_no_duplicates_with_or_and_
 
 #[test]
 fn test_filtering_options_case_insensitive() {
-   let filtering_options = FilteringOptions::new(
-    vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),]
-   );
+    let filtering_options = FilteringOptions::new(vec![Ok(FilteringRule {
+        filter_column: FilterColumn::String("name", "'John'".to_string()),
+        filter_operator: FilterOperator::Equal,
+        conditional_operator: ConditionalOperator::Or,
+    })]);
 
     assert_eq!(filtering_options.filtering_rules.len(), 1);
     assert_eq!(filtering_options.case_insensitive, true);
@@ -570,15 +697,12 @@ fn test_filtering_options_case_insensitive() {
 
 #[test]
 fn test_filtering_options_case_sensitive() {
-   let filtering_options = FilteringOptions::case_sensitive(
-    vec![
-        Ok(FilteringRule {
-            filter_column: FilterColumn::String("name", "'John'".to_string()),
-            filter_operator: FilterOperator::Equal,
-            conditional_operator: ConditionalOperator::Or,
-        }),]
-   );
+    let filtering_options = FilteringOptions::case_sensitive(vec![Ok(FilteringRule {
+        filter_column: FilterColumn::String("name", "'John'".to_string()),
+        filter_operator: FilterOperator::Equal,
+        conditional_operator: ConditionalOperator::Or,
+    })]);
 
     assert_eq!(filtering_options.filtering_rules.len(), 1);
     assert_eq!(filtering_options.case_insensitive, false);
-}
\ No newline at end of file
+}
diff --git a/tests/unit/mod.rs b/tests/unit/mod.rs
index af9ddd7..2bcd2fe 100644
--- a/tests/unit/mod.rs
+++ b/tests/unit/mod.rs
@@ -1,5 +1,5 @@
-pub mod sorting_test;
 pub mod combined_test;
-pub mod filtering_test;
 pub mod filtering_rule_test;
+pub mod filtering_test;
 pub mod pagination_test;
+pub mod sorting_test;