X-Git-Url: http://these/git/?a=blobdiff_plain;f=crates%2Fdb_schema%2Fsrc%2Futils.rs;h=7e8204de9a7844154d8c3f919f71de6640f6547d;hb=3471f3533cb724b2cf6953d563aadfcc9f66c1d2;hp=267540554800ca8cbdf68e5f39da51c0a1f855a3;hpb=93225e5ddfd48e613afe51984243112a1bedfcc2;p=lemmy.git

diff --git a/crates/db_schema/src/utils.rs b/crates/db_schema/src/utils.rs
index 26754055..7e8204de 100644
--- a/crates/db_schema/src/utils.rs
+++ b/crates/db_schema/src/utils.rs
@@ -3,6 +3,7 @@ use crate::{
   diesel_migrations::MigrationHarness,
   newtypes::DbUrl,
   CommentSortType,
+  PersonSortType,
   SortType,
 };
 use activitypub_federation::{fetch::object_id::ObjectId, traits::Object};
@@ -39,6 +40,7 @@ use rustls::{
 use std::{
   env,
   env::VarError,
+  ops::{Deref, DerefMut},
   sync::Arc,
   time::{Duration, SystemTime},
 };
@@ -49,10 +51,101 @@ const FETCH_LIMIT_DEFAULT: i64 = 10;
 pub const FETCH_LIMIT_MAX: i64 = 50;
 const POOL_TIMEOUT: Option<Duration> = Some(Duration::from_secs(5));
 
-pub type DbPool = Pool<AsyncPgConnection>;
+pub type ActualDbPool = Pool<AsyncPgConnection>;
 
-pub async fn get_conn(pool: &DbPool) -> Result<PooledConnection<AsyncPgConnection>, DieselError> {
-  pool.get().await.map_err(|e| QueryBuilderError(e.into()))
+/// References a pool or connection. Functions must take `&mut DbPool<'_>` to allow implicit reborrowing.
+///
+/// https://github.com/rust-lang/rfcs/issues/1403
+pub enum DbPool<'a> {
+  Pool(&'a ActualDbPool),
+  Conn(&'a mut AsyncPgConnection),
+}
+
+pub enum DbConn<'a> {
+  Pool(PooledConnection<AsyncPgConnection>),
+  Conn(&'a mut AsyncPgConnection),
+}
+
+pub async fn get_conn<'a, 'b: 'a>(pool: &'a mut DbPool<'b>) -> Result<DbConn<'a>, DieselError> {
+  Ok(match pool {
+    DbPool::Pool(pool) => DbConn::Pool(pool.get().await.map_err(|e| QueryBuilderError(e.into()))?),
+    DbPool::Conn(conn) => DbConn::Conn(conn),
+  })
+}
+
+impl<'a> Deref for DbConn<'a> {
+  type Target = AsyncPgConnection;
+
+  fn deref(&self) -> &Self::Target {
+    match self {
+      DbConn::Pool(conn) => conn.deref(),
+      DbConn::Conn(conn) => conn.deref(),
+    }
+  }
+}
+
+impl<'a> DerefMut for DbConn<'a> {
+  fn deref_mut(&mut self) -> &mut Self::Target {
+    match self {
+      DbConn::Pool(conn) => conn.deref_mut(),
+      DbConn::Conn(conn) => conn.deref_mut(),
+    }
+  }
+}
+
+// Allows functions that take `DbPool<'_>` to be called in a transaction by passing `&mut conn.into()`
+impl<'a> From<&'a mut AsyncPgConnection> for DbPool<'a> {
+  fn from(value: &'a mut AsyncPgConnection) -> Self {
+    DbPool::Conn(value)
+  }
+}
+
+impl<'a, 'b: 'a> From<&'a mut DbConn<'b>> for DbPool<'a> {
+  fn from(value: &'a mut DbConn<'b>) -> Self {
+    DbPool::Conn(value.deref_mut())
+  }
+}
+
+impl<'a> From<&'a ActualDbPool> for DbPool<'a> {
+  fn from(value: &'a ActualDbPool) -> Self {
+    DbPool::Pool(value)
+  }
+}
+
+/// Runs multiple async functions that take `&mut DbPool<'_>` as input and return `Result`. Only works when the  `futures` crate is listed in `Cargo.toml`.
+///
+/// `$pool` is the value given to each function.
+///
+/// A `Result` is returned (not in a `Future`, so don't use `.await`). The `Ok` variant contains a tuple with the values returned by the given functions.
+///
+/// The functions run concurrently if `$pool` has the `DbPool::Pool` variant.
+#[macro_export]
+macro_rules! try_join_with_pool {
+  ($pool:ident => ($($func:expr),+)) => {{
+    // Check type
+    let _: &mut $crate::utils::DbPool<'_> = $pool;
+
+    match $pool {
+      // Run concurrently with `try_join`
+      $crate::utils::DbPool::Pool(__pool) => ::futures::try_join!(
+        $(async {
+          let mut __dbpool = $crate::utils::DbPool::Pool(__pool);
+          ($func)(&mut __dbpool).await
+        }),+
+      ),
+      // Run sequentially
+      $crate::utils::DbPool::Conn(__conn) => async {
+        Ok(($({
+          let mut __dbpool = $crate::utils::DbPool::Conn(__conn);
+          // `?` prevents the error type from being inferred in an `async` block, so `match` is used instead
+          match ($func)(&mut __dbpool).await {
+            ::core::result::Result::Ok(__v) => __v,
+            ::core::result::Result::Err(__v) => return ::core::result::Result::Err(__v),
+          }
+        }),+))
+      }.await,
+    }
+  }};
 }
 
 pub fn get_database_url_from_env() -> Result<String, VarError> {
@@ -104,12 +197,12 @@ pub fn is_email_regex(test: &str) -> bool {
   EMAIL_REGEX.is_match(test)
 }
 
-pub fn diesel_option_overwrite(opt: &Option<String>) -> Option<Option<String>> {
+pub fn diesel_option_overwrite(opt: Option<String>) -> Option<Option<String>> {
   match opt {
     // An empty string is an erase
     Some(unwrapped) => {
       if !unwrapped.eq("") {
-        Some(Some(unwrapped.clone()))
+        Some(Some(unwrapped))
       } else {
         Some(None)
       }
@@ -144,7 +237,9 @@ pub fn diesel_option_overwrite_to_url_create(
   }
 }
 
-async fn build_db_pool_settings_opt(settings: Option<&Settings>) -> Result<DbPool, LemmyError> {
+async fn build_db_pool_settings_opt(
+  settings: Option<&Settings>,
+) -> Result<ActualDbPool, LemmyError> {
   let db_url = get_database_url(settings);
   let pool_size = settings.map(|s| s.database.pool_size).unwrap_or(5);
   // We only support TLS with sslmode=require currently
@@ -223,11 +318,11 @@ pub fn run_migrations(db_url: &str) {
   info!("Database migrations complete.");
 }
 
-pub async fn build_db_pool(settings: &Settings) -> Result<DbPool, LemmyError> {
+pub async fn build_db_pool(settings: &Settings) -> Result<ActualDbPool, LemmyError> {
   build_db_pool_settings_opt(Some(settings)).await
 }
 
-pub async fn build_db_pool_for_tests() -> DbPool {
+pub async fn build_db_pool_for_tests() -> ActualDbPool {
   build_db_pool_settings_opt(None)
     .await
     .expect("db pool missing")
@@ -253,6 +348,7 @@ pub fn post_to_comment_sort_type(sort: SortType) -> CommentSortType {
     SortType::Active | SortType::Hot => CommentSortType::Hot,
     SortType::New | SortType::NewComments | SortType::MostComments => CommentSortType::New,
     SortType::Old => CommentSortType::Old,
+    SortType::Controversial => CommentSortType::Controversial,
     SortType::TopHour
     | SortType::TopSixHour
     | SortType::TopTwelveHour
@@ -267,6 +363,16 @@ pub fn post_to_comment_sort_type(sort: SortType) -> CommentSortType {
   }
 }
 
+pub fn post_to_person_sort_type(sort: SortType) -> PersonSortType {
+  match sort {
+    SortType::Active | SortType::Hot | SortType::Controversial => PersonSortType::CommentScore,
+    SortType::New | SortType::NewComments => PersonSortType::New,
+    SortType::MostComments => PersonSortType::MostComments,
+    SortType::Old => PersonSortType::Old,
+    _ => PersonSortType::CommentScore,
+  }
+}
+
 static EMAIL_REGEX: Lazy<Regex> = Lazy::new(|| {
   Regex::new(r"^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$")
     .expect("compile email regex")
@@ -279,6 +385,10 @@ pub mod functions {
     fn hot_rank(score: BigInt, time: Timestamp) -> Integer;
   }
 
+  sql_function! {
+    fn controversy_rank(upvotes: BigInt, downvotes: BigInt, score: BigInt) -> Double;
+  }
+
   sql_function!(fn lower(x: Text) -> Text);
 }
 
@@ -312,6 +422,9 @@ where
 
 #[cfg(test)]
 mod tests {
+  #![allow(clippy::unwrap_used)]
+  #![allow(clippy::indexing_slicing)]
+
   use super::{fuzzy_search, *};
   use crate::utils::is_email_regex;
 
@@ -332,10 +445,10 @@ mod tests {
 
   #[test]
   fn test_diesel_option_overwrite() {
-    assert_eq!(diesel_option_overwrite(&None), None);
-    assert_eq!(diesel_option_overwrite(&Some(String::new())), Some(None));
+    assert_eq!(diesel_option_overwrite(None), None);
+    assert_eq!(diesel_option_overwrite(Some(String::new())), Some(None));
     assert_eq!(
-      diesel_option_overwrite(&Some("test".to_string())),
+      diesel_option_overwrite(Some("test".to_string())),
       Some(Some("test".to_string()))
     );
   }