diff --git a/quaint/src/connector/mssql/native/mod.rs b/quaint/src/connector/mssql/native/mod.rs
index d7052d5e5180..d22aa7a15dd6 100644
--- a/quaint/src/connector/mssql/native/mod.rs
+++ b/quaint/src/connector/mssql/native/mod.rs
@@ -237,20 +237,3 @@ impl Queryable for Mssql {
         true
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::tests::test_api::mssql::CONN_STR;
-    use crate::{error::*, single::Quaint};
-
-    #[tokio::test]
-    async fn should_map_wrong_credentials_error() {
-        let url = CONN_STR.replace("user=SA", "user=WRONG");
-
-        let res = Quaint::new(url.as_str()).await;
-        assert!(res.is_err());
-
-        let err = res.unwrap_err();
-        assert!(matches!(err.kind(), ErrorKind::AuthenticationFailed { user } if user == &Name::available("WRONG")));
-    }
-}
diff --git a/quaint/src/connector/mysql/native/mod.rs b/quaint/src/connector/mysql/native/mod.rs
index 7a95ee47b614..fdcc3a6276d1 100644
--- a/quaint/src/connector/mysql/native/mod.rs
+++ b/quaint/src/connector/mysql/native/mod.rs
@@ -295,86 +295,3 @@ impl Queryable for Mysql {
         true
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::MysqlUrl;
-    use crate::tests::test_api::mysql::CONN_STR;
-    use crate::{error::*, single::Quaint};
-    use url::Url;
-
-    #[test]
-    fn should_parse_socket_url() {
-        let url = MysqlUrl::new(Url::parse("mysql://root@localhost/dbname?socket=(/tmp/mysql.sock)").unwrap()).unwrap();
-        assert_eq!("dbname", url.dbname());
-        assert_eq!(&Some(String::from("/tmp/mysql.sock")), url.socket());
-    }
-
-    #[test]
-    fn should_parse_prefer_socket() {
-        let url =
-            MysqlUrl::new(Url::parse("mysql://root:root@localhost:3307/testdb?prefer_socket=false").unwrap()).unwrap();
-        assert!(!url.prefer_socket().unwrap());
-    }
-
-    #[test]
-    fn should_parse_sslaccept() {
-        let url =
-            MysqlUrl::new(Url::parse("mysql://root:root@localhost:3307/testdb?sslaccept=strict").unwrap()).unwrap();
-        assert!(url.query_params.use_ssl);
-        assert!(!url.query_params.ssl_opts.skip_domain_validation());
-        assert!(!url.query_params.ssl_opts.accept_invalid_certs());
-    }
-
-    #[test]
-    fn should_parse_ipv6_host() {
-        let url = MysqlUrl::new(Url::parse("mysql://[2001:db8:1234::ffff]:5432/testdb").unwrap()).unwrap();
-        assert_eq!("2001:db8:1234::ffff", url.host());
-    }
-
-    #[test]
-    fn should_allow_changing_of_cache_size() {
-        let url = MysqlUrl::new(Url::parse("mysql:///root:root@localhost:3307/foo?statement_cache_size=420").unwrap())
-            .unwrap();
-        assert_eq!(420, url.cache().capacity());
-    }
-
-    #[test]
-    fn should_have_default_cache_size() {
-        let url = MysqlUrl::new(Url::parse("mysql:///root:root@localhost:3307/foo").unwrap()).unwrap();
-        assert_eq!(100, url.cache().capacity());
-    }
-
-    #[tokio::test]
-    async fn should_map_nonexisting_database_error() {
-        let mut url = Url::parse(&CONN_STR).unwrap();
-        url.set_username("root").unwrap();
-        url.set_path("/this_does_not_exist");
-
-        let url = url.as_str().to_string();
-        let res = Quaint::new(&url).await;
-
-        let err = res.unwrap_err();
-
-        match err.kind() {
-            ErrorKind::DatabaseDoesNotExist { db_name } => {
-                assert_eq!(Some("1049"), err.original_code());
-                assert_eq!(Some("Unknown database \'this_does_not_exist\'"), err.original_message());
-                assert_eq!(&Name::available("this_does_not_exist"), db_name)
-            }
-            e => panic!("Expected `DatabaseDoesNotExist`, got {:?}", e),
-        }
-    }
-
-    #[tokio::test]
-    async fn should_map_wrong_credentials_error() {
-        let mut url = Url::parse(&CONN_STR).unwrap();
-        url.set_username("WRONG").unwrap();
-
-        let res = Quaint::new(url.as_str()).await;
-        assert!(res.is_err());
-
-        let err = res.unwrap_err();
-        assert!(matches!(err.kind(), ErrorKind::AuthenticationFailed { user } if user == &Name::available("WRONG")));
-    }
-}
diff --git a/quaint/src/connector/mysql/url.rs b/quaint/src/connector/mysql/url.rs
index c17b2224c0ef..f0756fa95833 100644
--- a/quaint/src/connector/mysql/url.rs
+++ b/quaint/src/connector/mysql/url.rs
@@ -316,3 +316,86 @@ pub(crate) struct MysqlUrlQueryParams {
     #[cfg(feature = "mysql-native")]
     pub(crate) ssl_opts: mysql_async::SslOpts,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::MysqlUrl;
+    use crate::tests::test_api::mysql::CONN_STR;
+    use crate::{error::*, single::Quaint};
+    use url::Url;
+
+    #[test]
+    fn should_parse_socket_url() {
+        let url = MysqlUrl::new(Url::parse("mysql://root@localhost/dbname?socket=(/tmp/mysql.sock)").unwrap()).unwrap();
+        assert_eq!("dbname", url.dbname());
+        assert_eq!(&Some(String::from("/tmp/mysql.sock")), url.socket());
+    }
+
+    #[test]
+    fn should_parse_prefer_socket() {
+        let url =
+            MysqlUrl::new(Url::parse("mysql://root:root@localhost:3307/testdb?prefer_socket=false").unwrap()).unwrap();
+        assert!(!url.prefer_socket().unwrap());
+    }
+
+    #[test]
+    fn should_parse_sslaccept() {
+        let url =
+            MysqlUrl::new(Url::parse("mysql://root:root@localhost:3307/testdb?sslaccept=strict").unwrap()).unwrap();
+        assert!(url.query_params.use_ssl);
+        assert!(!url.query_params.ssl_opts.skip_domain_validation());
+        assert!(!url.query_params.ssl_opts.accept_invalid_certs());
+    }
+
+    #[test]
+    fn should_parse_ipv6_host() {
+        let url = MysqlUrl::new(Url::parse("mysql://[2001:db8:1234::ffff]:5432/testdb").unwrap()).unwrap();
+        assert_eq!("2001:db8:1234::ffff", url.host());
+    }
+
+    #[test]
+    fn should_allow_changing_of_cache_size() {
+        let url = MysqlUrl::new(Url::parse("mysql:///root:root@localhost:3307/foo?statement_cache_size=420").unwrap())
+            .unwrap();
+        assert_eq!(420, url.cache().capacity());
+    }
+
+    #[test]
+    fn should_have_default_cache_size() {
+        let url = MysqlUrl::new(Url::parse("mysql:///root:root@localhost:3307/foo").unwrap()).unwrap();
+        assert_eq!(100, url.cache().capacity());
+    }
+
+    #[tokio::test]
+    async fn should_map_nonexisting_database_error() {
+        let mut url = Url::parse(&CONN_STR).unwrap();
+        url.set_username("root").unwrap();
+        url.set_path("/this_does_not_exist");
+
+        let url = url.as_str().to_string();
+        let res = Quaint::new(&url).await;
+
+        let err = res.unwrap_err();
+
+        match err.kind() {
+            ErrorKind::DatabaseDoesNotExist { db_name } => {
+                assert_eq!(Some("1049"), err.original_code());
+                assert_eq!(Some("Unknown database \'this_does_not_exist\'"), err.original_message());
+                assert_eq!(&Name::available("this_does_not_exist"), db_name)
+            }
+            e => panic!("Expected `DatabaseDoesNotExist`, got {:?}", e),
+        }
+    }
+
+    #[tokio::test]
+    async fn should_map_wrong_credentials_error() {
+        let mut url = Url::parse(&CONN_STR).unwrap();
+        url.set_username("WRONG").unwrap();
+
+        let res = Quaint::new(url.as_str()).await;
+        assert!(res.is_err());
+
+        let err = res.unwrap_err();
+        assert!(matches!(err.kind(), ErrorKind::AuthenticationFailed { user } if user == &Name::available("WRONG")));
+    }
+}
diff --git a/quaint/src/connector/postgres/native/mod.rs b/quaint/src/connector/postgres/native/mod.rs
index 5dbf67a91cdf..30f34e7002be 100644
--- a/quaint/src/connector/postgres/native/mod.rs
+++ b/quaint/src/connector/postgres/native/mod.rs
@@ -671,89 +671,11 @@ fn is_safe_identifier(ident: &str) -> bool {
 mod tests {
     use super::*;
     pub(crate) use crate::connector::postgres::url::PostgresFlavour;
+    use crate::connector::Queryable;
     use crate::tests::test_api::postgres::CONN_STR;
     use crate::tests::test_api::CRDB_CONN_STR;
-    use crate::{connector::Queryable, error::*, single::Quaint};
     use url::Url;
 
-    #[test]
-    fn should_parse_socket_url() {
-        let url = PostgresUrl::new(Url::parse("postgresql:///dbname?host=/var/run/psql.sock").unwrap()).unwrap();
-        assert_eq!("dbname", url.dbname());
-        assert_eq!("/var/run/psql.sock", url.host());
-    }
-
-    #[test]
-    fn should_parse_escaped_url() {
-        let url = PostgresUrl::new(Url::parse("postgresql:///dbname?host=%2Fvar%2Frun%2Fpostgresql").unwrap()).unwrap();
-        assert_eq!("dbname", url.dbname());
-        assert_eq!("/var/run/postgresql", url.host());
-    }
-
-    #[test]
-    fn should_allow_changing_of_cache_size() {
-        let url =
-            PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?statement_cache_size=420").unwrap()).unwrap();
-        assert_eq!(420, url.cache().capacity());
-    }
-
-    #[test]
-    fn should_have_default_cache_size() {
-        let url = PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo").unwrap()).unwrap();
-        assert_eq!(100, url.cache().capacity());
-    }
-
-    #[test]
-    fn should_have_application_name() {
-        let url =
-            PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?application_name=test").unwrap()).unwrap();
-        assert_eq!(Some("test"), url.application_name());
-    }
-
-    #[test]
-    fn should_have_channel_binding() {
-        let url =
-            PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?channel_binding=require").unwrap()).unwrap();
-        assert_eq!(ChannelBinding::Require, url.channel_binding());
-    }
-
-    #[test]
-    fn should_have_default_channel_binding() {
-        let url =
-            PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?channel_binding=invalid").unwrap()).unwrap();
-        assert_eq!(ChannelBinding::Prefer, url.channel_binding());
-
-        let url = PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo").unwrap()).unwrap();
-        assert_eq!(ChannelBinding::Prefer, url.channel_binding());
-    }
-
-    #[test]
-    fn should_not_enable_caching_with_pgbouncer() {
-        let url = PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?pgbouncer=true").unwrap()).unwrap();
-        assert_eq!(0, url.cache().capacity());
-    }
-
-    #[test]
-    fn should_parse_default_host() {
-        let url = PostgresUrl::new(Url::parse("postgresql:///dbname").unwrap()).unwrap();
-        assert_eq!("dbname", url.dbname());
-        assert_eq!("localhost", url.host());
-    }
-
-    #[test]
-    fn should_parse_ipv6_host() {
-        let url = PostgresUrl::new(Url::parse("postgresql://[2001:db8:1234::ffff]:5432/dbname").unwrap()).unwrap();
-        assert_eq!("2001:db8:1234::ffff", url.host());
-    }
-
-    #[test]
-    fn should_handle_options_field() {
-        let url = PostgresUrl::new(Url::parse("postgresql:///localhost:5432?options=--cluster%3Dmy_cluster").unwrap())
-            .unwrap();
-
-        assert_eq!("--cluster=my_cluster", url.options().unwrap());
-    }
-
     #[tokio::test]
     async fn test_custom_search_path_pg() {
         async fn test_path(schema_name: &str) -> Option<String> {
@@ -1010,82 +932,6 @@ mod tests {
         }
     }
 
-    #[tokio::test]
-    async fn should_map_nonexisting_database_error() {
-        let mut url = Url::parse(&CONN_STR).unwrap();
-        url.set_path("/this_does_not_exist");
-
-        let res = Quaint::new(url.as_str()).await;
-
-        assert!(res.is_err());
-
-        match res {
-            Ok(_) => unreachable!(),
-            Err(e) => match e.kind() {
-                ErrorKind::DatabaseDoesNotExist { db_name } => {
-                    assert_eq!(Some("3D000"), e.original_code());
-                    assert_eq!(
-                        Some("database \"this_does_not_exist\" does not exist"),
-                        e.original_message()
-                    );
-                    assert_eq!(&Name::available("this_does_not_exist"), db_name)
-                }
-                kind => panic!("Expected `DatabaseDoesNotExist`, got {:?}", kind),
-            },
-        }
-    }
-
-    #[tokio::test]
-    async fn should_map_wrong_credentials_error() {
-        let mut url = Url::parse(&CONN_STR).unwrap();
-        url.set_username("WRONG").unwrap();
-
-        let res = Quaint::new(url.as_str()).await;
-        assert!(res.is_err());
-
-        let err = res.unwrap_err();
-        assert!(matches!(err.kind(), ErrorKind::AuthenticationFailed { user } if user == &Name::available("WRONG")));
-    }
-
-    #[tokio::test]
-    async fn should_map_tls_errors() {
-        let mut url = Url::parse(&CONN_STR).expect("parsing url");
-        url.set_query(Some("sslmode=require&sslaccept=strict"));
-
-        let res = Quaint::new(url.as_str()).await;
-
-        assert!(res.is_err());
-
-        match res {
-            Ok(_) => unreachable!(),
-            Err(e) => match e.kind() {
-                ErrorKind::TlsError { .. } => (),
-                other => panic!("{:#?}", other),
-            },
-        }
-    }
-
-    #[tokio::test]
-    async fn should_map_incorrect_parameters_error() {
-        let url = Url::parse(&CONN_STR).unwrap();
-        let conn = Quaint::new(url.as_str()).await.unwrap();
-
-        let res = conn.query_raw("SELECT $1", &[Value::int32(1), Value::int32(2)]).await;
-
-        assert!(res.is_err());
-
-        match res {
-            Ok(_) => unreachable!(),
-            Err(e) => match e.kind() {
-                ErrorKind::IncorrectNumberOfParameters { expected, actual } => {
-                    assert_eq!(1, *expected);
-                    assert_eq!(2, *actual);
-                }
-                other => panic!("{:#?}", other),
-            },
-        }
-    }
-
     #[test]
     fn test_safe_ident() {
         // Safe
@@ -1123,63 +969,4 @@ mod tests {
             assert!(!is_safe_identifier(ident));
         }
     }
-
-    #[test]
-    fn search_path_pgbouncer_should_be_set_with_query() {
-        let mut url = Url::parse(&CONN_STR).unwrap();
-        url.query_pairs_mut().append_pair("schema", "hello");
-        url.query_pairs_mut().append_pair("pgbouncer", "true");
-
-        let mut pg_url = PostgresUrl::new(url).unwrap();
-        pg_url.set_flavour(PostgresFlavour::Postgres);
-
-        let config = pg_url.to_config();
-
-        // PGBouncer does not support the `search_path` connection parameter.
-        // When `pgbouncer=true`, config.search_path should be None,
-        // And the `search_path` should be set via a db query after connection.
-        assert_eq!(config.get_search_path(), None);
-    }
-
-    #[test]
-    fn search_path_pg_should_be_set_with_param() {
-        let mut url = Url::parse(&CONN_STR).unwrap();
-        url.query_pairs_mut().append_pair("schema", "hello");
-
-        let mut pg_url = PostgresUrl::new(url).unwrap();
-        pg_url.set_flavour(PostgresFlavour::Postgres);
-
-        let config = pg_url.to_config();
-
-        // Postgres supports setting the search_path via a connection parameter.
-        assert_eq!(config.get_search_path(), Some(&"\"hello\"".to_owned()));
-    }
-
-    #[test]
-    fn search_path_crdb_safe_ident_should_be_set_with_param() {
-        let mut url = Url::parse(&CONN_STR).unwrap();
-        url.query_pairs_mut().append_pair("schema", "hello");
-
-        let mut pg_url = PostgresUrl::new(url).unwrap();
-        pg_url.set_flavour(PostgresFlavour::Cockroach);
-
-        let config = pg_url.to_config();
-
-        // CRDB supports setting the search_path via a connection parameter if the identifier is safe.
-        assert_eq!(config.get_search_path(), Some(&"hello".to_owned()));
-    }
-
-    #[test]
-    fn search_path_crdb_unsafe_ident_should_be_set_with_query() {
-        let mut url = Url::parse(&CONN_STR).unwrap();
-        url.query_pairs_mut().append_pair("schema", "HeLLo");
-
-        let mut pg_url = PostgresUrl::new(url).unwrap();
-        pg_url.set_flavour(PostgresFlavour::Cockroach);
-
-        let config = pg_url.to_config();
-
-        // CRDB does NOT support setting the search_path via a connection parameter if the identifier is unsafe.
-        assert_eq!(config.get_search_path(), None);
-    }
 }
diff --git a/quaint/src/connector/postgres/url.rs b/quaint/src/connector/postgres/url.rs
index 7b9b3aafabb4..f0b60d88a848 100644
--- a/quaint/src/connector/postgres/url.rs
+++ b/quaint/src/connector/postgres/url.rs
@@ -470,3 +470,226 @@ impl Display for SetSearchPath<'_> {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ast::Value;
+    pub(crate) use crate::connector::postgres::url::PostgresFlavour;
+    use crate::tests::test_api::postgres::CONN_STR;
+    use crate::{connector::Queryable, error::*, single::Quaint};
+    use url::Url;
+
+    #[test]
+    fn should_parse_socket_url() {
+        let url = PostgresUrl::new(Url::parse("postgresql:///dbname?host=/var/run/psql.sock").unwrap()).unwrap();
+        assert_eq!("dbname", url.dbname());
+        assert_eq!("/var/run/psql.sock", url.host());
+    }
+
+    #[test]
+    fn should_parse_escaped_url() {
+        let url = PostgresUrl::new(Url::parse("postgresql:///dbname?host=%2Fvar%2Frun%2Fpostgresql").unwrap()).unwrap();
+        assert_eq!("dbname", url.dbname());
+        assert_eq!("/var/run/postgresql", url.host());
+    }
+
+    #[test]
+    fn should_allow_changing_of_cache_size() {
+        let url =
+            PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?statement_cache_size=420").unwrap()).unwrap();
+        assert_eq!(420, url.cache().capacity());
+    }
+
+    #[test]
+    fn should_have_default_cache_size() {
+        let url = PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo").unwrap()).unwrap();
+        assert_eq!(100, url.cache().capacity());
+    }
+
+    #[test]
+    fn should_have_application_name() {
+        let url =
+            PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?application_name=test").unwrap()).unwrap();
+        assert_eq!(Some("test"), url.application_name());
+    }
+
+    #[test]
+    fn should_have_channel_binding() {
+        let url =
+            PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?channel_binding=require").unwrap()).unwrap();
+        assert_eq!(ChannelBinding::Require, url.channel_binding());
+    }
+
+    #[test]
+    fn should_have_default_channel_binding() {
+        let url =
+            PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?channel_binding=invalid").unwrap()).unwrap();
+        assert_eq!(ChannelBinding::Prefer, url.channel_binding());
+
+        let url = PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo").unwrap()).unwrap();
+        assert_eq!(ChannelBinding::Prefer, url.channel_binding());
+    }
+
+    #[test]
+    fn should_not_enable_caching_with_pgbouncer() {
+        let url = PostgresUrl::new(Url::parse("postgresql:///localhost:5432/foo?pgbouncer=true").unwrap()).unwrap();
+        assert_eq!(0, url.cache().capacity());
+    }
+
+    #[test]
+    fn should_parse_default_host() {
+        let url = PostgresUrl::new(Url::parse("postgresql:///dbname").unwrap()).unwrap();
+        assert_eq!("dbname", url.dbname());
+        assert_eq!("localhost", url.host());
+    }
+
+    #[test]
+    fn should_parse_ipv6_host() {
+        let url = PostgresUrl::new(Url::parse("postgresql://[2001:db8:1234::ffff]:5432/dbname").unwrap()).unwrap();
+        assert_eq!("2001:db8:1234::ffff", url.host());
+    }
+
+    #[test]
+    fn should_handle_options_field() {
+        let url = PostgresUrl::new(Url::parse("postgresql:///localhost:5432?options=--cluster%3Dmy_cluster").unwrap())
+            .unwrap();
+
+        assert_eq!("--cluster=my_cluster", url.options().unwrap());
+    }
+
+    #[tokio::test]
+    async fn should_map_nonexisting_database_error() {
+        let mut url = Url::parse(&CONN_STR).unwrap();
+        url.set_path("/this_does_not_exist");
+
+        let res = Quaint::new(url.as_str()).await;
+
+        assert!(res.is_err());
+
+        match res {
+            Ok(_) => unreachable!(),
+            Err(e) => match e.kind() {
+                ErrorKind::DatabaseDoesNotExist { db_name } => {
+                    assert_eq!(Some("3D000"), e.original_code());
+                    assert_eq!(
+                        Some("database \"this_does_not_exist\" does not exist"),
+                        e.original_message()
+                    );
+                    assert_eq!(&Name::available("this_does_not_exist"), db_name)
+                }
+                kind => panic!("Expected `DatabaseDoesNotExist`, got {:?}", kind),
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn should_map_wrong_credentials_error() {
+        let mut url = Url::parse(&CONN_STR).unwrap();
+        url.set_username("WRONG").unwrap();
+
+        let res = Quaint::new(url.as_str()).await;
+        assert!(res.is_err());
+
+        let err = res.unwrap_err();
+        assert!(matches!(err.kind(), ErrorKind::AuthenticationFailed { user } if user == &Name::available("WRONG")));
+    }
+
+    #[tokio::test]
+    async fn should_map_tls_errors() {
+        let mut url = Url::parse(&CONN_STR).expect("parsing url");
+        url.set_query(Some("sslmode=require&sslaccept=strict"));
+
+        let res = Quaint::new(url.as_str()).await;
+
+        assert!(res.is_err());
+
+        match res {
+            Ok(_) => unreachable!(),
+            Err(e) => match e.kind() {
+                ErrorKind::TlsError { .. } => (),
+                other => panic!("{:#?}", other),
+            },
+        }
+    }
+
+    #[tokio::test]
+    async fn should_map_incorrect_parameters_error() {
+        let url = Url::parse(&CONN_STR).unwrap();
+        let conn = Quaint::new(url.as_str()).await.unwrap();
+
+        let res = conn.query_raw("SELECT $1", &[Value::int32(1), Value::int32(2)]).await;
+
+        assert!(res.is_err());
+
+        match res {
+            Ok(_) => unreachable!(),
+            Err(e) => match e.kind() {
+                ErrorKind::IncorrectNumberOfParameters { expected, actual } => {
+                    assert_eq!(1, *expected);
+                    assert_eq!(2, *actual);
+                }
+                other => panic!("{:#?}", other),
+            },
+        }
+    }
+
+    #[test]
+    fn search_path_pgbouncer_should_be_set_with_query() {
+        let mut url = Url::parse(&CONN_STR).unwrap();
+        url.query_pairs_mut().append_pair("schema", "hello");
+        url.query_pairs_mut().append_pair("pgbouncer", "true");
+
+        let mut pg_url = PostgresUrl::new(url).unwrap();
+        pg_url.set_flavour(PostgresFlavour::Postgres);
+
+        let config = pg_url.to_config();
+
+        // PGBouncer does not support the `search_path` connection parameter.
+        // When `pgbouncer=true`, config.search_path should be None,
+        // And the `search_path` should be set via a db query after connection.
+        assert_eq!(config.get_search_path(), None);
+    }
+
+    #[test]
+    fn search_path_pg_should_be_set_with_param() {
+        let mut url = Url::parse(&CONN_STR).unwrap();
+        url.query_pairs_mut().append_pair("schema", "hello");
+
+        let mut pg_url = PostgresUrl::new(url).unwrap();
+        pg_url.set_flavour(PostgresFlavour::Postgres);
+
+        let config = pg_url.to_config();
+
+        // Postgres supports setting the search_path via a connection parameter.
+        assert_eq!(config.get_search_path(), Some(&"\"hello\"".to_owned()));
+    }
+
+    #[test]
+    fn search_path_crdb_safe_ident_should_be_set_with_param() {
+        let mut url = Url::parse(&CONN_STR).unwrap();
+        url.query_pairs_mut().append_pair("schema", "hello");
+
+        let mut pg_url = PostgresUrl::new(url).unwrap();
+        pg_url.set_flavour(PostgresFlavour::Cockroach);
+
+        let config = pg_url.to_config();
+
+        // CRDB supports setting the search_path via a connection parameter if the identifier is safe.
+        assert_eq!(config.get_search_path(), Some(&"hello".to_owned()));
+    }
+
+    #[test]
+    fn search_path_crdb_unsafe_ident_should_be_set_with_query() {
+        let mut url = Url::parse(&CONN_STR).unwrap();
+        url.query_pairs_mut().append_pair("schema", "HeLLo");
+
+        let mut pg_url = PostgresUrl::new(url).unwrap();
+        pg_url.set_flavour(PostgresFlavour::Cockroach);
+
+        let config = pg_url.to_config();
+
+        // CRDB does NOT support setting the search_path via a connection parameter if the identifier is unsafe.
+        assert_eq!(config.get_search_path(), None);
+    }
+}
diff --git a/quaint/src/connector/sqlite/native/mod.rs b/quaint/src/connector/sqlite/native/mod.rs
index 4b686f5968d6..3bf0c46a7db5 100644
--- a/quaint/src/connector/sqlite/native/mod.rs
+++ b/quaint/src/connector/sqlite/native/mod.rs
@@ -165,27 +165,6 @@ mod tests {
         error::{ErrorKind, Name},
     };
 
-    #[test]
-    fn sqlite_params_from_str_should_resolve_path_correctly_with_file_scheme() {
-        let path = "file:dev.db";
-        let params = SqliteParams::try_from(path).unwrap();
-        assert_eq!(params.file_path, "dev.db");
-    }
-
-    #[test]
-    fn sqlite_params_from_str_should_resolve_path_correctly_with_sqlite_scheme() {
-        let path = "sqlite:dev.db";
-        let params = SqliteParams::try_from(path).unwrap();
-        assert_eq!(params.file_path, "dev.db");
-    }
-
-    #[test]
-    fn sqlite_params_from_str_should_resolve_path_correctly_with_no_scheme() {
-        let path = "dev.db";
-        let params = SqliteParams::try_from(path).unwrap();
-        assert_eq!(params.file_path, "dev.db");
-    }
-
     #[tokio::test]
     async fn unknown_table_should_give_a_good_error() {
         let conn = Sqlite::try_from("file:db/test.db").unwrap();
diff --git a/quaint/src/connector/sqlite/params.rs b/quaint/src/connector/sqlite/params.rs
index 46fb5c08f669..f024aa97a694 100644
--- a/quaint/src/connector/sqlite/params.rs
+++ b/quaint/src/connector/sqlite/params.rs
@@ -103,3 +103,29 @@ impl TryFrom<&str> for SqliteParams {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sqlite_params_from_str_should_resolve_path_correctly_with_file_scheme() {
+        let path = "file:dev.db";
+        let params = SqliteParams::try_from(path).unwrap();
+        assert_eq!(params.file_path, "dev.db");
+    }
+
+    #[test]
+    fn sqlite_params_from_str_should_resolve_path_correctly_with_sqlite_scheme() {
+        let path = "sqlite:dev.db";
+        let params = SqliteParams::try_from(path).unwrap();
+        assert_eq!(params.file_path, "dev.db");
+    }
+
+    #[test]
+    fn sqlite_params_from_str_should_resolve_path_correctly_with_no_scheme() {
+        let path = "dev.db";
+        let params = SqliteParams::try_from(path).unwrap();
+        assert_eq!(params.file_path, "dev.db");
+    }
+}