diff --git a/lutra/bindings/python/src/lib.rs b/lutra/bindings/python/src/lib.rs
index e9b8066c6425..7cac8e9f2b6f 100644
--- a/lutra/bindings/python/src/lib.rs
+++ b/lutra/bindings/python/src/lib.rs
@@ -1,9 +1,9 @@
 #![cfg(not(target_family = "wasm"))]
 
-use arrow::{pyarrow::PyArrowType, record_batch::RecordBatch};
-use itertools::Itertools;
 use std::str::FromStr;
 
+use arrow::{pyarrow::PyArrowType, record_batch::RecordBatch};
+use itertools::Itertools;
 use pyo3::prelude::*;
 
 #[pymodule]
diff --git a/prqlc/bindings/java/src/lib.rs b/prqlc/bindings/java/src/lib.rs
index 73b9a44d6df3..ceb7340068d4 100644
--- a/prqlc/bindings/java/src/lib.rs
+++ b/prqlc/bindings/java/src/lib.rs
@@ -1,8 +1,9 @@
+use std::str::FromStr;
+
 use jni::objects::{JClass, JString};
 use jni::sys::{jboolean, jstring};
 use jni::JNIEnv;
 use prqlc::{json, pl_to_prql, prql_to_pl, ErrorMessages, Options, Target};
-use std::str::FromStr;
 
 #[no_mangle]
 #[allow(non_snake_case)]
diff --git a/prqlc/bindings/prqlc-c/src/lib.rs b/prqlc/bindings/prqlc-c/src/lib.rs
index 683d8b264f69..25c0fc66132f 100644
--- a/prqlc/bindings/prqlc-c/src/lib.rs
+++ b/prqlc/bindings/prqlc-c/src/lib.rs
@@ -2,13 +2,14 @@
 
 extern crate libc;
 
-use libc::{c_char, size_t};
-use prqlc::ErrorMessages;
-use prqlc::Target;
 use std::ffi::CStr;
 use std::ffi::CString;
 use std::str::FromStr;
 
+use libc::{c_char, size_t};
+use prqlc::ErrorMessages;
+use prqlc::Target;
+
 /// Compile a PRQL string into a SQL string.
 ///
 /// This is a wrapper for: `prql_to_pl`, `pl_to_rq` and `rq_to_sql` without converting to JSON
diff --git a/prqlc/bindings/prqlc-python/src/lib.rs b/prqlc/bindings/prqlc-python/src/lib.rs
index 51b26fc9b41f..004c9aa41cad 100644
--- a/prqlc/bindings/prqlc-python/src/lib.rs
+++ b/prqlc/bindings/prqlc-python/src/lib.rs
@@ -134,9 +134,10 @@ pub fn get_targets() -> Vec<String> {
 #[cfg(not(feature = "extension-module"))]
 #[cfg(test)]
 mod test {
-    use super::*;
     use insta::assert_snapshot;
 
+    use super::*;
+
     #[test]
     fn parse_for_python() {
         let opts = Some(CompileOptions {
diff --git a/prqlc/prqlc-ast/src/error.rs b/prqlc/prqlc-ast/src/error.rs
index c95718c99acc..ba2d5bb3128e 100644
--- a/prqlc/prqlc-ast/src/error.rs
+++ b/prqlc/prqlc-ast/src/error.rs
@@ -191,9 +191,10 @@ impl<T, E: WithErrorInfo> WithErrorInfo for Result<T, E> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use insta::{assert_debug_snapshot, assert_snapshot};
 
+    use super::*;
+
     // Helper function to create a simple Error object
     fn create_simple_error() -> Error {
         Error::new_simple("A simple error message")
diff --git a/prqlc/prqlc-ast/src/expr.rs b/prqlc/prqlc-ast/src/expr.rs
index 27395714c5e1..d52e90dd2f4e 100644
--- a/prqlc/prqlc-ast/src/expr.rs
+++ b/prqlc/prqlc-ast/src/expr.rs
@@ -3,15 +3,14 @@ mod ident;
 mod literal;
 mod ops;
 
-pub use ident::Ident;
-pub use literal::{Literal, ValueAndUnit};
-pub use ops::{BinOp, UnOp};
-
 use std::collections::HashMap;
 
 use enum_as_inner::EnumAsInner;
 use serde::{Deserialize, Serialize};
 
+pub use self::ident::Ident;
+pub use self::literal::{Literal, ValueAndUnit};
+pub use self::ops::{BinOp, UnOp};
 use crate::{Span, Ty};
 
 impl Expr {
diff --git a/prqlc/prqlc-ast/src/span.rs b/prqlc/prqlc-ast/src/span.rs
index 1fb025a8a126..1fcf5d2f031c 100644
--- a/prqlc/prqlc-ast/src/span.rs
+++ b/prqlc/prqlc-ast/src/span.rs
@@ -1,8 +1,9 @@
-use serde::de::Visitor;
-use serde::{Deserialize, Serialize};
 use std::fmt::{self, Debug, Formatter};
 use std::ops::Range;
 
+use serde::de::Visitor;
+use serde::{Deserialize, Serialize};
+
 #[derive(Clone, PartialEq, Eq, Copy)]
 pub struct Span {
     pub start: usize,
diff --git a/prqlc/prqlc-ast/src/types.rs b/prqlc/prqlc-ast/src/types.rs
index 42d29fb00afc..5b19cb966069 100644
--- a/prqlc/prqlc-ast/src/types.rs
+++ b/prqlc/prqlc-ast/src/types.rs
@@ -2,9 +2,8 @@ use enum_as_inner::EnumAsInner;
 use serde::{Deserialize, Serialize};
 use strum::AsRefStr;
 
-use crate::{Ident, Span};
-
 use super::Literal;
+use crate::{Ident, Span};
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Ty {
diff --git a/prqlc/prqlc-parser/src/expr.rs b/prqlc/prqlc-parser/src/expr.rs
index 7d030ea28d08..f984cd2bddee 100644
--- a/prqlc/prqlc-parser/src/expr.rs
+++ b/prqlc/prqlc-parser/src/expr.rs
@@ -1,16 +1,14 @@
 use std::collections::HashMap;
 
 use chumsky::prelude::*;
-
 use prqlc_ast::expr::*;
 use prqlc_ast::Span;
 
-use crate::types::type_expr;
-
 use super::common::*;
 use super::interpolation;
 use super::lexer::TokenKind;
 use super::span::ParserSpan;
+use crate::types::type_expr;
 
 pub fn expr_call() -> impl Parser<TokenKind, Expr, Error = PError> {
     let expr = expr();
diff --git a/prqlc/prqlc-parser/src/interpolation.rs b/prqlc/prqlc-parser/src/interpolation.rs
index e8822c806d37..4d614e34b6a2 100644
--- a/prqlc/prqlc-parser/src/interpolation.rs
+++ b/prqlc/prqlc-parser/src/interpolation.rs
@@ -2,11 +2,10 @@ use chumsky::{error::Cheap, prelude::*};
 use itertools::Itertools;
 use prqlc_ast::expr::*;
 
-use crate::Span;
-
 use super::common::{into_expr, PError};
 use super::lexer::*;
 use super::span::ParserSpan;
+use crate::Span;
 
 /// Parses interpolated strings
 pub fn parse(string: String, span_base: ParserSpan) -> Result<Vec<InterpolateItem>, Vec<PError>> {
diff --git a/prqlc/prqlc-parser/src/lexer.rs b/prqlc/prqlc-parser/src/lexer.rs
index 32022af83aee..c01181ee2837 100644
--- a/prqlc/prqlc-parser/src/lexer.rs
+++ b/prqlc/prqlc-parser/src/lexer.rs
@@ -3,7 +3,6 @@ use chumsky::{
     prelude::*,
     text::{newline, Character},
 };
-
 use prqlc_ast::expr::*;
 use serde::{Deserialize, Serialize};
 
@@ -594,10 +593,11 @@ pub struct TokenVec(pub Vec<Token>);
 
 #[cfg(test)]
 mod test {
-    use super::*;
     use insta::assert_debug_snapshot;
     use insta::assert_snapshot;
 
+    use super::*;
+
     #[test]
     fn line_wrap() {
         assert_debug_snapshot!(TokenVec(lexer().parse(r"5 +
diff --git a/prqlc/prqlc-parser/src/lib.rs b/prqlc/prqlc-parser/src/lib.rs
index 1a930961fe98..6a74c7ba3cc9 100644
--- a/prqlc/prqlc-parser/src/lib.rs
+++ b/prqlc/prqlc-parser/src/lib.rs
@@ -9,14 +9,13 @@ mod types;
 
 use chumsky::error::SimpleReason;
 use chumsky::{prelude::*, Stream};
-
 use prqlc_ast::error::{Error, Reason, WithErrorInfo};
 use prqlc_ast::stmt::*;
 use prqlc_ast::Span;
 
-use lexer::Token;
-pub use lexer::{TokenKind, TokenVec};
-use span::ParserSpan;
+use self::lexer::Token;
+pub use self::lexer::{TokenKind, TokenVec};
+use self::span::ParserSpan;
 
 /// Build PRQL AST from a PRQL query string.
 pub fn parse_source(source: &str, source_id: u16) -> Result<Vec<Stmt>, Vec<Error>> {
@@ -70,12 +69,12 @@ pub fn lex_source(source: &str) -> Result<TokenVec, Vec<Error>> {
 
 mod common {
     use chumsky::prelude::*;
+    use prqlc_ast::expr::*;
+    use prqlc_ast::stmt::*;
     use prqlc_ast::Ty;
     use prqlc_ast::TyKind;
 
     use super::{lexer::TokenKind, span::ParserSpan};
-    use prqlc_ast::expr::*;
-    use prqlc_ast::stmt::*;
 
     pub type PError = Simple<TokenKind, ParserSpan>;
 
diff --git a/prqlc/prqlc-parser/src/stmt.rs b/prqlc/prqlc-parser/src/stmt.rs
index b86b7285a6f9..a3cbe4580628 100644
--- a/prqlc/prqlc-parser/src/stmt.rs
+++ b/prqlc/prqlc-parser/src/stmt.rs
@@ -1,17 +1,15 @@
-use itertools::Itertools;
 use std::collections::HashMap;
 
 use chumsky::prelude::*;
-use semver::VersionReq;
-
+use itertools::Itertools;
 use prqlc_ast::expr::*;
 use prqlc_ast::stmt::*;
-
-use crate::types::type_expr;
+use semver::VersionReq;
 
 use super::common::*;
 use super::expr::*;
 use super::lexer::TokenKind;
+use crate::types::type_expr;
 
 pub fn source() -> impl Parser<TokenKind, Vec<Stmt>, Error = PError> {
     query_def()
diff --git a/prqlc/prqlc-parser/src/types.rs b/prqlc/prqlc-parser/src/types.rs
index 3650a3774140..7958eb10d0ed 100644
--- a/prqlc/prqlc-parser/src/types.rs
+++ b/prqlc/prqlc-parser/src/types.rs
@@ -1,11 +1,9 @@
 use chumsky::prelude::*;
-
 use prqlc_ast::*;
 
-use crate::expr::ident;
-
 use super::common::*;
 use super::lexer::TokenKind;
+use crate::expr::ident;
 
 pub fn type_expr() -> impl Parser<TokenKind, Ty, Error = PError> {
     recursive(|nested_type_expr| {
diff --git a/prqlc/prqlc/examples/compile-files/build.rs b/prqlc/prqlc/examples/compile-files/build.rs
index f4286f5c0797..342f555c0893 100644
--- a/prqlc/prqlc/examples/compile-files/build.rs
+++ b/prqlc/prqlc/examples/compile-files/build.rs
@@ -1,6 +1,7 @@
-use prqlc::{compile, Options};
 use std::{env, fs, path::Path};
 
+use prqlc::{compile, Options};
+
 fn main() {
     // we expect queries to reside in `queries/` dir
     let paths = fs::read_dir("./queries").unwrap();
diff --git a/prqlc/prqlc/src/cli/docs_generator.rs b/prqlc/prqlc/src/cli/docs_generator.rs
index e7643f46bf0b..efae31dd7b0f 100644
--- a/prqlc/prqlc/src/cli/docs_generator.rs
+++ b/prqlc/prqlc/src/cli/docs_generator.rs
@@ -311,9 +311,10 @@ Generated with [prqlc](https://prql-lang.org/) {}.
 
 #[cfg(test)]
 mod tests {
+    use std::process::Command;
+
     use insta_cmd::assert_cmd_snapshot;
     use insta_cmd::get_cargo_bin;
-    use std::process::Command;
 
     #[test]
     fn generate_markdown_docs() {
diff --git a/prqlc/prqlc/src/cli/mod.rs b/prqlc/prqlc/src/cli/mod.rs
index 907bfb5d131c..274da4ac187a 100644
--- a/prqlc/prqlc/src/cli/mod.rs
+++ b/prqlc/prqlc/src/cli/mod.rs
@@ -19,7 +19,6 @@ use clio::has_extension;
 use clio::Output;
 use is_terminal::IsTerminal;
 use itertools::Itertools;
-
 use prqlc::semantic;
 use prqlc::semantic::reporting::{collect_frames, label_references};
 use prqlc::semantic::NS_DEFAULT_DB;
diff --git a/prqlc/prqlc/src/codegen/ast.rs b/prqlc/prqlc/src/codegen/ast.rs
index 6b29bae4bf2d..bdb7688e83b3 100644
--- a/prqlc/prqlc/src/codegen/ast.rs
+++ b/prqlc/prqlc/src/codegen/ast.rs
@@ -1,13 +1,11 @@
 use std::collections::HashSet;
 
 use once_cell::sync::Lazy;
-
-use crate::ast::*;
 use regex::Regex;
 
-use crate::codegen::SeparatedExprs;
-
 use super::{WriteOpt, WriteSource};
+use crate::ast::*;
+use crate::codegen::SeparatedExprs;
 
 pub(crate) fn write_expr(expr: &Expr) -> String {
     expr.write(WriteOpt::new_width(u16::MAX)).unwrap()
diff --git a/prqlc/prqlc/src/codegen/mod.rs b/prqlc/prqlc/src/codegen/mod.rs
index 617e8b0b36ed..baaf02269d51 100644
--- a/prqlc/prqlc/src/codegen/mod.rs
+++ b/prqlc/prqlc/src/codegen/mod.rs
@@ -203,9 +203,10 @@ impl<'a, T: WriteSource> SeparatedExprs<'a, T> {
 
 #[cfg(test)]
 mod test {
+    use insta::assert_snapshot;
+
     use super::*;
     use crate::ast::{Expr, ExprKind, Literal};
-    use insta::assert_snapshot;
 
     #[test]
     fn test_string_quoting() {
diff --git a/prqlc/prqlc/src/codegen/types.rs b/prqlc/prqlc/src/codegen/types.rs
index 318e7593873c..ffaaeed70d09 100644
--- a/prqlc/prqlc/src/codegen/types.rs
+++ b/prqlc/prqlc/src/codegen/types.rs
@@ -1,8 +1,7 @@
+use super::{WriteOpt, WriteSource};
 use crate::ast::*;
 use crate::codegen::SeparatedExprs;
 
-use super::{WriteOpt, WriteSource};
-
 pub(crate) fn write_ty(ty: &Ty) -> String {
     ty.write(WriteOpt::new_width(u16::MAX)).unwrap()
 }
diff --git a/prqlc/prqlc/src/error_message.rs b/prqlc/prqlc/src/error_message.rs
index 89e7c6ae9559..fc9492c065d7 100644
--- a/prqlc/prqlc/src/error_message.rs
+++ b/prqlc/prqlc/src/error_message.rs
@@ -1,17 +1,15 @@
-use anstream::adapter::strip_str;
-
-use ariadne::{Cache, Config, Label, Report, ReportKind, Source};
-use serde::Serialize;
-
 use std::error::Error as StdError;
 use std::fmt::{self, Debug, Display, Formatter};
 use std::ops::Range;
 use std::path::PathBuf;
 use std::{collections::HashMap, io::stderr};
 
-use crate::{Error, Errors, MessageKind, SourceTree};
+use anstream::adapter::strip_str;
+use ariadne::{Cache, Config, Label, Report, ReportKind, Source};
+use serde::Serialize;
 
 pub use crate::ir::Span;
+use crate::{Error, Errors, MessageKind, SourceTree};
 
 #[derive(Clone, Serialize)]
 pub struct ErrorMessage {
diff --git a/prqlc/prqlc/src/ir/constant.rs b/prqlc/prqlc/src/ir/constant.rs
index 010c5bb77038..de11953e9b4d 100644
--- a/prqlc/prqlc/src/ir/constant.rs
+++ b/prqlc/prqlc/src/ir/constant.rs
@@ -1,6 +1,7 @@
-use crate::ast::{Literal, Span};
 use serde::{Deserialize, Serialize};
 
+use crate::ast::{Literal, Span};
+
 /// A subset of PL expressions that are constant.
 #[derive(Serialize, Deserialize)]
 pub struct ConstExpr {
diff --git a/prqlc/prqlc/src/ir/decl.rs b/prqlc/prqlc/src/ir/decl.rs
index adddd0724e7b..e7e30c0ea82e 100644
--- a/prqlc/prqlc/src/ir/decl.rs
+++ b/prqlc/prqlc/src/ir/decl.rs
@@ -1,8 +1,9 @@
+use std::collections::HashMap;
+use std::fmt::Debug;
+
 use enum_as_inner::EnumAsInner;
 use itertools::Itertools;
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use std::fmt::Debug;
 
 use crate::ast::{Span, Ty};
 use crate::codegen::write_ty;
diff --git a/prqlc/prqlc/src/ir/pl/expr.rs b/prqlc/prqlc/src/ir/pl/expr.rs
index 49cceabd6a3c..e5f7696ce763 100644
--- a/prqlc/prqlc/src/ir/pl/expr.rs
+++ b/prqlc/prqlc/src/ir/pl/expr.rs
@@ -1,16 +1,13 @@
 use std::collections::HashMap;
 
 use enum_as_inner::EnumAsInner;
-
 use serde::{Deserialize, Serialize};
 
+use super::{Lineage, TransformCall};
 use crate::ast::generic;
 use crate::ast::{GenericTypeParam, Ident, Literal, Span, Ty};
-
 use crate::codegen::write_ty;
 
-use super::{Lineage, TransformCall};
-
 // The following code is tested by the tests_misc crate to match expr.rs in prqlc_ast.
 
 /// Expr is anything that has a value and thus a type.
diff --git a/prqlc/prqlc/src/ir/pl/fold.rs b/prqlc/prqlc/src/ir/pl/fold.rs
index 2617191b294b..5c792a246f76 100644
--- a/prqlc/prqlc/src/ir/pl/fold.rs
+++ b/prqlc/prqlc/src/ir/pl/fold.rs
@@ -3,11 +3,10 @@
 /// type.
 use itertools::Itertools;
 
+use super::*;
 use crate::ast::{Ty, TyFunc, TyKind, TyTupleField};
 use crate::Result;
 
-use super::*;
-
 // Fold pattern:
 // - https://rust-unofficial.github.io/patterns/patterns/creational/fold.html
 // Good discussions on the visitor / fold pattern:
diff --git a/prqlc/prqlc/src/ir/pl/mod.rs b/prqlc/prqlc/src/ir/pl/mod.rs
index 423ed75d7509..4c6fca500504 100644
--- a/prqlc/prqlc/src/ir/pl/mod.rs
+++ b/prqlc/prqlc/src/ir/pl/mod.rs
@@ -24,13 +24,13 @@ pub use self::utils::*;
 pub use crate::ast::{BinOp, BinaryExpr, Ident, Literal, UnOp, UnaryExpr, ValueAndUnit};
 
 pub fn print_mem_sizes() {
+    use std::mem::size_of;
+
     use crate::ast::{PrimitiveSet, Ty, TyFunc, TyKind, TyTupleField};
     use crate::ir::{decl, generic, pl, rq};
     use crate::sql::internal::SqlTransform;
     use crate::{ErrorMessage, ErrorMessages, SourceTree, Span};
 
-    use std::mem::size_of;
-
     println!("{:16}= {}", "Annotation", size_of::<Annotation>());
     println!("{:16}= {}", "BinaryExpr", size_of::<BinaryExpr>());
     println!("{:16}= {}", "BinOp", size_of::<BinOp>());
diff --git a/prqlc/prqlc/src/ir/pl/stmt.rs b/prqlc/prqlc/src/ir/pl/stmt.rs
index 961e519c23b8..c260aa6ea622 100644
--- a/prqlc/prqlc/src/ir/pl/stmt.rs
+++ b/prqlc/prqlc/src/ir/pl/stmt.rs
@@ -2,11 +2,10 @@ use enum_as_inner::EnumAsInner;
 use prqlc_ast::Ident;
 use serde::{Deserialize, Serialize};
 
+use super::expr::Expr;
 pub use crate::ast::stmt::QueryDef;
 use crate::ast::{Span, Ty};
 
-use super::expr::Expr;
-
 // The following code is tested by the tests_misc crate to match stmt.rs in prqlc_ast.
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
diff --git a/prqlc/prqlc/src/ir/pl/utils.rs b/prqlc/prqlc/src/ir/pl/utils.rs
index 1917d9c435dc..b0208b9e8bbf 100644
--- a/prqlc/prqlc/src/ir/pl/utils.rs
+++ b/prqlc/prqlc/src/ir/pl/utils.rs
@@ -1,6 +1,5 @@
-use crate::ast::expr::Ident;
-
 use super::{Expr, ExprKind, FuncCall};
+use crate::ast::expr::Ident;
 
 pub fn maybe_binop(left: Option<Expr>, op_name: &[&str], right: Option<Expr>) -> Option<Expr> {
     match (left, right) {
diff --git a/prqlc/prqlc/src/ir/rq/fold.rs b/prqlc/prqlc/src/ir/rq/fold.rs
index f94949345f83..dd6184a13e60 100644
--- a/prqlc/prqlc/src/ir/rq/fold.rs
+++ b/prqlc/prqlc/src/ir/rq/fold.rs
@@ -3,11 +3,10 @@
 /// type.
 use itertools::Itertools;
 
+use super::*;
 use crate::ir::generic::{ColumnSort, WindowFrame};
 use crate::Result;
 
-use super::*;
-
 // Fold pattern:
 // - https://rust-unofficial.github.io/patterns/patterns/creational/fold.html
 // Good discussions on the visitor / fold pattern:
diff --git a/prqlc/prqlc/src/ir/rq/mod.rs b/prqlc/prqlc/src/ir/rq/mod.rs
index c299baf18e0e..beb8a1724d59 100644
--- a/prqlc/prqlc/src/ir/rq/mod.rs
+++ b/prqlc/prqlc/src/ir/rq/mod.rs
@@ -8,16 +8,15 @@ mod ids;
 mod transform;
 mod utils;
 
-pub use expr::{Expr, ExprKind, UnOp};
-pub use fold::*;
-pub use ids::*;
-pub use transform::*;
-pub use utils::*;
-
 use enum_as_inner::EnumAsInner;
-use expr::{InterpolateItem, Range, SwitchCase};
 use serde::{Deserialize, Serialize};
 
+pub use self::expr::{Expr, ExprKind, UnOp};
+use self::expr::{InterpolateItem, Range, SwitchCase};
+pub use self::fold::*;
+pub use self::ids::*;
+pub use self::transform::*;
+pub use self::utils::*;
 use super::pl::TableExternRef;
 use super::pl::{Literal, QueryDef};
 
diff --git a/prqlc/prqlc/src/ir/rq/transform.rs b/prqlc/prqlc/src/ir/rq/transform.rs
index 821c59c6ac27..80f43922a6c8 100644
--- a/prqlc/prqlc/src/ir/rq/transform.rs
+++ b/prqlc/prqlc/src/ir/rq/transform.rs
@@ -1,12 +1,11 @@
 use enum_as_inner::EnumAsInner;
 use serde::{Deserialize, Serialize};
 
+use super::*;
 use crate::ir::generic::ColumnSort;
 use crate::ir::generic::WindowFrame;
 use crate::ir::pl::JoinSide;
 
-use super::*;
-
 /// Transformation of a table.
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, strum::AsRefStr, EnumAsInner)]
 pub enum Transform {
diff --git a/prqlc/prqlc/src/lib.rs b/prqlc/prqlc/src/lib.rs
index eb72afd48108..e64218fd02ef 100644
--- a/prqlc/prqlc/src/lib.rs
+++ b/prqlc/prqlc/src/lib.rs
@@ -101,22 +101,24 @@ pub mod semantic;
 pub mod sql;
 mod utils;
 
-pub use crate::ast::error::{Error, Errors, MessageKind, Reason, WithErrorInfo};
 use anstream::adapter::strip_str;
 pub use error_message::{ErrorMessage, ErrorMessages, SourceLocation};
 pub use ir::Span;
 pub use prqlc_ast as ast;
 
+pub use crate::ast::error::{Error, Errors, MessageKind, Reason, WithErrorInfo};
+
 pub type Result<T, E = Error> = core::result::Result<T, E>;
 
 pub static COMPILER_VERSION: Lazy<Version> =
     Lazy::new(|| Version::parse(env!("CARGO_PKG_VERSION")).expect("Invalid prqlc version number"));
 
+use std::{collections::HashMap, path::PathBuf, str::FromStr};
+
 use once_cell::sync::Lazy;
 use prqlc_parser::TokenVec;
 use semver::Version;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, path::PathBuf, str::FromStr};
 use strum::VariantNames;
 
 /// Compile a PRQL string into a SQL string.
@@ -448,10 +450,12 @@ impl<S: ToString> From<S> for SourceTree {
 
 #[cfg(test)]
 mod tests {
+    use std::str::FromStr;
+
+    use insta::assert_debug_snapshot;
+
     use crate::ast::expr::Ident;
     use crate::Target;
-    use insta::assert_debug_snapshot;
-    use std::str::FromStr;
 
     pub fn compile(prql: &str) -> Result<String, super::ErrorMessages> {
         anstream::ColorChoice::Never.write_global();
diff --git a/prqlc/prqlc/src/parser.rs b/prqlc/prqlc/src/parser.rs
index 947d1940ab0d..8d89fdb1f2a6 100644
--- a/prqlc/prqlc/src/parser.rs
+++ b/prqlc/prqlc/src/parser.rs
@@ -1,7 +1,8 @@
-use itertools::Itertools;
 use std::path::PathBuf;
 use std::{collections::HashMap, path::Path};
 
+use itertools::Itertools;
+
 use crate::ast::{ModuleDef, Stmt, StmtKind};
 use crate::{Error, Errors, Result, SourceTree, WithErrorInfo};
 
diff --git a/prqlc/prqlc/src/semantic/eval.rs b/prqlc/prqlc/src/semantic/eval.rs
index 437447de72cd..16138d2f4a8c 100644
--- a/prqlc/prqlc/src/semantic/eval.rs
+++ b/prqlc/prqlc/src/semantic/eval.rs
@@ -452,9 +452,8 @@ mod test {
 
     use insta::assert_snapshot;
 
-    use crate::semantic::write_pl;
-
     use super::*;
+    use crate::semantic::write_pl;
 
     #[track_caller]
     fn eval(source: &str) -> Result<String> {
diff --git a/prqlc/prqlc/src/semantic/mod.rs b/prqlc/prqlc/src/semantic/mod.rs
index 2e4191d2159d..75279acb7c74 100644
--- a/prqlc/prqlc/src/semantic/mod.rs
+++ b/prqlc/prqlc/src/semantic/mod.rs
@@ -7,11 +7,11 @@ mod module;
 pub mod reporting;
 mod resolver;
 
-use self::resolver::Resolver;
-pub use self::resolver::ResolverOptions;
 pub use eval::eval;
 pub use lowering::lower_to_ir;
 
+use self::resolver::Resolver;
+pub use self::resolver::ResolverOptions;
 use crate::ast;
 use crate::ir::constant::ConstExpr;
 use crate::ir::decl::{Module, RootModule};
@@ -160,12 +160,11 @@ pub fn write_pl(expr: pl::Expr) -> String {
 pub mod test {
     use insta::assert_yaml_snapshot;
 
+    use super::{resolve, resolve_and_lower, RootModule};
     use crate::ir::rq::RelationalQuery;
     use crate::parser::parse;
     use crate::Errors;
 
-    use super::{resolve, resolve_and_lower, RootModule};
-
     pub fn parse_resolve_and_lower(query: &str) -> Result<RelationalQuery, Errors> {
         let source_tree = query.into();
         Ok(resolve_and_lower(parse(&source_tree)?, &[], None)?)
diff --git a/prqlc/prqlc/src/semantic/module.rs b/prqlc/prqlc/src/semantic/module.rs
index 86598e88ff87..d02311db5bbc 100644
--- a/prqlc/prqlc/src/semantic/module.rs
+++ b/prqlc/prqlc/src/semantic/module.rs
@@ -1,17 +1,15 @@
 use std::collections::{HashMap, HashSet};
 
-use crate::ast::QueryDef;
-use crate::ast::{Literal, Span, Ty, TyKind, TyTupleField};
-use crate::Result;
-
-use crate::ir::pl::{Annotation, Expr, Ident, Lineage, LineageColumn};
-use crate::Error;
-
 use super::{
     NS_DEFAULT_DB, NS_GENERIC, NS_INFER, NS_INFER_MODULE, NS_MAIN, NS_PARAM, NS_QUERY_DEF, NS_SELF,
     NS_STD, NS_THAT, NS_THIS,
 };
+use crate::ast::QueryDef;
+use crate::ast::{Literal, Span, Ty, TyKind, TyTupleField};
 use crate::ir::decl::{Decl, DeclKind, Module, RootModule, TableDecl, TableExpr};
+use crate::ir::pl::{Annotation, Expr, Ident, Lineage, LineageColumn};
+use crate::Error;
+use crate::Result;
 
 impl Module {
     pub fn singleton<S: ToString>(name: S, entry: Decl) -> Module {
diff --git a/prqlc/prqlc/src/semantic/resolver/expr.rs b/prqlc/prqlc/src/semantic/resolver/expr.rs
index f86a79c630bd..80106cc7d29e 100644
--- a/prqlc/prqlc/src/semantic/resolver/expr.rs
+++ b/prqlc/prqlc/src/semantic/resolver/expr.rs
@@ -1,4 +1,3 @@
-use crate::Result;
 use itertools::Itertools;
 
 use crate::ast::{Ty, TyKind, TyTupleField};
@@ -7,6 +6,7 @@ use crate::ir::pl::*;
 use crate::semantic::resolver::{flatten, types, Resolver};
 use crate::semantic::{NS_INFER, NS_SELF, NS_THAT, NS_THIS};
 use crate::utils::IdGenerator;
+use crate::Result;
 use crate::{Error, Reason, Span, WithErrorInfo};
 
 impl PlFold for Resolver<'_> {
diff --git a/prqlc/prqlc/src/semantic/resolver/flatten.rs b/prqlc/prqlc/src/semantic/resolver/flatten.rs
index 8e8498b7166a..c109ba9d6602 100644
--- a/prqlc/prqlc/src/semantic/resolver/flatten.rs
+++ b/prqlc/prqlc/src/semantic/resolver/flatten.rs
@@ -1,11 +1,10 @@
 use std::collections::HashMap;
 
-use crate::Result;
-
 use crate::ir::pl::{
     fold_column_sorts, fold_transform_kind, ColumnSort, Expr, ExprKind, PlFold, TransformCall,
     TransformKind, WindowFrame,
 };
+use crate::Result;
 
 /// Flattens group and window [TransformCall]s into a single pipeline.
 /// Sets partition, window and sort of [TransformCall].
diff --git a/prqlc/prqlc/src/semantic/resolver/functions.rs b/prqlc/prqlc/src/semantic/resolver/functions.rs
index 4f451593571e..1eba284f0bab 100644
--- a/prqlc/prqlc/src/semantic/resolver/functions.rs
+++ b/prqlc/prqlc/src/semantic/resolver/functions.rs
@@ -1,18 +1,17 @@
 use std::collections::HashMap;
 use std::iter::zip;
 
-use crate::Result;
 use itertools::{Itertools, Position};
 
+use super::Resolver;
 use crate::ast::{Ty, TyFunc, TyKind};
 use crate::ir::decl::{Decl, DeclKind, Module};
 use crate::ir::pl::*;
 use crate::semantic::resolver::types;
 use crate::semantic::{NS_GENERIC, NS_PARAM, NS_THAT, NS_THIS};
+use crate::Result;
 use crate::{Error, Span, WithErrorInfo};
 
-use super::Resolver;
-
 impl Resolver<'_> {
     pub fn fold_function(
         &mut self,
diff --git a/prqlc/prqlc/src/semantic/resolver/inference.rs b/prqlc/prqlc/src/semantic/resolver/inference.rs
index 9ecc652f7249..24cb8ecd0689 100644
--- a/prqlc/prqlc/src/semantic/resolver/inference.rs
+++ b/prqlc/prqlc/src/semantic/resolver/inference.rs
@@ -1,12 +1,11 @@
-use crate::Result;
 use itertools::Itertools;
 
+use super::Resolver;
 use crate::ast::{Ident, Ty, TyTupleField};
 use crate::ir::decl::{Decl, TableDecl, TableExpr};
 use crate::ir::pl::{Lineage, LineageColumn, LineageInput};
 use crate::semantic::{NS_DEFAULT_DB, NS_INFER};
-
-use super::Resolver;
+use crate::Result;
 
 impl Resolver<'_> {
     pub fn infer_table_column(
diff --git a/prqlc/prqlc/src/semantic/resolver/mod.rs b/prqlc/prqlc/src/semantic/resolver/mod.rs
index d0224186d374..b404a168554b 100644
--- a/prqlc/prqlc/src/semantic/resolver/mod.rs
+++ b/prqlc/prqlc/src/semantic/resolver/mod.rs
@@ -50,10 +50,10 @@ impl Resolver<'_> {
 
 #[cfg(test)]
 pub(super) mod test {
-    use crate::{Errors, Result};
     use insta::assert_yaml_snapshot;
 
     use crate::ir::pl::{Expr, Lineage, PlFold};
+    use crate::{Errors, Result};
 
     pub fn erase_ids(expr: Expr) -> Expr {
         IdEraser {}.fold_expr(expr).unwrap()
diff --git a/prqlc/prqlc/src/semantic/resolver/names.rs b/prqlc/prqlc/src/semantic/resolver/names.rs
index 44263016da08..18295639faf8 100644
--- a/prqlc/prqlc/src/semantic/resolver/names.rs
+++ b/prqlc/prqlc/src/semantic/resolver/names.rs
@@ -2,18 +2,15 @@ use std::collections::HashSet;
 
 use itertools::Itertools;
 
-use crate::Result;
-
+use super::Resolver;
 use crate::ast::Ident;
-
 use crate::ir::decl::{Decl, DeclKind, Module};
 use crate::ir::pl::{Expr, ExprKind};
 use crate::semantic::{NS_INFER, NS_INFER_MODULE, NS_SELF, NS_THAT, NS_THIS};
 use crate::Error;
+use crate::Result;
 use crate::WithErrorInfo;
 
-use super::Resolver;
-
 impl Resolver<'_> {
     pub(super) fn resolve_ident(&mut self, ident: &Ident) -> Result<Ident, Error> {
         let mut res = if let Some(default_namespace) = self.default_namespace.clone() {
diff --git a/prqlc/prqlc/src/semantic/resolver/stmt.rs b/prqlc/prqlc/src/semantic/resolver/stmt.rs
index dce25a766688..e71ab60f3c75 100644
--- a/prqlc/prqlc/src/semantic/resolver/stmt.rs
+++ b/prqlc/prqlc/src/semantic/resolver/stmt.rs
@@ -1,9 +1,9 @@
-use crate::Result;
 use std::collections::HashMap;
 
 use crate::ast::{Ty, TyKind, TyTupleField};
 use crate::ir::decl::{Decl, DeclKind, Module, TableDecl, TableExpr};
 use crate::ir::pl::*;
+use crate::Result;
 use crate::WithErrorInfo;
 
 impl super::Resolver<'_> {
diff --git a/prqlc/prqlc/src/semantic/resolver/transforms.rs b/prqlc/prqlc/src/semantic/resolver/transforms.rs
index 69aa8ad64b6d..5af757a60890 100644
--- a/prqlc/prqlc/src/semantic/resolver/transforms.rs
+++ b/prqlc/prqlc/src/semantic/resolver/transforms.rs
@@ -1,22 +1,20 @@
 use std::collections::HashMap;
+use std::iter::zip;
 
 use itertools::Itertools;
 use serde::Deserialize;
-use std::iter::zip;
 
+use super::types::{ty_tuple_kind, type_intersection};
+use super::Resolver;
+use crate::ast::{Ty, TyKind, TyTupleField};
 use crate::ir::decl::{Decl, DeclKind, Module};
 use crate::ir::generic::{SortDirection, WindowKind};
 use crate::ir::pl::*;
-
-use crate::ast::{Ty, TyKind, TyTupleField};
 use crate::semantic::ast_expand::{restrict_null_literal, try_restrict_range};
 use crate::semantic::resolver::functions::expr_of_func;
 use crate::semantic::{write_pl, NS_PARAM, NS_THIS};
 use crate::{Error, Reason, Result, WithErrorInfo, COMPILER_VERSION};
 
-use super::types::{ty_tuple_kind, type_intersection};
-use super::Resolver;
-
 impl Resolver<'_> {
     /// try to convert function call with enough args into transform
     #[allow(clippy::boxed_local)]
@@ -981,9 +979,8 @@ fn unpack<const P: usize>(func_args: Vec<Expr>) -> [Expr; P] {
 }
 
 mod from_text {
-    use crate::ir::rq::RelationLiteral;
-
     use super::*;
+    use crate::ir::rq::RelationLiteral;
 
     // TODO: Can we dynamically get the types, like in pandas? We need to put
     // quotes around strings and not around numbers.
diff --git a/prqlc/prqlc/src/semantic/resolver/types.rs b/prqlc/prqlc/src/semantic/resolver/types.rs
index 2ffcc0720cf8..813451b8560d 100644
--- a/prqlc/prqlc/src/semantic/resolver/types.rs
+++ b/prqlc/prqlc/src/semantic/resolver/types.rs
@@ -1,18 +1,16 @@
 use std::collections::HashMap;
 use std::iter::zip;
 
-use crate::ast::{PrimitiveSet, Ty, TyFunc, TyKind, TyTupleField};
-use crate::Result;
 use itertools::Itertools;
 
+use super::Resolver;
+use crate::ast::{PrimitiveSet, Ty, TyFunc, TyKind, TyTupleField};
 use crate::codegen::{write_ty, write_ty_kind};
 use crate::ir::decl::DeclKind;
 use crate::ir::pl::*;
-
+use crate::Result;
 use crate::{Error, Reason, WithErrorInfo};
 
-use super::Resolver;
-
 impl Resolver<'_> {
     pub fn infer_type(expr: &Expr) -> Result<Option<Ty>> {
         if let Some(ty) = &expr.ty {
diff --git a/prqlc/prqlc/src/sql/dialect.rs b/prqlc/prqlc/src/sql/dialect.rs
index b788aa3417d4..3e97be97492d 100644
--- a/prqlc/prqlc/src/sql/dialect.rs
+++ b/prqlc/prqlc/src/sql/dialect.rs
@@ -11,10 +11,11 @@
 //!
 //! As a consequence, generated SQL may be verbose, since it will avoid newer or less adopted SQL
 //! constructs. The upside is much less complex translator.
-use chrono::format::{Fixed, Item, Numeric, Pad, StrftimeItems};
 use core::fmt::Debug;
-use serde::{Deserialize, Serialize};
 use std::any::{Any, TypeId};
+
+use chrono::format::{Fixed, Item, Numeric, Pad, StrftimeItems};
+use serde::{Deserialize, Serialize};
 use strum::VariantNames;
 
 use crate::{Error, Result};
@@ -515,10 +516,12 @@ impl DialectHandler for DuckDbDialect {
 
 #[cfg(test)]
 mod tests {
-    use super::Dialect;
-    use insta::assert_debug_snapshot;
     use std::str::FromStr;
 
+    use insta::assert_debug_snapshot;
+
+    use super::Dialect;
+
     #[test]
     fn test_dialect_from_str() {
         assert_debug_snapshot!(Dialect::from_str("postgres"), @r###"
diff --git a/prqlc/prqlc/src/sql/gen_expr.rs b/prqlc/prqlc/src/sql/gen_expr.rs
index 041c4ffe12f7..ef36779272d9 100644
--- a/prqlc/prqlc/src/sql/gen_expr.rs
+++ b/prqlc/prqlc/src/sql/gen_expr.rs
@@ -1,5 +1,7 @@
 //! Contains functions that compile [crate::ast::pl] nodes into [sqlparser] nodes.
 
+use std::cmp::Ordering;
+
 use itertools::Itertools;
 use regex::Regex;
 use sqlparser::ast::{
@@ -7,8 +9,9 @@ use sqlparser::ast::{
     FunctionArgumentList, ObjectName, OrderByExpr, SelectItem, UnaryOperator, Value,
     WindowFrameBound, WindowSpec,
 };
-use std::cmp::Ordering;
 
+use super::gen_projection::try_into_exprs;
+use super::{keywords, Context};
 use crate::ast::expr::generic::{InterpolateItem, Range};
 use crate::ir::generic::{ColumnSort, SortDirection, WindowFrame, WindowKind};
 use crate::ir::pl::{self, Ident, Literal};
@@ -17,9 +20,6 @@ use crate::sql::srq::context::ColumnDecl;
 use crate::utils::{OrMap, VALID_IDENT};
 use crate::{Error, Reason, Result, Span, WithErrorInfo};
 
-use super::gen_projection::try_into_exprs;
-use super::{keywords, Context};
-
 pub(super) fn translate_expr(expr: Expr, ctx: &mut Context) -> Result<ExprOrSource> {
     Ok(match expr.kind {
         ExprKind::ColumnRef(cid) => translate_cid(cid, ctx)?,
@@ -1022,10 +1022,10 @@ impl From<sql_ast::Expr> for ExprOrSource {
 
 #[cfg(test)]
 mod test {
-    use super::*;
-
     use insta::assert_yaml_snapshot;
 
+    use super::*;
+
     #[test]
     fn test_range_of_ranges() -> Result<()> {
         fn from_ints(start: Option<i64>, end: Option<i64>) -> Range<Expr> {
diff --git a/prqlc/prqlc/src/sql/gen_projection.rs b/prqlc/prqlc/src/sql/gen_projection.rs
index b8e9f7821a09..7dd2107fe797 100644
--- a/prqlc/prqlc/src/sql/gen_projection.rs
+++ b/prqlc/prqlc/src/sql/gen_projection.rs
@@ -1,20 +1,19 @@
 use std::collections::{HashMap, HashSet};
 
-use crate::Result;
 use itertools::Itertools;
 use sqlparser::ast::{
     self as sql_ast, ExceptSelectItem, ExcludeSelectItem, ObjectName, SelectItem,
     WildcardAdditionalOptions,
 };
 
-use crate::ir::pl::Ident;
-use crate::ir::rq::{CId, RelationColumn};
-use crate::{Error, Span, WithErrorInfo};
-
 use super::dialect::ColumnExclude;
 use super::gen_expr::*;
 use super::srq::context::{AnchorContext, ColumnDecl};
 use super::Context;
+use crate::ir::pl::Ident;
+use crate::ir::rq::{CId, RelationColumn};
+use crate::Result;
+use crate::{Error, Span, WithErrorInfo};
 
 pub(super) fn try_into_exprs(
     cids: Vec<CId>,
diff --git a/prqlc/prqlc/src/sql/gen_query.rs b/prqlc/prqlc/src/sql/gen_query.rs
index c7bc9ff0c657..0828d1736b27 100644
--- a/prqlc/prqlc/src/sql/gen_query.rs
+++ b/prqlc/prqlc/src/sql/gen_query.rs
@@ -9,19 +9,17 @@ use sqlparser::ast::{
     TableFactor, TableWithJoins,
 };
 
+use super::gen_expr::*;
+use super::gen_projection::*;
+use super::operators::translate_operator;
+use super::srq::ast::{Cte, CteKind, RelationExpr, RelationExprKind, SqlRelation, SqlTransform};
+use super::{Context, Dialect};
 use crate::ast::generic::InterpolateItem;
 use crate::ir::pl::{JoinSide, Literal};
 use crate::ir::rq::{CId, Expr, ExprKind, RelationLiteral, RelationalQuery};
 use crate::utils::{BreakUp, Pluck};
 use crate::{Error, Result, WithErrorInfo};
 
-use super::gen_expr::*;
-use super::gen_projection::*;
-use super::srq::ast::{Cte, CteKind, RelationExpr, RelationExprKind, SqlRelation, SqlTransform};
-
-use super::operators::translate_operator;
-use super::{Context, Dialect};
-
 type Transform = SqlTransform<RelationExpr, ()>;
 
 pub fn translate_query(query: RelationalQuery, dialect: Option<Dialect>) -> Result<sql_ast::Query> {
diff --git a/prqlc/prqlc/src/sql/mod.rs b/prqlc/prqlc/src/sql/mod.rs
index 47173ebdd961..e7f1a3b5cd2a 100644
--- a/prqlc/prqlc/src/sql/mod.rs
+++ b/prqlc/prqlc/src/sql/mod.rs
@@ -10,13 +10,11 @@ mod srq;
 
 pub use dialect::{Dialect, SupportLevel};
 
-use crate::Result;
-
-use crate::{ir::rq::RelationalQuery, Options, COMPILER_VERSION};
-
 use self::dialect::DialectHandler;
 use self::srq::ast::Cte;
 use self::srq::context::AnchorContext;
+use crate::Result;
+use crate::{ir::rq::RelationalQuery, Options, COMPILER_VERSION};
 
 /// Translate a PRQL AST into a SQL string.
 pub fn compile(query: RelationalQuery, options: &Options) -> Result<String> {
@@ -59,12 +57,11 @@ pub fn compile(query: RelationalQuery, options: &Options) -> Result<String> {
 
 /// This module gives access to internal machinery that gives no stability guarantees.
 pub mod internal {
+    pub use super::srq::ast::SqlTransform;
     use super::*;
     use crate::ir::rq::Transform;
     use crate::Error;
 
-    pub use super::srq::ast::SqlTransform;
-
     fn init(query: RelationalQuery) -> Result<(Vec<Transform>, Context)> {
         let (ctx, relation) = AnchorContext::of(query);
         let ctx = Context::new(dialect::Dialect::Generic, ctx);
diff --git a/prqlc/prqlc/src/sql/operators.rs b/prqlc/prqlc/src/sql/operators.rs
index 6b6cab8290b1..ea02002cd0e7 100644
--- a/prqlc/prqlc/src/sql/operators.rs
+++ b/prqlc/prqlc/src/sql/operators.rs
@@ -2,16 +2,15 @@ use std::collections::HashMap;
 use std::iter::zip;
 use std::path::PathBuf;
 
-use crate::Result;
 use itertools::Itertools;
 use once_cell::sync::Lazy;
 
 use super::gen_expr::{translate_operand, ExprOrSource, SourceExpr};
 use super::{Context, Dialect};
-
 use crate::ir::{decl, pl, rq};
 use crate::semantic;
 use crate::utils::Pluck;
+use crate::Result;
 use crate::{Error, WithErrorInfo};
 
 static STD: Lazy<decl::Module> = Lazy::new(load_std_sql);
diff --git a/prqlc/prqlc/src/sql/srq/anchor.rs b/prqlc/prqlc/src/sql/srq/anchor.rs
index a2908cfacbf0..68138bfa5ac3 100644
--- a/prqlc/prqlc/src/sql/srq/anchor.rs
+++ b/prqlc/prqlc/src/sql/srq/anchor.rs
@@ -1,16 +1,16 @@
-use crate::Result;
-use itertools::Itertools;
 use std::collections::{HashMap, HashSet};
 
+use itertools::Itertools;
+
+use super::ast::{SqlTransform, SrqMapper};
+use super::context::{AnchorContext, ColumnDecl, RIId, RelationStatus, SqlTableDecl};
 use crate::ir::generic::ColumnSort;
 use crate::ir::rq::{
     self, fold_column_sorts, fold_transform, CId, Compute, Expr, RelationColumn, RqFold, TableRef,
     Transform,
 };
 use crate::sql::srq::context::RelationAdapter;
-
-use super::ast::{SqlTransform, SrqMapper};
-use super::context::{AnchorContext, ColumnDecl, RIId, RelationStatus, SqlTableDecl};
+use crate::Result;
 
 /// Extract last part of pipeline that is able to "fit" into a single SELECT statement.
 /// Remaining proceeding pipeline is declared as a table and stored in AnchorContext.
diff --git a/prqlc/prqlc/src/sql/srq/ast.rs b/prqlc/prqlc/src/sql/srq/ast.rs
index 8cfbb7034eb8..aad549d8f294 100644
--- a/prqlc/prqlc/src/sql/srq/ast.rs
+++ b/prqlc/prqlc/src/sql/srq/ast.rs
@@ -3,17 +3,16 @@
 //! This IR dictates the structure of the resulting SQL query. This includes number of CTEs,
 //! position of sub-queries and set operations.
 
-use crate::Result;
 use enum_as_inner::EnumAsInner;
 use itertools::Itertools;
 use serde::Serialize;
 
+use super::context::RIId;
 use crate::ast::generic::InterpolateItem;
 use crate::ir::generic::ColumnSort;
 use crate::ir::pl::JoinSide;
 use crate::ir::rq::{self, fold_column_sorts, RelationLiteral, RqFold};
-
-use super::context::RIId;
+use crate::Result;
 
 #[derive(Debug, Clone, Serialize)]
 pub struct SqlQuery {
diff --git a/prqlc/prqlc/src/sql/srq/context.rs b/prqlc/prqlc/src/sql/srq/context.rs
index 2f6af391ff55..095187e95b84 100644
--- a/prqlc/prqlc/src/sql/srq/context.rs
+++ b/prqlc/prqlc/src/sql/srq/context.rs
@@ -4,19 +4,17 @@
 use std::collections::HashMap;
 use std::iter::zip;
 
-use crate::{ir::pl::TableExternRef::LocalTable, Result};
 use enum_as_inner::EnumAsInner;
 use serde::Serialize;
 
+use super::ast::{SqlRelation, SqlTransform};
 use crate::ir::pl::Ident;
 use crate::ir::rq::{
     fold_table, CId, Compute, Relation, RelationColumn, RelationKind, RelationalQuery, RqFold, TId,
     TableDecl, TableRef, Transform,
 };
-
 use crate::utils::{IdGenerator, NameGenerator};
-
-use super::ast::{SqlRelation, SqlTransform};
+use crate::{ir::pl::TableExternRef::LocalTable, Result};
 
 /// The AnchorContext struct stores information about tables and columns, and
 /// is used to generate new IDs and names.
diff --git a/prqlc/prqlc/src/sql/srq/gen_query.rs b/prqlc/prqlc/src/sql/srq/gen_query.rs
index 779533841253..40d032b83019 100644
--- a/prqlc/prqlc/src/sql/srq/gen_query.rs
+++ b/prqlc/prqlc/src/sql/srq/gen_query.rs
@@ -2,22 +2,20 @@
 
 use std::str::FromStr;
 
-use crate::Result;
 use itertools::Itertools;
 
-use crate::ir::rq::{RelationKind, RelationalQuery, RqFold, Transform};
-use crate::utils::BreakUp;
-use crate::Target;
-
+use super::super::{Context, Dialect};
 use super::anchor::{self, anchor_split};
 use super::ast::{
     fold_sql_transform, Cte, CteKind, RelationExpr, RelationExprKind, SqlQuery, SqlRelation,
     SqlTransform, SrqMapper,
 };
 use super::context::{AnchorContext, RIId, RelationAdapter, RelationStatus};
-
-use super::super::{Context, Dialect};
 use super::{postprocess, preprocess};
+use crate::ir::rq::{RelationKind, RelationalQuery, RqFold, Transform};
+use crate::utils::BreakUp;
+use crate::Result;
+use crate::Target;
 
 pub(in super::super) fn compile_query(
     query: RelationalQuery,
diff --git a/prqlc/prqlc/src/sql/srq/mod.rs b/prqlc/prqlc/src/sql/srq/mod.rs
index 3d073a7575a3..1927e19529c0 100644
--- a/prqlc/prqlc/src/sql/srq/mod.rs
+++ b/prqlc/prqlc/src/sql/srq/mod.rs
@@ -19,12 +19,10 @@ pub(super) use gen_query::compile_query;
 
 #[cfg(test)]
 mod test {
-    use crate::{Errors, Result};
-
     use super::ast::SqlQuery;
     use super::*;
-
     use crate::sql::Dialect;
+    use crate::{Errors, Result};
 
     fn parse_and_resolve(source: &str) -> Result<SqlQuery, Errors> {
         let query = crate::semantic::test::parse_resolve_and_lower(source)?;
diff --git a/prqlc/prqlc/src/sql/srq/postprocess.rs b/prqlc/prqlc/src/sql/srq/postprocess.rs
index 0e5d031fd235..4fb6f954fe7b 100644
--- a/prqlc/prqlc/src/sql/srq/postprocess.rs
+++ b/prqlc/prqlc/src/sql/srq/postprocess.rs
@@ -4,16 +4,15 @@
 
 use std::collections::{HashMap, HashSet};
 
-use crate::Result;
 use itertools::Itertools;
 
+use super::anchor::CidRedirector;
+use super::ast::*;
 use crate::ir::generic::ColumnSort;
 use crate::ir::pl::Ident;
 use crate::ir::rq::{CId, RqFold, TId};
 use crate::sql::Context;
-
-use super::anchor::CidRedirector;
-use super::ast::*;
+use crate::Result;
 
 type Sorting = Vec<ColumnSort<CId>>;
 
diff --git a/prqlc/prqlc/src/sql/srq/preprocess.rs b/prqlc/prqlc/src/sql/srq/preprocess.rs
index d9e516c4b471..e47218a3ea13 100644
--- a/prqlc/prqlc/src/sql/srq/preprocess.rs
+++ b/prqlc/prqlc/src/sql/srq/preprocess.rs
@@ -1,8 +1,12 @@
-use itertools::Itertools;
 use std::cmp::Ordering;
 use std::collections::hash_map::RandomState;
 use std::collections::HashSet;
 
+use itertools::Itertools;
+
+use super::anchor::{infer_complexity, CidCollector, Complexity};
+use super::ast::*;
+use super::context::RIId;
 use crate::ast::generic::{InterpolateItem, Range};
 use crate::ir::generic::{ColumnSort, SortDirection, WindowFrame, WindowKind};
 use crate::ir::pl::{JoinSide, Literal};
@@ -13,10 +17,6 @@ use crate::sql::srq::context::ColumnDecl;
 use crate::sql::Context;
 use crate::{Error, Result, WithErrorInfo};
 
-use super::anchor::{infer_complexity, CidCollector, Complexity};
-use super::ast::*;
-use super::context::RIId;
-
 /// Converts RQ AST into SqlRQ AST and applies a few preprocessing operations.
 ///
 /// Note that some SQL translation mechanisms depend on behavior of some of these
diff --git a/prqlc/prqlc/src/utils/mod.rs b/prqlc/prqlc/src/utils/mod.rs
index ccc8034c3b8a..7e594a680d80 100644
--- a/prqlc/prqlc/src/utils/mod.rs
+++ b/prqlc/prqlc/src/utils/mod.rs
@@ -2,12 +2,12 @@ mod id_gen;
 mod toposort;
 
 pub use id_gen::{IdGenerator, NameGenerator};
+use itertools::Itertools;
 use once_cell::sync::Lazy;
 use regex::Regex;
 pub use toposort::toposort;
 
 use crate::Result;
-use itertools::Itertools;
 
 pub trait OrMap<T> {
     /// Merges two options into one using `f`.
diff --git a/prqlc/prqlc/tests/integration/bad_error_messages.rs b/prqlc/prqlc/tests/integration/bad_error_messages.rs
index 38eb2101e5a2..7f7d93d1e181 100644
--- a/prqlc/prqlc/tests/integration/bad_error_messages.rs
+++ b/prqlc/prqlc/tests/integration/bad_error_messages.rs
@@ -15,9 +15,10 @@
 //! be a huge number of issues, and it would be difficult to see what's current.
 //! So instead, add the error message as a test here.
 
-use super::sql::compile;
 use insta::assert_snapshot;
 
+use super::sql::compile;
+
 #[test]
 fn test_bad_error_messages() {
     assert_snapshot!(compile(r###"
diff --git a/prqlc/prqlc/tests/integration/cli.rs b/prqlc/prqlc/tests/integration/cli.rs
index dba97882a764..ff6c5c2ad2b0 100644
--- a/prqlc/prqlc/tests/integration/cli.rs
+++ b/prqlc/prqlc/tests/integration/cli.rs
@@ -1,11 +1,12 @@
 #![cfg(all(not(target_family = "wasm"), feature = "cli"))]
 
-use insta_cmd::assert_cmd_snapshot;
-use insta_cmd::get_cargo_bin;
 use std::env::current_dir;
 use std::path::PathBuf;
 use std::process::Command;
 
+use insta_cmd::assert_cmd_snapshot;
+use insta_cmd::get_cargo_bin;
+
 #[cfg(not(windows))] // Windows has slightly different output (e.g. `prqlc.exe`), so we exclude.
 #[test]
 fn help() {
diff --git a/prqlc/prqlc/tests/integration/dbs/mod.rs b/prqlc/prqlc/tests/integration/dbs/mod.rs
index 1206a9f1010a..e712b3e4780f 100644
--- a/prqlc/prqlc/tests/integration/dbs/mod.rs
+++ b/prqlc/prqlc/tests/integration/dbs/mod.rs
@@ -9,10 +9,9 @@ use prqlc::{sql::Dialect, sql::SupportLevel, Options, Target};
 use regex::Regex;
 use serde::{Deserialize, Serialize};
 
+pub use self::protocol::DbProtocol;
 use self::protocol::DbProtocolHandler;
 use self::runner::DbTestRunner;
-
-pub use self::protocol::DbProtocol;
 pub type Row = Vec<String>;
 
 pub struct DbConnection {
diff --git a/prqlc/prqlc/tests/integration/dbs/runner.rs b/prqlc/prqlc/tests/integration/dbs/runner.rs
index 20ffde2ae833..186590e345fe 100644
--- a/prqlc/prqlc/tests/integration/dbs/runner.rs
+++ b/prqlc/prqlc/tests/integration/dbs/runner.rs
@@ -1,6 +1,7 @@
+use std::fs;
+
 use itertools::Itertools;
 use regex::Regex;
-use std::fs;
 
 use super::protocol::DbProtocolHandler;
 
diff --git a/prqlc/prqlc/tests/integration/error_messages.rs b/prqlc/prqlc/tests/integration/error_messages.rs
index 259529018d53..b0dc4a5fbf3b 100644
--- a/prqlc/prqlc/tests/integration/error_messages.rs
+++ b/prqlc/prqlc/tests/integration/error_messages.rs
@@ -2,9 +2,10 @@
 //! It's also fine to put errors by the things that they're testing.
 //! See also [test_bad_error_messages.rs](test_bad_error_messages.rs) for error
 //! messages which need to be improved.
-use super::sql::compile;
 use insta::assert_snapshot;
 
+use super::sql::compile;
+
 #[test]
 fn test_errors() {
     assert_snapshot!(compile(r###"
diff --git a/prqlc/prqlc/tests/integration/queries.rs b/prqlc/prqlc/tests/integration/queries.rs
index e5054db0912e..aa88f276744d 100644
--- a/prqlc/prqlc/tests/integration/queries.rs
+++ b/prqlc/prqlc/tests/integration/queries.rs
@@ -4,7 +4,6 @@ use std::{env, fs};
 
 use insta::assert_debug_snapshot;
 use insta::{assert_snapshot, with_settings};
-
 use prqlc::sql::Dialect;
 use prqlc::{Options, Target};
 use test_each_file::test_each_path;
@@ -71,13 +70,12 @@ mod fmt {
 
 #[cfg(any(feature = "test-dbs", feature = "test-dbs-external"))]
 mod results {
-    use super::*;
-
     use std::{ops::DerefMut, sync::Mutex};
 
     use once_cell::sync::Lazy;
     use prqlc::sql::SupportLevel;
 
+    use super::*;
     use crate::dbs::{ConnectionCfg, DbConnection, DbProtocol};
 
     static CONNECTIONS: Lazy<Mutex<Vec<DbConnection>>> = Lazy::new(init_connections);
diff --git a/web/book/src/lib.rs b/web/book/src/lib.rs
index 02fef4f0d4e6..d3152f3adb96 100644
--- a/web/book/src/lib.rs
+++ b/web/book/src/lib.rs
@@ -1,5 +1,7 @@
 #![cfg(not(target_family = "wasm"))]
 
+use std::str::FromStr;
+
 use anyhow::{bail, Result};
 use itertools::Itertools;
 use mdbook::preprocess::Preprocessor;
@@ -8,9 +10,6 @@ use mdbook::{book::Book, BookItem};
 use prqlc::compile;
 use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag};
 use pulldown_cmark_to_cmark::cmark_with_options;
-
-use std::str::FromStr;
-
 use strum::EnumString;
 
 pub struct ComparisonPreprocessor;
diff --git a/web/book/tests/documentation/book.rs b/web/book/tests/documentation/book.rs
index 662bca5ed32d..97b1c79b946d 100644
--- a/web/book/tests/documentation/book.rs
+++ b/web/book/tests/documentation/book.rs
@@ -1,4 +1,7 @@
 #![cfg(not(target_family = "wasm"))]
+use std::fs;
+use std::path::Path;
+
 use anyhow::{anyhow, bail, Result};
 use globset::Glob;
 use insta::assert_snapshot;
@@ -6,8 +9,6 @@ use itertools::Itertools;
 use mdbook_prql::{code_block_lang_tags, LangTag};
 use prqlc::{pl_to_prql, pl_to_rq, prql_to_pl};
 use pulldown_cmark::Tag;
-use std::fs;
-use std::path::Path;
 use walkdir::WalkDir;
 
 use super::compile;
diff --git a/web/book/tests/documentation/website.rs b/web/book/tests/documentation/website.rs
index 8f9753d880d0..1befaeaac6cb 100644
--- a/web/book/tests/documentation/website.rs
+++ b/web/book/tests/documentation/website.rs
@@ -1,8 +1,8 @@
-use similar_asserts::assert_eq;
 use std::fs::read_dir;
 
 use regex::Regex;
 use serde_yaml::Value;
+use similar_asserts::assert_eq;
 
 use super::compile;