Use insert_into when possible

src/api/core/accounts.rs

@@ -1476,7 +1476,7 @@ async fn post_auth_request(
         _ => err!("AuthRequest doesn't exist", "Device verification failed"),
     };
 
-    let mut auth_request = AuthRequest::new(
+    let auth_request = AuthRequest::new(
         user.uuid.clone(),
         data.device_identifier.clone(),
         client_headers.device_type,

src/db/models/attachment.rs

@@ -77,24 +77,16 @@ use crate::error::MapResult;
 impl Attachment {
     pub async fn save(&self, conn: &DbConn) -> EmptyResult {
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(attachments::table)
+                diesel::insert_into(attachments::table)
                     .values(self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(attachments::table)
-                            .filter(attachments::id.eq(&self.id))
                     .set(self)
                     .execute(conn)
                     .map_res("Error saving attachment")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error saving attachment")
-            }
-            postgresql {
                 diesel::insert_into(attachments::table)
                     .values(self)
                     .on_conflict(attachments::id)

src/db/models/auth_request.rs

@@ -80,31 +80,23 @@ use crate::api::EmptyResult;
 use crate::error::MapResult;
 
 impl AuthRequest {
-    pub async fn save(&mut self, conn: &DbConn) -> EmptyResult {
+    pub async fn save(&self, conn: &DbConn) -> EmptyResult {
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(auth_requests::table)
+                diesel::insert_into(auth_requests::table)
-                    .values(&*self)
+                    .values(self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
+                    .set(self)
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(auth_requests::table)
-                            .filter(auth_requests::uuid.eq(&self.uuid))
-                            .set(&*self)
                     .execute(conn)
-                            .map_res("Error auth_request")
+                    .map_res("Error saving auth_request")
-                    }
-                    Err(e) => Err(e.into()),
-                }.map_res("Error auth_request")
             }
-            postgresql {
+            postgresql, sqlite {
                 diesel::insert_into(auth_requests::table)
-                    .values(&*self)
+                    .values(self)
                     .on_conflict(auth_requests::uuid)
                     .do_update()
-                    .set(&*self)
+                    .set(self)
                     .execute(conn)
                     .map_res("Error saving auth_request")
             }

src/db/models/cipher.rs

@@ -438,24 +438,16 @@ impl Cipher {
         self.updated_at = Utc::now().naive_utc();
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(ciphers::table)
+                diesel::insert_into(ciphers::table)
                     .values(&*self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(ciphers::table)
-                            .filter(ciphers::uuid.eq(&self.uuid))
                     .set(&*self)
                     .execute(conn)
                     .map_res("Error saving cipher")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error saving cipher")
-            }
-            postgresql {
                 diesel::insert_into(ciphers::table)
                     .values(&*self)
                     .on_conflict(ciphers::uuid)

src/db/models/collection.rs

@@ -158,24 +158,16 @@ impl Collection {
         self.update_users_revision(conn).await;
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(collections::table)
+                diesel::insert_into(collections::table)
                     .values(self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(collections::table)
-                            .filter(collections::uuid.eq(&self.uuid))
                     .set(self)
                     .execute(conn)
                     .map_res("Error saving collection")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error saving collection")
-            }
-            postgresql {
                 diesel::insert_into(collections::table)
                     .values(self)
                     .on_conflict(collections::uuid)
@@ -605,53 +597,30 @@ impl CollectionUser {
     ) -> EmptyResult {
         User::update_uuid_revision(user_uuid, conn).await;
 
-        db_run! { conn:
+        let values = (
-            sqlite, mysql {
-                match diesel::replace_into(users_collections::table)
-                    .values((
-                        users_collections::user_uuid.eq(user_uuid),
-                        users_collections::collection_uuid.eq(collection_uuid),
-                        users_collections::read_only.eq(read_only),
-                        users_collections::hide_passwords.eq(hide_passwords),
-                        users_collections::manage.eq(manage),
-                    ))
-                    .execute(conn)
-                {
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(users_collections::table)
-                            .filter(users_collections::user_uuid.eq(user_uuid))
-                            .filter(users_collections::collection_uuid.eq(collection_uuid))
-                            .set((
             users_collections::user_uuid.eq(user_uuid),
             users_collections::collection_uuid.eq(collection_uuid),
             users_collections::read_only.eq(read_only),
             users_collections::hide_passwords.eq(hide_passwords),
             users_collections::manage.eq(manage),
-                            ))
+        );
+
+        db_run! { conn:
+            mysql {
+                diesel::insert_into(users_collections::table)
+                    .values(values)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
+                    .do_update()
+                    .set(values)
                     .execute(conn)
                     .map_res("Error adding user to collection")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error adding user to collection")
-            }
-            postgresql {
                 diesel::insert_into(users_collections::table)
-                    .values((
+                    .values(values)
-                        users_collections::user_uuid.eq(user_uuid),
-                        users_collections::collection_uuid.eq(collection_uuid),
-                        users_collections::read_only.eq(read_only),
-                        users_collections::hide_passwords.eq(hide_passwords),
-                        users_collections::manage.eq(manage),
-                    ))
                     .on_conflict((users_collections::user_uuid, users_collections::collection_uuid))
                     .do_update()
-                    .set((
+                    .set(values)
-                        users_collections::read_only.eq(read_only),
-                        users_collections::hide_passwords.eq(hide_passwords),
-                        users_collections::manage.eq(manage),
-                    ))
                     .execute(conn)
                     .map_res("Error adding user to collection")
             }
@@ -767,19 +736,18 @@ impl CollectionCipher {
         Self::update_users_revision(collection_uuid, conn).await;
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                // Not checking for ForeignKey Constraints here.
+                diesel::insert_into(ciphers_collections::table)
-                // Table ciphers_collections does not have ForeignKey Constraints which would cause conflicts.
-                // This table has no constraints pointing to itself, but only to others.
-                diesel::replace_into(ciphers_collections::table)
                     .values((
                         ciphers_collections::cipher_uuid.eq(cipher_uuid),
                         ciphers_collections::collection_uuid.eq(collection_uuid),
                     ))
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
+                    .do_nothing()
                     .execute(conn)
                     .map_res("Error adding cipher to collection")
             }
-            postgresql {
+            postgresql, sqlite {
                 diesel::insert_into(ciphers_collections::table)
                     .values((
                         ciphers_collections::cipher_uuid.eq(cipher_uuid),

src/db/models/device.rs

@@ -138,15 +138,18 @@ impl Device {
 
     async fn inner_save(&self, conn: &DbConn) -> EmptyResult {
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
                 crate::util::retry(||
-                    diesel::replace_into(devices::table)
+                    diesel::insert_into(devices::table)
                         .values(self)
+                        .on_conflict(diesel::dsl::DuplicatedKeys)
+                        .do_update()
+                        .set(self)
                         .execute(conn),
                     10,
                 ).map_res("Error saving device")
             }
-            postgresql {
+            postgresql, sqlite {
                 crate::util::retry(||
                     diesel::insert_into(devices::table)
                         .values(self)

src/db/models/emergency_access.rs

@@ -144,24 +144,16 @@ impl EmergencyAccess {
         self.updated_at = Utc::now().naive_utc();
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(emergency_access::table)
+                diesel::insert_into(emergency_access::table)
                     .values(&*self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(emergency_access::table)
-                            .filter(emergency_access::uuid.eq(&self.uuid))
                     .set(&*self)
                     .execute(conn)
-                            .map_res("Error updating emergency access")
+                    .map_res("Error saving emergency access")
-                    }
-                    Err(e) => Err(e.into()),
-                }.map_res("Error saving emergency access")
             }
-            postgresql {
+            postgresql, sqlite {
                 diesel::insert_into(emergency_access::table)
                     .values(&*self)
                     .on_conflict(emergency_access::uuid)

src/db/models/event.rs

@@ -195,13 +195,16 @@ impl Event {
     /// Basic Queries
     pub async fn save(&self, conn: &DbConn) -> EmptyResult {
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                diesel::replace_into(event::table)
+                diesel::insert_into(event::table)
                     .values(self)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
+                    .do_update()
+                    .set(self)
                     .execute(conn)
                     .map_res("Error saving event")
             }
-            postgresql {
+            postgresql, sqlite {
                 diesel::insert_into(event::table)
                     .values(self)
                     .on_conflict(event::uuid)

src/db/models/folder.rs

@@ -74,24 +74,16 @@ impl Folder {
         self.updated_at = Utc::now().naive_utc();
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(folders::table)
+                diesel::insert_into(folders::table)
                     .values(&*self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(folders::table)
-                            .filter(folders::uuid.eq(&self.uuid))
                     .set(&*self)
                     .execute(conn)
                     .map_res("Error saving folder")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error saving folder")
-            }
-            postgresql {
                 diesel::insert_into(folders::table)
                     .values(&*self)
                     .on_conflict(folders::uuid)
@@ -144,16 +136,15 @@ impl Folder {
 impl FolderCipher {
     pub async fn save(&self, conn: &DbConn) -> EmptyResult {
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                // Not checking for ForeignKey Constraints here.
+                diesel::insert_into(folders_ciphers::table)
-                // Table folders_ciphers does not have ForeignKey Constraints which would cause conflicts.
-                // This table has no constraints pointing to itself, but only to others.
-                diesel::replace_into(folders_ciphers::table)
                     .values(self)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
+                    .do_nothing()
                     .execute(conn)
                     .map_res("Error adding cipher to folder")
             }
-            postgresql {
+            postgresql, sqlite {
                 diesel::insert_into(folders_ciphers::table)
                     .values(self)
                     .on_conflict((folders_ciphers::cipher_uuid, folders_ciphers::folder_uuid))

src/db/models/group.rs

@@ -160,24 +160,16 @@ impl Group {
         self.revision_date = Utc::now().naive_utc();
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(groups::table)
+                diesel::insert_into(groups::table)
                     .values(&*self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(groups::table)
-                            .filter(groups::uuid.eq(&self.uuid))
                     .set(&*self)
                     .execute(conn)
                     .map_res("Error saving group")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error saving group")
-            }
-            postgresql {
                 diesel::insert_into(groups::table)
                     .values(&*self)
                     .on_conflict(groups::uuid)
@@ -312,53 +304,30 @@ impl CollectionGroup {
             group_user.update_user_revision(conn).await;
         }
 
-        db_run! { conn:
+        let values = (
-            sqlite, mysql {
-                match diesel::replace_into(collections_groups::table)
-                    .values((
             collections_groups::collections_uuid.eq(&self.collections_uuid),
             collections_groups::groups_uuid.eq(&self.groups_uuid),
             collections_groups::read_only.eq(&self.read_only),
             collections_groups::hide_passwords.eq(&self.hide_passwords),
             collections_groups::manage.eq(&self.manage),
-                    ))
+        );
-                    .execute(conn)
+
-                {
+        db_run! { conn:
-                    Ok(_) => Ok(()),
+            mysql {
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
+                diesel::insert_into(collections_groups::table)
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
+                    .values(values)
-                        diesel::update(collections_groups::table)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                            .filter(collections_groups::collections_uuid.eq(&self.collections_uuid))
+                    .do_update()
-                            .filter(collections_groups::groups_uuid.eq(&self.groups_uuid))
+                    .set(values)
-                            .set((
-                                collections_groups::collections_uuid.eq(&self.collections_uuid),
-                                collections_groups::groups_uuid.eq(&self.groups_uuid),
-                                collections_groups::read_only.eq(&self.read_only),
-                                collections_groups::hide_passwords.eq(&self.hide_passwords),
-                                collections_groups::manage.eq(&self.manage),
-                            ))
                     .execute(conn)
                     .map_res("Error adding group to collection")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error adding group to collection")
-            }
-            postgresql {
                 diesel::insert_into(collections_groups::table)
-                    .values((
+                    .values(values)
-                        collections_groups::collections_uuid.eq(&self.collections_uuid),
-                        collections_groups::groups_uuid.eq(&self.groups_uuid),
-                        collections_groups::read_only.eq(self.read_only),
-                        collections_groups::hide_passwords.eq(self.hide_passwords),
-                        collections_groups::manage.eq(self.manage),
-                    ))
                     .on_conflict((collections_groups::collections_uuid, collections_groups::groups_uuid))
                     .do_update()
-                    .set((
+                    .set(values)
-                        collections_groups::read_only.eq(self.read_only),
-                        collections_groups::hide_passwords.eq(self.hide_passwords),
-                        collections_groups::manage.eq(self.manage),
-                    ))
                     .execute(conn)
                     .map_res("Error adding group to collection")
             }
@@ -451,43 +420,25 @@ impl GroupUser {
     pub async fn save(&mut self, conn: &DbConn) -> EmptyResult {
         self.update_user_revision(conn).await;
 
-        db_run! { conn:
+        let values = (
-            sqlite, mysql {
-                match diesel::replace_into(groups_users::table)
-                    .values((
-                        groups_users::users_organizations_uuid.eq(&self.users_organizations_uuid),
-                        groups_users::groups_uuid.eq(&self.groups_uuid),
-                    ))
-                    .execute(conn)
-                {
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(groups_users::table)
-                            .filter(groups_users::users_organizations_uuid.eq(&self.users_organizations_uuid))
-                            .filter(groups_users::groups_uuid.eq(&self.groups_uuid))
-                            .set((
             groups_users::users_organizations_uuid.eq(&self.users_organizations_uuid),
             groups_users::groups_uuid.eq(&self.groups_uuid),
-                            ))
+        );
+
+        db_run! { conn:
+            mysql {
+                diesel::insert_into(groups_users::table)
+                    .values(values)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
+                    .do_nothing()
                     .execute(conn)
                     .map_res("Error adding user to group")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error adding user to group")
-            }
-            postgresql {
                 diesel::insert_into(groups_users::table)
-                    .values((
+                    .values(values)
-                        groups_users::users_organizations_uuid.eq(&self.users_organizations_uuid),
-                        groups_users::groups_uuid.eq(&self.groups_uuid),
-                    ))
                     .on_conflict((groups_users::users_organizations_uuid, groups_users::groups_uuid))
-                    .do_update()
+                    .do_nothing()
-                    .set((
-                        groups_users::users_organizations_uuid.eq(&self.users_organizations_uuid),
-                        groups_users::groups_uuid.eq(&self.groups_uuid),
-                    ))
                     .execute(conn)
                     .map_res("Error adding user to group")
             }

src/db/models/organization.rs

@@ -338,25 +338,16 @@ impl Organization {
         }
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(organizations::table)
+                diesel::insert_into(organizations::table)
                     .values(self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(organizations::table)
-                            .filter(organizations::uuid.eq(&self.uuid))
                     .set(self)
                     .execute(conn)
                     .map_res("Error saving organization")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error saving organization")
-
-            }
-            postgresql {
                 diesel::insert_into(organizations::table)
                     .values(self)
                     .on_conflict(organizations::uuid)
@@ -744,24 +735,16 @@ impl Membership {
         User::update_uuid_revision(&self.user_uuid, conn).await;
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(users_organizations::table)
+                diesel::insert_into(users_organizations::table)
                     .values(self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(users_organizations::table)
-                            .filter(users_organizations::uuid.eq(&self.uuid))
                     .set(self)
                     .execute(conn)
                     .map_res("Error adding user to organization")
-                    },
-                    Err(e) => Err(e.into()),
-                }.map_res("Error adding user to organization")
             }
-            postgresql {
+            postgresql, sqlite {
                 diesel::insert_into(users_organizations::table)
                     .values(self)
                     .on_conflict(users_organizations::uuid)
@@ -1147,25 +1130,16 @@ impl Membership {
 impl OrganizationApiKey {
     pub async fn save(&self, conn: &DbConn) -> EmptyResult {
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(organization_api_key::table)
+                diesel::insert_into(organization_api_key::table)
                     .values(self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(organization_api_key::table)
-                            .filter(organization_api_key::uuid.eq(&self.uuid))
                     .set(self)
                     .execute(conn)
                     .map_res("Error saving organization")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error saving organization")
-
-            }
-            postgresql {
                 diesel::insert_into(organization_api_key::table)
                     .values(self)
                     .on_conflict((organization_api_key::uuid, organization_api_key::org_uuid))

src/db/models/send.rs

@@ -192,24 +192,16 @@ impl Send {
         self.revision_date = Utc::now().naive_utc();
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                match diesel::replace_into(sends::table)
+                diesel::insert_into(sends::table)
                     .values(&*self)
-                    .execute(conn)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
-                {
+                    .do_update()
-                    Ok(_) => Ok(()),
-                    // Record already exists and causes a Foreign Key Violation because replace_into() wants to delete the record first.
-                    Err(diesel::result::Error::DatabaseError(diesel::result::DatabaseErrorKind::ForeignKeyViolation, _)) => {
-                        diesel::update(sends::table)
-                            .filter(sends::uuid.eq(&self.uuid))
                     .set(&*self)
                     .execute(conn)
                     .map_res("Error saving send")
             }
-                    Err(e) => Err(e.into()),
+            postgresql, sqlite {
-                }.map_res("Error saving send")
-            }
-            postgresql {
                 diesel::insert_into(sends::table)
                     .values(&*self)
                     .on_conflict(sends::uuid)

src/db/models/user.rs

@@ -432,15 +432,15 @@ impl Invitation {
         }
 
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                // Not checking for ForeignKey Constraints here
+                diesel::insert_into(invitations::table)
-                // Table invitations does not have any ForeignKey Constraints.
-                diesel::replace_into(invitations::table)
                     .values(self)
+                    .on_conflict(diesel::dsl::DuplicatedKeys)
+                    .do_nothing()
                     .execute(conn)
                     .map_res("Error saving invitation")
             }
-            postgresql {
+            postgresql, sqlite {
                 diesel::insert_into(invitations::table)
                     .values(self)
                     .on_conflict(invitations::email)
@@ -500,13 +500,13 @@ pub struct UserId(String);
 impl SsoUser {
     pub async fn save(&self, conn: &DbConn) -> EmptyResult {
         db_run! { conn:
-            sqlite, mysql {
+            mysql {
-                diesel::replace_into(sso_users::table)
+                diesel::insert_into(sso_users::table)
                     .values(self)
                     .execute(conn)
                     .map_res("Error saving SSO user")
             }
-            postgresql {
+            postgresql, sqlite {
                 diesel::insert_into(sso_users::table)
                     .values(self)
                     .execute(conn)