Skip to content

Use insert_into when possible #6437

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
Timshel wants to merge 1 commit into
base: main
Choose a base branch
from
+171 −321
Open

Use insert_into when possible #6437

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion src/api/core/accounts.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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,
Expand Down
22 changes: 7 additions & 15 deletions src/db/models/attachment.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -77,24 +77,16 @@ use crate::error::MapResult;
impl Attachment {
pub async fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn:
sqlite, mysql {
match diesel::replace_into(attachments::table)
mysql {
diesel::insert_into(attachments::table)
.values(self)
.on_conflict(diesel::dsl::DuplicatedKeys)
.do_update()
.set(self)
.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(attachments::table)
.filter(attachments::id.eq(&self.id))
.set(self)
.execute(conn)
.map_res("Error saving attachment")
}
Err(e) => Err(e.into()),
}.map_res("Error saving attachment")
.map_res("Error saving attachment")
}
postgresql {
postgresql, sqlite {
diesel::insert_into(attachments::table)
.values(self)
.on_conflict(attachments::id)
Expand Down
30 changes: 11 additions & 19 deletions src/db/models/auth_request.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
match diesel::replace_into(auth_requests::table)
.values(&*self)
mysql {
diesel::insert_into(auth_requests::table)
.values(self)
.on_conflict(diesel::dsl::DuplicatedKeys)
.do_update()
.set(self)
.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(auth_requests::table)
.filter(auth_requests::uuid.eq(&self.uuid))
.set(&*self)
.execute(conn)
.map_res("Error auth_request")
}
Err(e) => Err(e.into()),
}.map_res("Error auth_request")
.map_res("Error saving 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")
}
Expand Down
22 changes: 7 additions & 15 deletions src/db/models/cipher.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -438,24 +438,16 @@ impl Cipher {
self.updated_at = Utc::now().naive_utc();

db_run! { conn:
sqlite, mysql {
match diesel::replace_into(ciphers::table)
mysql {
diesel::insert_into(ciphers::table)
.values(&*self)
.on_conflict(diesel::dsl::DuplicatedKeys)
.do_update()
.set(&*self)
.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(ciphers::table)
.filter(ciphers::uuid.eq(&self.uuid))
.set(&*self)
.execute(conn)
.map_res("Error saving cipher")
}
Err(e) => Err(e.into()),
}.map_res("Error saving cipher")
.map_res("Error saving cipher")
}
postgresql {
postgresql, sqlite {
diesel::insert_into(ciphers::table)
.values(&*self)
.on_conflict(ciphers::uuid)
Expand Down
92 changes: 30 additions & 62 deletions src/db/models/collection.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -158,24 +158,16 @@ impl Collection {
self.update_users_revision(conn).await;

db_run! { conn:
sqlite, mysql {
match diesel::replace_into(collections::table)
mysql {
diesel::insert_into(collections::table)
.values(self)
.on_conflict(diesel::dsl::DuplicatedKeys)
.do_update()
.set(self)
.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(collections::table)
.filter(collections::uuid.eq(&self.uuid))
.set(self)
.execute(conn)
.map_res("Error saving collection")
}
Err(e) => Err(e.into()),
}.map_res("Error saving collection")
.map_res("Error saving collection")
}
postgresql {
postgresql, sqlite {
diesel::insert_into(collections::table)
.values(self)
.on_conflict(collections::uuid)
Expand Down Expand Up @@ -605,53 +597,30 @@ impl CollectionUser {
) -> EmptyResult {
User::update_uuid_revision(user_uuid, conn).await;

let 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),
);

db_run! { conn:
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),
))
mysql {
diesel::insert_into(users_collections::table)
.values(values)
.on_conflict(diesel::dsl::DuplicatedKeys)
.do_update()
.set(values)
.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),
))
.execute(conn)
.map_res("Error adding user to collection")
}
Err(e) => Err(e.into()),
}.map_res("Error adding user to collection")
.map_res("Error adding user to collection")
}
postgresql {
postgresql, sqlite {
diesel::insert_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),
))
.values(values)
.on_conflict((users_collections::user_uuid, users_collections::collection_uuid))
.do_update()
.set((
users_collections::read_only.eq(read_only),
users_collections::hide_passwords.eq(hide_passwords),
users_collections::manage.eq(manage),
))
.set(values)
.execute(conn)
.map_res("Error adding user to collection")
}
Expand Down Expand Up @@ -767,19 +736,18 @@ impl CollectionCipher {
Self::update_users_revision(collection_uuid, conn).await;

db_run! { conn:
sqlite, mysql {
// Not checking for ForeignKey Constraints here.
// 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)
mysql {
diesel::insert_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),
Expand Down
9 changes: 6 additions & 3 deletions src/db/models/device.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down
22 changes: 7 additions & 15 deletions src/db/models/emergency_access.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -144,24 +144,16 @@ impl EmergencyAccess {
self.updated_at = Utc::now().naive_utc();

db_run! { conn:
sqlite, mysql {
match diesel::replace_into(emergency_access::table)
mysql {
diesel::insert_into(emergency_access::table)
.values(&*self)
.on_conflict(diesel::dsl::DuplicatedKeys)
.do_update()
.set(&*self)
.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(emergency_access::table)
.filter(emergency_access::uuid.eq(&self.uuid))
.set(&*self)
.execute(conn)
.map_res("Error updating emergency access")
}
Err(e) => Err(e.into()),
}.map_res("Error saving emergency access")
.map_res("Error saving emergency access")
}
postgresql {
postgresql, sqlite {
diesel::insert_into(emergency_access::table)
.values(&*self)
.on_conflict(emergency_access::uuid)
Expand Down
27 changes: 15 additions & 12 deletions src/db/models/event.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -195,20 +195,23 @@ impl Event {
/// Basic Queries
pub async fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn:
sqlite, mysql {
diesel::replace_into(event::table)
.values(self)
.execute(conn)
.map_res("Error saving event")
mysql {
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)
.do_update()
.set(self)
.execute(conn)
.map_res("Error saving event")
.values(self)
.on_conflict(event::uuid)
.do_update()
.set(self)
.execute(conn)
.map_res("Error saving event")
}
}
}
Expand Down
33 changes: 12 additions & 21 deletions src/db/models/folder.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -74,24 +74,16 @@ impl Folder {
self.updated_at = Utc::now().naive_utc();

db_run! { conn:
sqlite, mysql {
match diesel::replace_into(folders::table)
mysql {
diesel::insert_into(folders::table)
.values(&*self)
.on_conflict(diesel::dsl::DuplicatedKeys)
.do_update()
.set(&*self)
.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(folders::table)
.filter(folders::uuid.eq(&self.uuid))
.set(&*self)
.execute(conn)
.map_res("Error saving folder")
}
Err(e) => Err(e.into()),
}.map_res("Error saving folder")
.map_res("Error saving folder")
}
postgresql {
postgresql, sqlite {
diesel::insert_into(folders::table)
.values(&*self)
.on_conflict(folders::uuid)
Expand Down Expand Up @@ -144,16 +136,15 @@ impl Folder {
impl FolderCipher {
pub async fn save(&self, conn: &DbConn) -> EmptyResult {
db_run! { conn:
sqlite, mysql {
// Not checking for ForeignKey Constraints here.
// 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)
mysql {
diesel::insert_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))
Expand Down
Loading