From 0ddeab8caaa0c9e3f5e74bf8908a2a5c2bc6822d Mon Sep 17 00:00:00 2001
From: Valentin Tolmer <valentin@tolmer.fr>
Date: Thu, 21 Nov 2024 23:22:53 +0100
Subject: [PATCH] server: Fix schema migration from v8 for sqlite and postgres

Neither supports limits, but we can delete all the duplicate memberships and re-insert a single one
---
 server/src/domain/sql_migrations.rs | 59 +++++++++++------------------
 1 file changed, 22 insertions(+), 37 deletions(-)

diff --git a/server/src/domain/sql_migrations.rs b/server/src/domain/sql_migrations.rs
index 4bd54cf..64630a1 100644
--- a/server/src/domain/sql_migrations.rs
+++ b/server/src/domain/sql_migrations.rs
@@ -5,8 +5,8 @@ use crate::domain::{
 use itertools::Itertools;
 use sea_orm::{
     sea_query::{
-        self, all, Alias, BinOper, BlobSize::Blob, ColumnDef, Expr, ForeignKey, ForeignKeyAction,
-        Func, Index, Query, SimpleExpr, Table, Value,
+        self, all, BinOper, BlobSize::Blob, ColumnDef, Expr, ForeignKey, ForeignKeyAction, Func,
+        Index, Query, SimpleExpr, Table, Value,
     },
     ConnectionTrait, DatabaseTransaction, DbErr, DeriveIden, FromQueryResult, Iden, Order,
     Statement, TransactionTrait,
@@ -970,21 +970,15 @@ async fn migrate_to_v8(transaction: DatabaseTransaction) -> Result<DatabaseTrans
     let builder = transaction.get_database_backend();
     // Remove duplicate memberships.
     #[derive(FromQueryResult)]
-    #[allow(dead_code)]
     struct MembershipInfo {
         user_id: UserId,
         group_id: GroupId,
-        cnt: i64,
     }
-    let mut delete_queries = MembershipInfo::find_by_statement(
+    for MembershipInfo { user_id, group_id } in MembershipInfo::find_by_statement(
         builder.build(
             Query::select()
                 .from(Memberships::Table)
                 .columns([Memberships::UserId, Memberships::GroupId])
-                .expr_as(
-                    Expr::count(Expr::col((Memberships::Table, Memberships::UserId))),
-                    Alias::new("cnt"),
-                )
                 .group_by_columns([Memberships::UserId, Memberships::GroupId])
                 .cond_having(all![SimpleExpr::Binary(
                     Box::new(Expr::col((Memberships::Table, Memberships::UserId)).count()),
@@ -996,38 +990,29 @@ async fn migrate_to_v8(transaction: DatabaseTransaction) -> Result<DatabaseTrans
     .all(&transaction)
     .await?
     .into_iter()
-    .map(
-        |MembershipInfo {
-             user_id,
-             group_id,
-             cnt,
-         }| {
-            builder
-                .build(
+    {
+        transaction
+            .execute(
+                builder.build(
                     Query::delete()
                         .from_table(Memberships::Table)
                         .cond_where(all![
-                            Expr::col(Memberships::UserId).eq(user_id),
+                            Expr::col(Memberships::UserId).eq(&user_id),
                             Expr::col(Memberships::GroupId).eq(group_id)
-                        ])
-                        .limit(cnt as u64 - 1),
-                )
-                .to_owned()
-        },
-    )
-    .peekable();
-    if delete_queries.peek().is_some() {
-        match transaction.get_database_backend() {
-            sea_orm::DatabaseBackend::Sqlite => {
-                return Err(DbErr::Migration(format!(
-                    "The Sqlite driver does not support LIMIT in DELETE. Run these queries manually:\n{}" , delete_queries.map(|s| s.to_string()).join("\n"))));
-            }
-            sea_orm::DatabaseBackend::MySql | sea_orm::DatabaseBackend::Postgres => {
-                for query in delete_queries {
-                    transaction.execute(query).await?;
-                }
-            }
-        }
+                        ]),
+                ),
+            )
+            .await?;
+        transaction
+            .execute(
+                builder.build(
+                    Query::insert()
+                        .into_table(Memberships::Table)
+                        .columns([Memberships::UserId, Memberships::GroupId])
+                        .values_panic([user_id.into(), group_id.into()]),
+                ),
+            )
+            .await?;
     }
     transaction
         .execute(