SONAR-15142 - Persisting deletes only when deletedRows > 0

40 files changed, 484 insertions, 239 deletions

diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatDao.java
index f2d29cf5313..e8ec8d446dc 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatDao.java
@@ -82,22 +82,22 @@ public class AlmPatDao implements Dao {
   }
 
   public void delete(DbSession dbSession, AlmPatDto almPatDto, @Nullable String userLogin, @Nullable String almSettingKey) {
-    getMapper(dbSession).deleteByUuid(almPatDto.getUuid());
-    if (auditPersister != null) {
+    int deletedRows = getMapper(dbSession).deleteByUuid(almPatDto.getUuid());
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almPatDto, userLogin, almSettingKey));
     }
   }
 
   public void deleteByUser(DbSession dbSession, UserDto user) {
-    getMapper(dbSession).deleteByUser(user.getUuid());
-    if (auditPersister != null) {
+    int deletedRows = getMapper(dbSession).deleteByUser(user.getUuid());
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(user));
     }
   }
 
   public void deleteByAlmSetting(DbSession dbSession, AlmSettingDto almSetting) {
-    getMapper(dbSession).deleteByAlmSetting(almSetting.getUuid());
-    if (auditPersister != null) {
+    int deletedRows = getMapper(dbSession).deleteByAlmSetting(almSetting.getUuid());
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deletePersonalAccessToken(dbSession, new PersonalAccessTokenNewValue(almSetting));
     }
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatMapper.java
index 3f2e0c255d8..32cd52f7b92 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/pat/AlmPatMapper.java
@@ -34,9 +34,9 @@ public interface AlmPatMapper {
 
   void update(@Param("dto") AlmPatDto almPatDto);
 
-  void deleteByUuid(@Param("uuid") String uuid);
+  int deleteByUuid(@Param("uuid") String uuid);
 
-  void deleteByUser(@Param("userUuid") String userUuid);
+  int deleteByUser(@Param("userUuid") String userUuid);
 
-  void deleteByAlmSetting(@Param("almSettingUuid") String almSettingUuid);
+  int deleteByAlmSetting(@Param("almSettingUuid") String almSettingUuid);
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingDao.java
index 35f8ae7fa2e..973e7e82f44 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingDao.java
@@ -79,9 +79,9 @@ public class AlmSettingDao implements Dao {
   }
 
   public void delete(DbSession dbSession, AlmSettingDto almSettingDto) {
-    getMapper(dbSession).deleteByKey(almSettingDto.getKey());
+    int deletedRows = getMapper(dbSession).deleteByKey(almSettingDto.getKey());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(almSettingDto.getUuid(), almSettingDto.getKey()));
     }
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingMapper.java
index c45a34c45b8..bd0397abba3 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/AlmSettingMapper.java
@@ -39,5 +39,5 @@ public interface AlmSettingMapper {
 
   void update(@Param("dto") AlmSettingDto almSettingDto);
 
-  void deleteByKey(@Param("key") String key);
+  int deleteByKey(@Param("key") String key);
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingDao.java
index 6333987cbbd..9668dcbda25 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingDao.java
@@ -73,9 +73,9 @@ public class ProjectAlmSettingDao implements Dao {
   }
 
   public void deleteByProject(DbSession dbSession, ProjectDto project) {
-    getMapper(dbSession).deleteByProjectUuid(project.getUuid());
+    int deletedRows = getMapper(dbSession).deleteByProjectUuid(project.getUuid());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteDevOpsPlatformSetting(dbSession, new DevOpsPlatformSettingNewValue(project));
     }
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingMapper.java
index 7c25eb34497..fc4342f8071 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/alm/setting/ProjectAlmSettingMapper.java
@@ -34,7 +34,7 @@ public interface ProjectAlmSettingMapper {
 
   int update(@Param("dto") ProjectAlmSettingDto projectAlmSettingDto, @Param("now") long now);
 
-  void deleteByProjectUuid(@Param("projectUuid") String projectUuid);
+  int deleteByProjectUuid(@Param("projectUuid") String projectUuid);
   void deleteByAlmSettingUuid(@Param("almSettingUuid") String almSettingUuid);
 
   List<ProjectAlmSettingDto> selectByAlmSettingAndSlugs(@Param("almSettingUuid") String almSettingUuid, @Param("slugs") List<String> slugs);
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ProjectNewValue.java b/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ProjectNewValue.java
deleted file mode 100644
index ffe6c8ab411..00000000000
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/audit/model/ProjectNewValue.java
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
- * SonarQube
- * Copyright (C) 2009-2021 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-package org.sonar.db.audit.model;
-
-import org.apache.commons.lang.ObjectUtils;
-
-public class ProjectNewValue extends NewValue{
-
-  private final String uuid;
-  private String name;
-  private String description;
-  private Boolean isPrivate;
-
-  public ProjectNewValue(String uuid, boolean isPrivate, String name, String description) {
-    this.uuid = uuid;
-    this.isPrivate = isPrivate;
-    this.name = name;
-    this.description = description;
-  }
-
-  public String getUuid() {
-    return uuid;
-  }
-
-  public String getDescription() {
-    return description;
-  }
-
-  public boolean isPrivate() {
-    return isPrivate;
-  }
-
-  public String getName() {
-    return name;
-  }
-
-  @Override
-  public String toString() {
-    StringBuilder sb = new StringBuilder("{");
-    addField(sb, "\"projectUuid\": ", this.uuid, true);
-    addField(sb, "\"description\": ", this.description, true);
-    addField(sb, "\"name\": ", this.name, true);
-    addField(sb, "\"isPrivate\": ", ObjectUtils.toString(this.isPrivate), false);
-    endString(sb);
-    return sb.toString();
-  }
-}
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java
index 9f6aef56f4c..a95cccfdf58 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionDao.java
@@ -137,9 +137,9 @@ public class GroupPermissionDao implements Dao {
    * Delete all the permissions associated to a root component (project)
    */
   public void deleteByRootComponentUuid(DbSession dbSession, ComponentDto component) {
-    mapper(dbSession).deleteByRootComponentUuid(component.uuid());
+    int deletedRecords = mapper(dbSession).deleteByRootComponentUuid(component.uuid());
 
-    if (auditPersister != null) {
+    if (deletedRecords > 0 && auditPersister != null) {
       auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(null, null, null, component.uuid(), component.name(),
         component.qualifier(), null));
     }
@@ -152,7 +152,7 @@ public class GroupPermissionDao implements Dao {
   public int deleteByRootComponentUuidAndGroupUuid(DbSession dbSession, @Nullable String groupUuid, ComponentDto component) {
     int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(component.uuid(), groupUuid);
 
-    if (auditPersister != null) {
+    if (deletedRecords > 0 && auditPersister != null) {
       auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(null, groupUuid, "", component.uuid(), component.name(),
         component.qualifier(), null));
     }
@@ -162,7 +162,7 @@ public class GroupPermissionDao implements Dao {
   public int deleteByRootComponentUuidForAnyOne(DbSession dbSession, ComponentDto component) {
     int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndGroupUuid(component.uuid(), null);
 
-    if (auditPersister != null) {
+    if (deletedRecords > 0 && auditPersister != null) {
       auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(null, null, null, component.uuid(),
         component.name(), component.qualifier(), null));
     }
@@ -176,7 +176,7 @@ public class GroupPermissionDao implements Dao {
   public int deleteByRootComponentUuidAndPermission(DbSession dbSession, String permission, ComponentDto component) {
     int deletedRecords = mapper(dbSession).deleteByRootComponentUuidAndPermission(component.uuid(), permission);
 
-    if (auditPersister != null) {
+    if (deletedRecords > 0 && auditPersister != null) {
       auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(permission, null, null, component.uuid(),
         component.name(), component.qualifier(), null));
     }
@@ -201,9 +201,9 @@ public class GroupPermissionDao implements Dao {
   public void delete(DbSession dbSession, String permission,
     @Nullable String groupUuid, @Nullable String groupName, @Nullable String rootComponentUuid, @Nullable ComponentDto componentDto) {
 
-    mapper(dbSession).delete(permission, groupUuid, rootComponentUuid);
+    int deletedRecords = mapper(dbSession).delete(permission, groupUuid, rootComponentUuid);
 
-    if (auditPersister != null) {
+    if (deletedRecords > 0 && auditPersister != null) {
       String projectName = (componentDto != null) ? componentDto.name() : null;
       String qualifier = (componentDto != null) ? componentDto.qualifier() : null;
       auditPersister.deleteGroupPermission(dbSession, new PermissionNewValue(permission, groupUuid, groupName, rootComponentUuid,
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java
index 86f3c47c394..441a514c0e3 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/GroupPermissionMapper.java
@@ -39,7 +39,7 @@ public interface GroupPermissionMapper {
 
   void insert(GroupPermissionDto dto);
 
-  void delete(@Param("permission") String permission, @Nullable @Param("groupUuid") String groupUuid, @Nullable @Param("rootComponentUuid") String rootComponentUuid);
+  int delete(@Param("permission") String permission, @Nullable @Param("groupUuid") String groupUuid, @Nullable @Param("rootComponentUuid") String rootComponentUuid);
 
   List<String> selectGlobalPermissionsOfGroup(@Nullable @Param("groupUuid") String groupUuid);
 
@@ -54,7 +54,7 @@ public interface GroupPermissionMapper {
    */
   Set<String> selectGroupUuidsWithPermissionOnProjectBut(@Param("projectUuid") String projectUuid, @Param("role") String permission);
 
-  void deleteByRootComponentUuid(@Param("rootComponentUuid") String rootComponentUuid);
+  int deleteByRootComponentUuid(@Param("rootComponentUuid") String rootComponentUuid);
 
   int deleteByRootComponentUuidAndGroupUuid(@Param("rootComponentUuid") String rootComponentUuid, @Nullable @Param("groupUuid") String groupUuid);
 
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionDao.java
index 42661794fbf..94868a08425 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionDao.java
@@ -127,9 +127,9 @@ public class UserPermissionDao implements Dao {
    * Removes a single global permission from user
    */
   public void deleteGlobalPermission(DbSession dbSession, String userUuid, String permission) {
-    mapper(dbSession).deleteGlobalPermission(userUuid, permission);
+    int deletedRows = mapper(dbSession).deleteGlobalPermission(userUuid, permission);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null,
         null, null, null, userUuid));
     }
@@ -139,9 +139,9 @@ public class UserPermissionDao implements Dao {
    * Removes a single project permission from user
    */
   public void deleteProjectPermission(DbSession dbSession, String userUuid, String permission, ComponentDto component) {
-    mapper(dbSession).deleteProjectPermission(userUuid, permission, component.uuid());
+    int deletedRows = mapper(dbSession).deleteProjectPermission(userUuid, permission, component.uuid());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null, component.uuid(),
         component.name(), component.qualifier(), userUuid));
     }
@@ -151,9 +151,9 @@ public class UserPermissionDao implements Dao {
    * Deletes all the permissions defined on a project
    */
   public void deleteProjectPermissions(DbSession dbSession, ComponentDto component) {
-    mapper(dbSession).deleteProjectPermissions(component.uuid());
+    int deletedRows = mapper(dbSession).deleteProjectPermissions(component.uuid());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(null, null, null, component.uuid(), component.name(),
         component.qualifier(), null));
     }
@@ -165,7 +165,7 @@ public class UserPermissionDao implements Dao {
   public int deleteProjectPermissionOfAnyUser(DbSession dbSession, String permission, ComponentDto project) {
     int deletedRows = mapper(dbSession).deleteProjectPermissionOfAnyUser(project.uuid(), permission);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(permission, null, null, project.uuid(), project.name(),
         project.qualifier(), null));
     }
@@ -174,9 +174,9 @@ public class UserPermissionDao implements Dao {
   }
 
   public void deleteByUserUuid(DbSession dbSession, String userUuid) {
-    mapper(dbSession).deleteByUserUuid(userUuid);
+    int deletedRows = mapper(dbSession).deleteByUserUuid(userUuid);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserPermission(dbSession, new PermissionNewValue(null, null, null, null,
         null, null, userUuid));
     }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionMapper.java
index 6ac031ecf21..26e06af5e6e 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/UserPermissionMapper.java
@@ -54,12 +54,12 @@ public interface UserPermissionMapper {
 
   void insert(@Param("dto")UserPermissionDto dto);
 
-  void deleteGlobalPermission(@Param("userUuid") String userUuid, @Param("permission") String permission);
+  int deleteGlobalPermission(@Param("userUuid") String userUuid, @Param("permission") String permission);
 
-  void deleteProjectPermission(@Param("userUuid") String userUuid, @Param("permission") String permission,
+  int deleteProjectPermission(@Param("userUuid") String userUuid, @Param("permission") String permission,
     @Param("projectUuid") String projectUuid);
 
-  void deleteProjectPermissions(@Param("projectUuid") String projectUuid);
+  int deleteProjectPermissions(@Param("projectUuid") String projectUuid);
 
   int deleteProjectPermissionOfAnyUser(@Param("projectUuid") String projectUuid, @Param("permission") String permission);
 
@@ -67,5 +67,5 @@ public interface UserPermissionMapper {
 
   List<String> selectProjectPermissionsOfUser(@Param("userUuid") String userUuid, @Param("projectUuid") String projectUuid);
 
-  void deleteByUserUuid(@Param("userUuid") String userUuid);
+  int deleteByUserUuid(@Param("userUuid") String userUuid);
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java
index 8bf9c63f846..4aa396f4456 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateDao.java
@@ -170,9 +170,9 @@ public class PermissionTemplateDao implements Dao {
     mapper.deleteUserPermissionsByTemplateUuid(templateUuid);
     mapper.deleteGroupPermissionsByTemplateUuid(templateUuid);
     session.getMapper(PermissionTemplateCharacteristicMapper.class).deleteByTemplateUuid(templateUuid);
-    mapper.deleteByUuid(templateUuid);
+    int deletedRows = mapper.deleteByUuid(templateUuid);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deletePermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName));
     }
   }
@@ -211,9 +211,9 @@ public class PermissionTemplateDao implements Dao {
       .setTemplateUuid(templateUuid)
       .setPermission(permission)
       .setUserUuid(userUuid);
-    mapper(session).deleteUserPermission(permissionTemplateUser);
+    int deletedRows = mapper(session).deleteUserPermission(permissionTemplateUser);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserFromPermissionTemplate(session, new PermissionTemplateNewValue(templateUuid, templateName,
         permission, userUuid, userLogin, null, null));
     }
@@ -222,9 +222,9 @@ public class PermissionTemplateDao implements Dao {
   }
 
   public void deleteUserPermissionsByUserUuid(DbSession dbSession, String userUuid, String userLogin) {
-    mapper(dbSession).deleteUserPermissionsByUserUuid(userUuid);
+    int deletedRows = mapper(dbSession).deleteUserPermissionsByUserUuid(userUuid);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserFromPermissionTemplate(dbSession, new PermissionTemplateNewValue(null, null,
         null, userUuid, userLogin, null, null));
     }
@@ -262,9 +262,9 @@ public class PermissionTemplateDao implements Dao {
       .setTemplateUuid(templateUuid)
       .setPermission(permission)
       .setGroupUuid(groupUuid);
-    mapper(session).deleteGroupPermission(permissionTemplateGroup);
+    int deletedRows = mapper(session).deleteGroupPermission(permissionTemplateGroup);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteGroupFromPermissionTemplate(session, new PermissionTemplateNewValue(permissionTemplateGroup.getTemplateUuid(), templateName,
         permissionTemplateGroup.getPermission(), null, null, permissionTemplateGroup.getGroupUuid(), groupName));
     }
@@ -284,9 +284,9 @@ public class PermissionTemplateDao implements Dao {
    * Remove a group from all templates (used when removing a group)
    */
   public void deleteByGroup(DbSession session, String groupUuid, String groupName) {
-    session.getMapper(PermissionTemplateMapper.class).deleteByGroupUuid(groupUuid);
+    int deletedRows = session.getMapper(PermissionTemplateMapper.class).deleteByGroupUuid(groupUuid);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteGroupFromPermissionTemplate(session, new PermissionTemplateNewValue(null, null,
         null, null, null, groupUuid, groupName));
     }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java
index 4e653b35773..4f9373724d0 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/permission/template/PermissionTemplateMapper.java
@@ -36,7 +36,7 @@ public interface PermissionTemplateMapper {
 
   void update(PermissionTemplateDto permissionTemplate);
 
-  void deleteByUuid(String templateUuid);
+  int deleteByUuid(String templateUuid);
 
   void deleteByUuids(@Param("templateUuids") List<String> templateUuids);
 
@@ -44,15 +44,15 @@ public interface PermissionTemplateMapper {
 
   void deleteUserPermissionsByTemplateUuids(@Param("templateUuids") List<String> templateUuids);
 
-  void deleteUserPermissionsByUserUuid(@Param("userUuid") String userUuid);
+  int deleteUserPermissionsByUserUuid(@Param("userUuid") String userUuid);
 
-  void deleteUserPermission(PermissionTemplateUserDto permissionTemplateUser);
+  int deleteUserPermission(PermissionTemplateUserDto permissionTemplateUser);
 
   void deleteGroupPermissionsByTemplateUuid(String templateUuid);
 
   void deleteGroupPermissionsByTemplateUuids(@Param("templateUuids") List<String> templateUuids);
 
-  void deleteGroupPermission(PermissionTemplateGroupDto permissionTemplateGroup);
+  int deleteGroupPermission(PermissionTemplateGroupDto permissionTemplateGroup);
 
   PermissionTemplateDto selectByUuid(String templateUuid);
 
@@ -64,7 +64,7 @@ public interface PermissionTemplateMapper {
 
   void insertGroupPermission(PermissionTemplateGroupDto permissionTemplateGroup);
 
-  void deleteByGroupUuid(String groupUuid);
+  int deleteByGroupUuid(String groupUuid);
 
   PermissionTemplateDto selectByName(@Param("name") String name);
 
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/project/ProjectDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/project/ProjectDao.java
index 50ea889d17d..45a32cc1906 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/project/ProjectDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/project/ProjectDao.java
@@ -103,7 +103,7 @@ public class ProjectDao implements Dao {
     return mapper(session).selectByUuids(uuids);
   }
 
-  public void updateVisibility(DbSession session, String uuid, boolean isPrivate, String qualifier, String name) {
+  public void updateVisibility(DbSession session, String uuid, boolean isPrivate) {
     mapper(session).updateVisibility(uuid, isPrivate, system2.now());
   }
 
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesDao.java
index 29028f2c6fb..ab1fa9fa6cb 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesDao.java
@@ -263,7 +263,7 @@ public class PropertiesDao implements Dao {
   public int deleteByQuery(DbSession dbSession, PropertyQuery query) {
     int deletedRows = getMapper(dbSession).deleteByQuery(query);
 
-    if (auditPersister != null && query.key() != null && auditPersister.isTrackedProperty(query.key())) {
+    if (deletedRows > 0 && auditPersister != null && query.key() != null && auditPersister.isTrackedProperty(query.key())) {
       auditPersister.deleteProperty(dbSession, new PropertyNewValue(query.key(), query.componentUuid(),
         null, null, query.userUuid()), false);
     }
@@ -274,7 +274,7 @@ public class PropertiesDao implements Dao {
   public int delete(DbSession dbSession, PropertyDto dto, @Nullable String userLogin, @Nullable String projectName, @Nullable String qualifier) {
     int deletedRows = getMapper(dbSession).delete(dto.getKey(), dto.getUserUuid(), dto.getComponentUuid());
 
-    if (auditPersister != null && auditPersister.isTrackedProperty(dto.getKey())) {
+    if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(dto.getKey())) {
       auditPersister.deleteProperty(dbSession, new PropertyNewValue(dto, userLogin, projectName, qualifier), false);
     }
     return deletedRows;
@@ -288,18 +288,18 @@ public class PropertiesDao implements Dao {
   }
 
   public void deleteProjectProperty(DbSession session, String key, String projectUuid, String projectName, String qualifier) {
-    getMapper(session).deleteProjectProperty(key, projectUuid);
+    int deletedRows = getMapper(session).deleteProjectProperty(key, projectUuid);
 
-    if (auditPersister != null && auditPersister.isTrackedProperty(key)) {
+    if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) {
       auditPersister.deleteProperty(session, new PropertyNewValue(key, projectUuid, projectName, qualifier,
         null), false);
     }
   }
 
   public void deleteProjectProperties(String key, String value, DbSession session) {
-    getMapper(session).deleteProjectProperties(key, value);
+    int deletedRows = getMapper(session).deleteProjectProperties(key, value);
 
-    if (auditPersister != null && auditPersister.isTrackedProperty(key)) {
+    if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) {
       auditPersister.deleteProperty(session, new PropertyNewValue(key, value), false);
     }
   }
@@ -312,9 +312,9 @@ public class PropertiesDao implements Dao {
   }
 
   public void deleteGlobalProperty(String key, DbSession session) {
-    getMapper(session).deleteGlobalProperty(key);
+    int deletedRows = getMapper(session).deleteGlobalProperty(key);
 
-    if (auditPersister != null && auditPersister.isTrackedProperty(key)) {
+    if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) {
       auditPersister.deleteProperty(session, new PropertyNewValue(key), false);
     }
   }
@@ -343,9 +343,9 @@ public class PropertiesDao implements Dao {
   }
 
   public void deleteByKeyAndValue(DbSession dbSession, String key, String value) {
-    getMapper(dbSession).deleteByKeyAndValue(key, value);
+    int deletedRows = getMapper(dbSession).deleteByKeyAndValue(key, value);
 
-    if (auditPersister != null && auditPersister.isTrackedProperty(key)) {
+    if (deletedRows > 0 && auditPersister != null && auditPersister.isTrackedProperty(key)) {
       auditPersister.deleteProperty(dbSession, new PropertyNewValue(key, value), false);
     }
   }
@@ -382,7 +382,7 @@ public class PropertiesDao implements Dao {
   }
 
   private void persistDeletedProperties(DbSession dbSession, @Nullable String userUuid, String userLogin, List<String> uuids) {
-    if (auditPersister != null) {
+    if (!uuids.isEmpty() && auditPersister != null) {
       List<PropertyDto> properties = executeLargeInputs(uuids, subList -> getMapper(dbSession).selectByUuids(subList));
 
       properties
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesMapper.java
index b3ea7429be5..e0b1f18b644 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/property/PropertiesMapper.java
@@ -75,7 +75,7 @@ public interface PropertiesMapper {
 
   void deleteByUuids(@Param("uuids") List<String> uuids);
 
-  void deleteByKeyAndValue(@Param("key") String key, @Param("value") String value);
+  int deleteByKeyAndValue(@Param("key") String key, @Param("value") String value);
 
   List<PropertyDto> selectByUuids(@Param("uuids") List<String> uuids);
 
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java
index 80b1c7dad4e..20e39b9357c 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupDao.java
@@ -75,9 +75,9 @@ public class GroupDao implements Dao {
   }
 
   public void deleteByUuid(DbSession dbSession, String groupUuid, String groupName) {
-    mapper(dbSession).deleteByUuid(groupUuid);
+    int deletedRows = mapper(dbSession).deleteByUuid(groupUuid);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserGroup(dbSession, new UserGroupNewValue(groupUuid, groupName));
     }
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMapper.java
index 7caed9add90..820a043deee 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/GroupMapper.java
@@ -42,7 +42,7 @@ public interface GroupMapper {
 
   int countByQuery(@Nullable @Param("query") String query);
 
-  void deleteByUuid(String groupUuid);
+  int deleteByUuid(String groupUuid);
 
   @CheckForNull
   GroupDto selectByName(@Param("name") String name);
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java
index 1c1a3cf2a90..7c7bf915947 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupDao.java
@@ -51,25 +51,25 @@ public class UserGroupDao implements Dao {
   }
 
   public void delete(DbSession session, GroupDto group, UserDto user) {
-    mapper(session).delete(group.getUuid(), user.getUuid());
+    int deletedRows = mapper(session).delete(group.getUuid(), user.getUuid());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserFromGroup(session, new UserGroupNewValue(group, user));
     }
   }
 
   public void deleteByGroupUuid(DbSession session, String groupUuid, String groupName) {
-    mapper(session).deleteByGroupUuid(groupUuid);
+    int deletedRows = mapper(session).deleteByGroupUuid(groupUuid);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserFromGroup(session, new UserGroupNewValue(groupUuid, groupName));
     }
   }
 
   public void deleteByUserUuid(DbSession dbSession, UserDto userDto) {
-    mapper(dbSession).deleteByUserUuid(userDto.getUuid());
+    int deletedRows = mapper(dbSession).deleteByUserUuid(userDto.getUuid());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserFromGroup(dbSession, new UserGroupNewValue(userDto));
     }
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupMapper.java
index 763cb53de90..903932ed75e 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserGroupMapper.java
@@ -28,9 +28,9 @@ public interface UserGroupMapper {
 
   Set<String> selectUserUuidsInGroup(@Param("groupUuid") String groupUuid);
 
-  void delete(@Param("groupUuid") String groupUuid, @Param("userUuid") String userUuid);
+  int delete(@Param("groupUuid") String groupUuid, @Param("userUuid") String userUuid);
 
-  void deleteByGroupUuid(@Param("groupUuid") String groupUuid);
+  int deleteByGroupUuid(@Param("groupUuid") String groupUuid);
 
-  void deleteByUserUuid(@Param("userUuid") String userUuid);
+  int deleteByUserUuid(@Param("userUuid") String userUuid);
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesDao.java
index e42c92540d9..01080f163be 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesDao.java
@@ -70,9 +70,9 @@ public class UserPropertiesDao implements Dao {
 
   public void deleteByUser(DbSession session, UserDto user) {
     List<UserPropertyDto> userProperties = selectByUser(session, user);
-    mapper(session).deleteByUserUuid(user.getUuid());
+    int deletedRows = mapper(session).deleteByUserUuid(user.getUuid());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       userProperties.stream()
         .filter(p -> auditPersister.isTrackedProperty(p.getKey()))
         .forEach(p -> auditPersister.deleteProperty(session, new PropertyNewValue(p, user.getLogin()), true));
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesMapper.java
index b933b4a3352..87fcfe5a9d9 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserPropertiesMapper.java
@@ -30,6 +30,6 @@ public interface UserPropertiesMapper {
 
   int update(@Param("userProperty") UserPropertyDto userPropertyDto, @Param("now") long now);
 
-  void deleteByUserUuid(@Param("userUuid") String userUuid);
+  int deleteByUserUuid(@Param("userUuid") String userUuid);
 
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenDao.java
index ed4053f92a6..11165f9fd55 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenDao.java
@@ -99,17 +99,17 @@ public class UserTokenDao implements Dao {
   }
 
   public void deleteByUser(DbSession dbSession, UserDto user) {
-    mapper(dbSession).deleteByUserUuid(user.getUuid());
+    int deletedRows = mapper(dbSession).deleteByUserUuid(user.getUuid());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserToken(dbSession, new UserTokenNewValue(user));
     }
   }
 
   public void deleteByUserAndName(DbSession dbSession, UserDto user, String name) {
-    mapper(dbSession).deleteByUserUuidAndName(user.getUuid(), name);
+    int deletedRows = mapper(dbSession).deleteByUserUuidAndName(user.getUuid(), name);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteUserToken(dbSession, new UserTokenNewValue(user, name));
     }
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenMapper.java
index 88337ab6fc6..888456fd153 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/user/UserTokenMapper.java
@@ -34,9 +34,9 @@ public interface UserTokenMapper {
 
   List<UserTokenDto> selectByUserUuid(String userUuid);
 
-  void deleteByUserUuid(String userUuid);
+  int deleteByUserUuid(String userUuid);
 
-  void deleteByUserUuidAndName(@Param("userUuid") String userUuid, @Param("name") String name);
+  int deleteByUserUuidAndName(@Param("userUuid") String userUuid, @Param("name") String name);
 
   List<UserTokenCount> countTokensByUserUuids(@Param("userUuids") List<String> userUuids);
 }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookDao.java b/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookDao.java
index 7d906aec2fa..088e35f478a 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookDao.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookDao.java
@@ -73,17 +73,17 @@ public class WebhookDao implements Dao {
   }
 
   public void delete(DbSession dbSession, String uuid, String webhookName) {
-    mapper(dbSession).delete(uuid);
+    int deletedRows = mapper(dbSession).delete(uuid);
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteWebhook(dbSession, new WebhookNewValue(uuid, webhookName));
     }
   }
 
   public void deleteByProject(DbSession dbSession, ProjectDto projectDto) {
-    mapper(dbSession).deleteForProjectUuid(projectDto.getUuid());
+    int deletedRows = mapper(dbSession).deleteForProjectUuid(projectDto.getUuid());
 
-    if (auditPersister != null) {
+    if (deletedRows > 0 && auditPersister != null) {
       auditPersister.deleteWebhook(dbSession, new WebhookNewValue(projectDto));
     }
   }
diff --git a/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookMapper.java b/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookMapper.java
index dbf24214302..4d7547ab398 100644
--- a/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookMapper.java
+++ b/server/sonar-db-dao/src/main/java/org/sonar/db/webhook/WebhookMapper.java
@@ -36,7 +36,7 @@ public interface WebhookMapper {
 
   void update(WebhookDto dto);
 
-  void delete(@Param("uuid") String uuid);
+  int delete(@Param("uuid") String uuid);
 
-  void deleteForProjectUuid(@Param("projectUuid") String projectUuid);
+  int deleteForProjectUuid(@Param("projectUuid") String projectUuid);
 }
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoWithPersisterTest.java
index db5c075f1f0..73a736e5e3d 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/pat/AlmPatDaoWithPersisterTest.java
@@ -32,9 +32,12 @@ import org.sonar.db.audit.model.PersonalAccessTokenNewValue;
 import org.sonar.db.user.UserDto;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 import static org.sonar.db.alm.integration.pat.AlmPatsTesting.newAlmPatDto;
 
@@ -100,6 +103,15 @@ public class AlmPatDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteWithoutAffectedRowsIsNotPersisted() {
+    AlmPatDto almPat = newAlmPatDto();
+
+    underTest.delete(dbSession, almPat, null, null);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteByUserIsPersisted() {
     when(uuidFactory.create()).thenReturn(A_UUID);
     UserDto userDto = db.users().insertUser();
@@ -120,6 +132,16 @@ public class AlmPatDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteByUserWithoutAffectedRowsIsNotPersisted() {
+    UserDto userDto = db.users().insertUser();
+
+    underTest.deleteByUser(dbSession, userDto);
+
+    verify(auditPersister).addUser(any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteByAlmSettingIsPersisted() {
     when(uuidFactory.create()).thenReturn(A_UUID);
     AlmSettingDto almSettingDto = db.almSettings().insertBitbucketAlmSetting();
@@ -139,4 +161,13 @@ public class AlmPatDaoWithPersisterTest {
     assertThat(newValue.toString()).doesNotContain("userUuid");
   }
 
+  @Test
+  public void deleteByAlmSettingWithoutAffectedRowsIsNotPersisted() {
+    AlmSettingDto almSettingDto = db.almSettings().insertBitbucketAlmSetting();
+
+    underTest.deleteByAlmSetting(dbSession, almSettingDto);
+
+    verifyNoInteractions(auditPersister);
+  }
+
 }
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoWithPersisterTest.java
index 1d33930bd2e..cb1bc266a1a 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/alm/setting/ProjectAlmSettingDaoWithPersisterTest.java
@@ -31,10 +31,12 @@ import org.sonar.db.audit.model.DevOpsPlatformSettingNewValue;
 import org.sonar.db.project.ProjectDto;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 import static org.sonar.db.almsettings.AlmSettingsTesting.newGithubProjectAlmSettingDto;
 
@@ -91,7 +93,7 @@ public class ProjectAlmSettingDaoWithPersisterTest {
   }
 
   @Test
-  public void deleteByProject() {
+  public void deleteByProjectIsPersisted() {
     when(uuidFactory.create()).thenReturn(A_UUID);
     AlmSettingDto githubAlmSetting = db.almSettings().insertGitHubAlmSetting();
     ProjectDto project = db.components().insertPrivateProjectDto();
@@ -109,7 +111,17 @@ public class ProjectAlmSettingDaoWithPersisterTest {
   }
 
   @Test
-  public void deleteByAlmSettingNotTracked() {
+  public void deleteByWithoutAffectedRowsProjectIsNotPersisted() {
+    ProjectDto project = db.components().insertPrivateProjectDto();
+
+    underTest.deleteByProject(dbSession, project);
+
+    verify(auditPersister).addComponent(any(), any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
+  public void deleteByAlmSettingNotTrackedIsNotPersisted() {
     AlmSettingDto githubAlmSetting = db.almSettings().insertGitHubAlmSetting();
     underTest.deleteByAlmSetting(dbSession, githubAlmSetting);
 
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/audit/model/ProjectNewValueTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/audit/model/ProjectNewValueTest.java
deleted file mode 100644
index 45735b4ae3d..00000000000
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/audit/model/ProjectNewValueTest.java
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * SonarQube
- * Copyright (C) 2009-2021 SonarSource SA
- * mailto:info AT sonarsource DOT com
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-package org.sonar.db.audit.model;
-
-import org.json.simple.JSONObject;
-import org.json.simple.parser.JSONParser;
-import org.json.simple.parser.ParseException;
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class ProjectNewValueTest {
-
-  @Test
-  public void toString_generatesValidJson() throws ParseException {
-    ProjectNewValue newValue = new ProjectNewValue("uuid", true, "name", "description");
-
-    JSONObject jsonObject = (JSONObject) new JSONParser().parse(newValue.toString());
-
-    assertThat(jsonObject.size()).isEqualTo(4);
-  }
-
-}
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterTest.java
index 94c5311e916..4760eb99eda 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/GroupPermissionDaoWithPersisterTest.java
@@ -32,9 +32,12 @@ import org.sonar.db.component.ComponentDto;
 import org.sonar.db.user.GroupDto;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.sonar.api.web.UserRole.ADMIN;
 
 public class GroupPermissionDaoWithPersisterTest {
@@ -79,6 +82,13 @@ public class GroupPermissionDaoWithPersisterTest {
   }
 
   @Test
+  public void groupGlobalPermissionDeleteWithoutAffectedRowsIsNotPersisted() {
+    underTest.delete(dbSession, ADMIN, "group-uuid", "group-name", null, null);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void groupProjectPermissionDeleteByComponentIsPersisted() {
     GroupDto group = db.users().insertGroup();
     ComponentDto project = db.components().insertPrivateProject();
@@ -107,10 +117,20 @@ public class GroupPermissionDaoWithPersisterTest {
   }
 
   @Test
+  public void groupProjectPermissionDeleteByComponentWithoutAffectedRowsIsNotPersisted() {
+    ComponentDto project = db.components().insertPrivateProject();
+
+    underTest.deleteByRootComponentUuid(dbSession, project);
+
+    verify(auditPersister).addComponent(any(), any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
   public void groupProjectPermissionDeleteByComponentAndGroupIsPersisted() {
     GroupDto group = db.users().insertGroup();
     ComponentDto project = db.components().insertPrivateProject();
-    GroupPermissionDto dto = getGroupPermission(group, project);
+    GroupPermissionDto dto = getGroupPermission(project);
     underTest.insert(dbSession, dto, project);
 
     verify(auditPersister).addGroupPermission(eq(dbSession), newValueCaptor.capture());
@@ -119,7 +139,7 @@ public class GroupPermissionDaoWithPersisterTest {
       .extracting(PermissionNewValue::getPermissionUuid, PermissionNewValue::getGroupUuid,
         PermissionNewValue::getGroupName, PermissionNewValue::getComponentUuid,
         PermissionNewValue::getRole, PermissionNewValue::getComponentName, PermissionNewValue::getQualifier)
-      .containsExactly(dto.getUuid(), group.getUuid(), group.getName(), project.uuid(), dto.getRole(), project.name(), "project");
+      .containsExactly(dto.getUuid(), null, null, project.uuid(), dto.getRole(), project.name(), "project");
     assertThat(newValue.toString()).contains("componentUuid");
 
     underTest.deleteByRootComponentUuidForAnyOne(dbSession, project);
@@ -135,6 +155,16 @@ public class GroupPermissionDaoWithPersisterTest {
   }
 
   @Test
+  public void groupProjectPermissionDeleteByComponentAndGroupWithoutAffectedRowsIsNotPersisted() {
+    ComponentDto project = db.components().insertPrivateProject();
+
+    underTest.deleteByRootComponentUuidForAnyOne(dbSession, project);
+
+    verify(auditPersister).addComponent(any(), any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
   public void groupProjectPermissionDeleteByComponentAndPermissionIsPersisted() {
     GroupDto group = db.users().insertGroup();
     ComponentDto project = db.components().insertPrivateProject();
@@ -161,6 +191,18 @@ public class GroupPermissionDaoWithPersisterTest {
     assertThat(newValue.toString()).doesNotContain("permissionUuid");
   }
 
+  @Test
+  public void groupProjectPermissionDeleteByComponentAndPermissionWithoutAffectedRowsIsNotPersisted() {
+    GroupDto group = db.users().insertGroup();
+    ComponentDto project = db.components().insertPrivateProject();
+    GroupPermissionDto dto = getGroupPermission(group, project);
+
+    underTest.deleteByRootComponentUuidAndPermission(dbSession, dto.getRole(), project);
+
+    verify(auditPersister).addComponent(any(), any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
   private GroupPermissionDto getGroupPermission(GroupDto group, ComponentDto project) {
     return new GroupPermissionDto()
       .setUuid(Uuids.createFast())
@@ -170,4 +212,12 @@ public class GroupPermissionDaoWithPersisterTest {
       .setComponentUuid(project.uuid())
       .setComponentName(project.name());
   }
+
+  private GroupPermissionDto getGroupPermission(ComponentDto project) {
+    return new GroupPermissionDto()
+      .setUuid(Uuids.createFast())
+      .setRole(ADMIN)
+      .setComponentUuid(project.uuid())
+      .setComponentName(project.name());
+  }
 }
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoWithPersisterTest.java
index dbbfd2c85e6..c6ff53983fb 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/UserPermissionDaoWithPersisterTest.java
@@ -33,9 +33,11 @@ import org.sonar.db.component.ComponentDto;
 import org.sonar.db.user.UserDto;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.sonar.core.permission.GlobalPermissions.SCAN_EXECUTION;
 import static org.sonar.core.permission.GlobalPermissions.SYSTEM_ADMIN;
 
@@ -75,6 +77,16 @@ public class UserPermissionDaoWithPersisterTest {
   }
 
   @Test
+  public void userGlobalPermissionDeleteWithoutAffectedRowsIsNotPersisted() {
+    UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com"));
+
+    underTest.deleteGlobalPermission(dbSession, user.getUuid(), SYSTEM_ADMIN);
+
+    verify(auditPersister).addUser(any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
   public void userProjectPermissionInsertAndDeleteArePersisted() {
     UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com"));
     ComponentDto project = db.components().insertPrivateProject();
@@ -102,6 +114,18 @@ public class UserPermissionDaoWithPersisterTest {
   }
 
   @Test
+  public void userProjectPermissionDeleteWithoutAffectedRowsIsNotPersisted() {
+    UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com"));
+    ComponentDto project = db.components().insertPrivateProject();
+
+    underTest.deleteProjectPermission(dbSession, user.getUuid(), SYSTEM_ADMIN, project);
+
+    verify(auditPersister).addUser(any(), any());
+    verify(auditPersister).addComponent(any(), any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
   public void userPortfolioPermissionIsPersisted() {
     UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com"));
     ComponentDto portfolio = db.components().insertPublicPortfolio();
@@ -153,6 +177,16 @@ public class UserPermissionDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteUserPermissionOfAnyUserWithoutAffectedRowsIsNotPersisted() {
+    ComponentDto project = db.components().insertPrivateProject();
+
+    underTest.deleteProjectPermissionOfAnyUser(dbSession, SCAN_EXECUTION, project);
+
+    verify(auditPersister).addComponent(any(), any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteUserPermissionByUserUuidIsPersisted() {
     UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com"));
     ComponentDto project = db.components().insertPrivateProject();
@@ -169,6 +203,16 @@ public class UserPermissionDaoWithPersisterTest {
     assertThat(newValue.toString()).contains("userUuid");
   }
 
+  @Test
+  public void deleteUserPermissionByUserUuidWithoutAffectedRowsIsNotPersisted() {
+    UserDto user = insertUser(u -> u.setLogin("login1").setName("Marius").setEmail("email1@email.com"));
+
+    underTest.deleteByUserUuid(dbSession, user.getUuid());
+
+    verify(auditPersister).addUser(any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
   private UserDto insertUser(Consumer<UserDto> populateUserDto) {
     UserDto user = db.users().insertUser(populateUserDto);
     return user;
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoWithPersisterTest.java
index fe5d845c557..4a2182eb9a1 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/permission/template/PermissionTemplateDaoWithPersisterTest.java
@@ -35,6 +35,7 @@ import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.sonar.api.web.UserRole.ADMIN;
 import static org.sonar.db.permission.template.PermissionTemplateTesting.newPermissionTemplateDto;
 import static org.sonar.db.user.GroupTesting.newGroupDto;
@@ -92,6 +93,13 @@ public class PermissionTemplateDaoWithPersisterTest {
   }
 
   @Test
+  public void deletePermissionTemplateWithoutAffectedRowsIsPersisted() {
+    underTest.deleteByUuid(session, "template-uuid", "template-name");
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void insertAndDeleteUserPermissionToTemplateIsPersisted() {
     PermissionTemplateDto dto = insertPermissionTemplate();
     UserDto user = db.users().insertUser();
@@ -117,6 +125,14 @@ public class PermissionTemplateDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteUserPermissionToTemplateWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteUserPermission(session, "template-uuid", "user-uuid", ADMIN,
+      "template-name", "user-login");
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void insertAndDeleteUserPermissionByUserUuidToTemplateIsPersisted() {
     PermissionTemplateDto dto = insertPermissionTemplate();
     UserDto user = db.users().insertUser();
@@ -133,6 +149,13 @@ public class PermissionTemplateDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteUserPermissionByUserUuidToTemplateWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteUserPermissionsByUserUuid(session, "user-uuid", "user-login");
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void insertAndDeleteGroupPermissionToTemplateIsPersisted() {
     PermissionTemplateDto dto = insertPermissionTemplate();
     GroupDto group = db.users().insertGroup(newGroupDto());
@@ -158,11 +181,20 @@ public class PermissionTemplateDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteGroupPermissionToTemplateWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteGroupPermission(session, "template-uuid", "group-uuid", ADMIN,
+      "template-name", "group-name");
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void insertAndDeleteGroupPermissionByGroupUuidToTemplateIsPersisted() {
     PermissionTemplateDto templateDto = insertPermissionTemplate();
     PermissionTemplateGroupDto templateGroupDto = new PermissionTemplateGroupDto()
       .setUuid(Uuids.createFast())
       .setGroupName("group")
+      .setGroupUuid("group-id")
       .setPermission(ADMIN)
       .setTemplateUuid(templateDto.getUuid())
       .setCreatedAt(new Date())
@@ -188,6 +220,13 @@ public class PermissionTemplateDaoWithPersisterTest {
     assertThat(newValue.toString()).doesNotContain("userUuid");
   }
 
+  @Test
+  public void deleteGroupPermissionByGroupUuidToTemplateWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteByGroup(session, "group-uid", "group-name");
+
+    verifyNoInteractions(auditPersister);
+  }
+
   private PermissionTemplateDto insertPermissionTemplate() {
     return underTest.insert(session, newPermissionTemplateDto()
       .setUuid("ABCD")
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/project/ProjectDaoTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/project/ProjectDaoTest.java
index b42ba5d0083..62a3d921d5b 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/project/ProjectDaoTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/project/ProjectDaoTest.java
@@ -19,6 +19,12 @@
  */
 package org.sonar.db.project;
 
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import javax.annotation.Nullable;
 import org.junit.Rule;
 import org.junit.Test;
 import org.sonar.api.impl.utils.AlwaysIncreasingSystem2;
@@ -30,17 +36,10 @@ import org.sonar.db.audit.AuditPersister;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyNoInteractions;
-import javax.annotation.Nullable;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
 
 public class ProjectDaoTest {
 
@@ -148,8 +147,8 @@ public class ProjectDaoTest {
     assertProject(projectsByUuids.get(0), "projectName_p1", "projectKee_o1_p1",  "uuid_o1_p1", "desc_p1", "tag1,tag2", true);
     assertProject(projectsByUuids.get(1), "projectName_p2", "projectKee_o1_p2",  "uuid_o1_p2", "desc_p2", "tag1,tag2", false);
 
-    projectDao.updateVisibility(db.getSession(), dto1.getUuid(), false, Qualifiers.PROJECT, dto1.getName());
-    projectDao.updateVisibility(db.getSession(), dto2.getUuid(), true, Qualifiers.PROJECT, dto2.getName());
+    projectDao.updateVisibility(db.getSession(), dto1.getUuid(), false);
+    projectDao.updateVisibility(db.getSession(), dto2.getUuid(), true);
 
     projectsByUuids = projectDao.selectByUuids(db.getSession(), new HashSet<>(Arrays.asList("uuid_o1_p1", "uuid_o1_p2")));
     assertThat(projectsByUuids).hasSize(2);
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/property/PropertiesDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/property/PropertiesDaoWithPersisterTest.java
index 26ef4bf051d..e430e2fa07b 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/property/PropertiesDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/property/PropertiesDaoWithPersisterTest.java
@@ -44,6 +44,7 @@ import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
@@ -121,7 +122,7 @@ public class PropertiesDaoWithPersisterTest {
   public void saveProjectTrackedPropertyIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
 
-    PropertyDto propertyDto = getPropertyDto(KEY);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
     underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
 
     verify(auditPersister).isTrackedProperty(KEY);
@@ -140,7 +141,7 @@ public class PropertiesDaoWithPersisterTest {
   public void saveApplicationTrackedPropertyIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
 
-    PropertyDto propertyDto = getPropertyDto(KEY);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
     underTest.saveProperty(session, propertyDto, USER_LOGIN, "app-name", Qualifiers.APP);
 
     verify(auditPersister).isTrackedProperty(KEY);
@@ -160,7 +161,7 @@ public class PropertiesDaoWithPersisterTest {
   public void savePortfolioTrackedPropertyIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
 
-    PropertyDto propertyDto = getPropertyDto(KEY);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
     underTest.saveProperty(session, propertyDto, USER_LOGIN, "portfolio-name", Qualifiers.VIEW);
 
     verify(auditPersister).isTrackedProperty(KEY);
@@ -180,7 +181,7 @@ public class PropertiesDaoWithPersisterTest {
   public void saveProjectTrackedAndSecuredPropertyIsPersisted() {
     when(auditPersister.isTrackedProperty(SECURED_KEY)).thenReturn(true);
 
-    PropertyDto propertyDto = getPropertyDto(SECURED_KEY);
+    PropertyDto propertyDto = getPropertyDto(SECURED_KEY, PROJECT_UUID, USER_UUID);
     underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
 
     verify(auditPersister).isTrackedProperty(SECURED_KEY);
@@ -198,11 +199,13 @@ public class PropertiesDaoWithPersisterTest {
   @Test
   public void deleteTrackedPropertyByQueryIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
-
     PropertyQuery query = getPropertyQuery(KEY);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
+    underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
+
     underTest.deleteByQuery(session, query);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false));
     PropertyNewValue newValue = newValueCaptor.getValue();
     assertThat(newValue)
@@ -215,24 +218,36 @@ public class PropertiesDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteTrackedPropertyByQueryWithoutAffectedRowsIsNotPersisted() {
+    PropertyQuery query = getPropertyQuery(KEY);
+
+    underTest.deleteByQuery(session, query);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteNotTrackedPropertyByQueryIsNotPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(false);
-
     PropertyQuery query = getPropertyQuery(KEY);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
+    underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
+
     underTest.deleteByQuery(session, query);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verifyNoMoreInteractions(auditPersister);
   }
 
   @Test
   public void deleteTrackedPropertyIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
+    underTest.saveProperty(session, propertyDto, USER_LOGIN, null, null);
 
-    PropertyDto propertyDto = getPropertyDto(KEY);
     underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false));
     PropertyNewValue newValue = newValueCaptor.getValue();
     assertThat(newValue)
@@ -245,22 +260,35 @@ public class PropertiesDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteTrackedPropertyWithoutAffectedRowsIsNotPersisted() {
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
+
+    underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteNotTrackedPropertyIsNotPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(false);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
+    underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
 
-    PropertyDto propertyDto = getPropertyDto(KEY);
     underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verifyNoMoreInteractions(auditPersister);
   }
 
   @Test
   public void deleteTrackedProjectPropertyIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, null);
+    underTest.saveProperty(propertyDto);
+
     underTest.deleteProjectProperty(KEY, PROJECT_UUID, PROJECT_NAME, Qualifiers.PROJECT);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false));
     PropertyNewValue newValue = newValueCaptor.getValue();
     assertThat(newValue)
@@ -273,23 +301,33 @@ public class PropertiesDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteTrackedProjectPropertyWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteProjectProperty(KEY, PROJECT_UUID, PROJECT_NAME, Qualifiers.PROJECT);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteNotTrackedProjectPropertyIsNotPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(false);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, USER_UUID);
+    underTest.saveProperty(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
 
-    PropertyDto propertyDto = getPropertyDto(KEY);
     underTest.delete(session, propertyDto, USER_LOGIN, PROJECT_NAME, Qualifiers.PROJECT);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verifyNoMoreInteractions(auditPersister);
   }
 
   @Test
   public void deleteTrackedProjectPropertiesIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, null);
+    underTest.saveProperty(propertyDto);
 
     underTest.deleteProjectProperties(KEY, VALUE);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false));
     PropertyNewValue newValue = newValueCaptor.getValue();
     assertThat(newValue)
@@ -302,22 +340,33 @@ public class PropertiesDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteTrackedProjectPropertiesWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteProjectProperties(KEY, VALUE);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteNotTrackedProjectPropertiesIsNotPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(false);
+    PropertyDto propertyDto = getPropertyDto(KEY, PROJECT_UUID, null);
+    underTest.saveProperty(propertyDto);
 
     underTest.deleteProjectProperties(KEY, VALUE);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verifyNoMoreInteractions(auditPersister);
   }
 
   @Test
   public void deleteTrackedGlobalPropertyIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
+    PropertyDto propertyDto = getPropertyDto(KEY, null, null);
+    underTest.saveProperty(session, propertyDto, null, null, null);
 
     underTest.deleteGlobalProperty(KEY, session);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false));
     PropertyNewValue newValue = newValueCaptor.getValue();
     assertThat(newValue)
@@ -330,12 +379,21 @@ public class PropertiesDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteTrackedGlobalPropertyWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteGlobalProperty(KEY, session);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteNotTrackedGlobalPropertyIsNotPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(false);
+    PropertyDto propertyDto = getPropertyDto(KEY, null, null);
+    underTest.saveProperty(session, propertyDto, null, null, null);
 
     underTest.deleteGlobalProperty(KEY, session);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verifyNoMoreInteractions(auditPersister);
   }
 
@@ -366,6 +424,13 @@ public class PropertiesDaoWithPersisterTest {
   }
 
   @Test
+  public void deletePropertyByUserWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteByUser(session, USER_UUID, USER_LOGIN);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deletePropertyByUserLoginIsPersisted() {
     UserDto user = setUserProperties(null);
     underTest.deleteByMatchingLogin(session, user.getLogin(), newArrayList(KEY, ANOTHER_KEY, SECURED_KEY));
@@ -392,12 +457,21 @@ public class PropertiesDaoWithPersisterTest {
   }
 
   @Test
+  public void deletePropertyByUserLoginWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteByMatchingLogin(session, USER_LOGIN, newArrayList(KEY, ANOTHER_KEY, SECURED_KEY));
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteTrackedPropertyByKeyAndValueIsPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(true);
 
+    PropertyDto propertyDto = getPropertyDto(KEY, null, USER_UUID);
+    underTest.saveProperty(session, propertyDto, USER_LOGIN, null, null);
     underTest.deleteByKeyAndValue(session, KEY, VALUE);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verify(auditPersister).deleteProperty(any(), newValueCaptor.capture(), eq(false));
     PropertyNewValue newValue = newValueCaptor.getValue();
     assertThat(newValue)
@@ -410,21 +484,30 @@ public class PropertiesDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteTrackedPropertyByKeyAndValueWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteByKeyAndValue(session, KEY, VALUE);
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteNotTrackedPropertyByKeyAndValueIsNotPersisted() {
     when(auditPersister.isTrackedProperty(KEY)).thenReturn(false);
+    PropertyDto propertyDto = getPropertyDto(KEY, null, USER_UUID);
+    underTest.saveProperty(session, propertyDto, USER_LOGIN, null, null);
 
     underTest.deleteByKeyAndValue(session, KEY, VALUE);
 
-    verify(auditPersister).isTrackedProperty(KEY);
+    verify(auditPersister, times(2)).isTrackedProperty(KEY);
     verifyNoMoreInteractions(auditPersister);
   }
 
-  private PropertyDto getPropertyDto(String key) {
+  private PropertyDto getPropertyDto(String key, @Nullable String projectUuid, @Nullable String userUuid) {
     return new PropertyDto()
       .setKey(key)
       .setValue(VALUE)
-      .setUserUuid(USER_UUID)
-      .setComponentUuid(PROJECT_UUID);
+      .setUserUuid(userUuid)
+      .setComponentUuid(projectUuid);
   }
 
   private PropertyQuery getPropertyQuery(String key) {
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupDaoWithPersisterTest.java
index 936a8993b75..04dedb3e50c 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/GroupDaoWithPersisterTest.java
@@ -35,6 +35,7 @@ import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;
 
 public class GroupDaoWithPersisterTest {
@@ -104,4 +105,11 @@ public class GroupDaoWithPersisterTest {
       .extracting(UserGroupNewValue::getGroupUuid, UserGroupNewValue::getName)
       .containsExactly(aGroup.getUuid(), aGroup.getName());
   }
+
+  @Test
+  public void deleteGroupWithoutAffectedRowsIsNotPersisted() {
+    underTest.deleteByUuid(db.getSession(), aGroup.getUuid(), aGroup.getName());
+
+    verifyNoInteractions(auditPersister);
+  }
 }
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoWithPersisterTest.java
index f46b107377e..e18a167d6ad 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserGroupDaoWithPersisterTest.java
@@ -33,6 +33,8 @@ import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 public class UserGroupDaoWithPersisterTest {
   private final AuditPersister auditPersister = mock(AuditPersister.class);
@@ -85,6 +87,15 @@ public class UserGroupDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteUserGroupByGroupWithoutAffectedRowsIsNotPersisted() {
+    GroupDto group1 = db.users().insertGroup();
+    underTest.deleteByGroupUuid(db.getSession(), group1.getUuid(), group1.getName());
+    db.getSession().commit();
+
+    verifyNoInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteUserGroupByUserIsPersisted() {
     UserDto user1 = db.users().insertUser();
     UserDto user2 = db.users().insertUser();
@@ -106,6 +117,16 @@ public class UserGroupDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteUserGroupByUserWithoutAffectedRowsIsNotPersisted() {
+    UserDto user1 = db.users().insertUser();
+    underTest.deleteByUserUuid(db.getSession(), user1);
+    db.getSession().commit();
+
+    verify(auditPersister).addUser(any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
   public void delete_by_user_and_group() {
     UserDto user1 = db.users().insertUser();
     UserDto user2 = db.users().insertUser();
@@ -122,4 +143,15 @@ public class UserGroupDaoWithPersisterTest {
       .extracting(UserGroupNewValue::getGroupUuid, UserGroupNewValue::getName, UserGroupNewValue::getUserUuid, UserGroupNewValue::getUserLogin)
       .containsExactly(group1.getUuid(), group1.getName(), user1.getUuid(), user1.getLogin());
   }
+
+  @Test
+  public void deletByUserAndGroupWithoutAffectedRowsIsNotPersisted() {
+    UserDto user1 = db.users().insertUser();
+    GroupDto group1 = db.users().insertGroup();
+    underTest.delete(db.getSession(), group1, user1);
+    db.getSession().commit();
+
+    verify(auditPersister).addUser(any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
 }
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserPropertiesDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserPropertiesDaoWithPersisterTest.java
index 1d74a380629..5992048b027 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserPropertiesDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserPropertiesDaoWithPersisterTest.java
@@ -170,4 +170,14 @@ public class UserPropertiesDaoWithPersisterTest {
         PropertyNewValue::getUserLogin)
       .containsExactly(userSetting.getKey(), userSetting.getValue(), user.getUuid(), user.getLogin());
   }
+
+  @Test
+  public void deleteTrackedUserPropertyWithoutAffectedRowsIsNotPersisted() {
+    UserDto user = db.users().insertUser();
+
+    underTest.deleteByUser(db.getSession(), user);
+
+    verify(auditPersister).addUser(eq(db.getSession()), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
 }
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoWithPersisterTest.java
index b2dd97a6243..79940eeaf34 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/user/UserTokenDaoWithPersisterTest.java
@@ -31,9 +31,11 @@ import org.sonar.db.audit.AuditPersister;
 import org.sonar.db.audit.model.UserTokenNewValue;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.sonar.db.user.UserTokenTesting.newUserToken;
 
 public class UserTokenDaoWithPersisterTest {
@@ -50,7 +52,7 @@ public class UserTokenDaoWithPersisterTest {
   private final UserTokenDao underTest = dbClient.userTokenDao();
 
   @Test
-  public void insert_token() {
+  public void insert_token_is_persisted() {
     UserTokenDto userToken = newUserToken();
     underTest.insert(db.getSession(), userToken, "login");
 
@@ -70,7 +72,7 @@ public class UserTokenDaoWithPersisterTest {
   }
 
   @Test
-  public void update_token() {
+  public void update_token_is_persisted() {
     UserDto user1 = db.users().insertUser();
     UserTokenDto userToken1 = db.users().insertToken(user1);
 
@@ -86,7 +88,7 @@ public class UserTokenDaoWithPersisterTest {
   }
 
   @Test
-  public void delete_tokens_by_user() {
+  public void delete_tokens_by_user_is_persisted() {
     UserDto user1 = db.users().insertUser();
     UserDto user2 = db.users().insertUser();
     db.users().insertToken(user1);
@@ -104,7 +106,17 @@ public class UserTokenDaoWithPersisterTest {
   }
 
   @Test
-  public void delete_token_by_user_and_name() {
+  public void delete_tokens_by_user_without_affected_rows_is_not_persisted() {
+    UserDto user1 = db.users().insertUser();
+
+    underTest.deleteByUser(dbSession, user1);
+
+    verify(auditPersister).addUser(any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
+  public void delete_token_by_user_and_name_is_persisted() {
     UserDto user1 = db.users().insertUser();
     UserDto user2 = db.users().insertUser();
     db.users().insertToken(user1, t -> t.setName("name"));
@@ -120,4 +132,14 @@ public class UserTokenDaoWithPersisterTest {
       .extracting(UserTokenNewValue::getUserUuid, UserTokenNewValue::getUserLogin, UserTokenNewValue::getTokenName)
       .containsExactly(user1.getUuid(), user1.getLogin(), "name");
   }
+
+  @Test
+  public void delete_token_by_user_and_name_without_affected_rows_is_persisted() {
+    UserDto user1 = db.users().insertUser();
+
+    underTest.deleteByUserAndName(dbSession, user1, "name");
+
+    verify(auditPersister).addUser(any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
 }
diff --git a/server/sonar-db-dao/src/test/java/org/sonar/db/webhook/WebhookDaoWithPersisterTest.java b/server/sonar-db-dao/src/test/java/org/sonar/db/webhook/WebhookDaoWithPersisterTest.java
index 7dd4c49e674..97dc844b750 100644
--- a/server/sonar-db-dao/src/test/java/org/sonar/db/webhook/WebhookDaoWithPersisterTest.java
+++ b/server/sonar-db-dao/src/test/java/org/sonar/db/webhook/WebhookDaoWithPersisterTest.java
@@ -32,9 +32,11 @@ import org.sonar.db.component.ComponentDbTester;
 import org.sonar.db.project.ProjectDto;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
 
 public class WebhookDaoWithPersisterTest {
   private final AuditPersister auditPersister = mock(AuditPersister.class);
@@ -139,6 +141,16 @@ public class WebhookDaoWithPersisterTest {
   }
 
   @Test
+  public void deleteProjectWebhooksWithoutAffectedRowsIsNotPersisted() {
+    ProjectDto projectDto = componentDbTester.insertPrivateProjectDto(p -> p.setUuid("puuid").setName("pname"));
+
+    underTest.deleteByProject(dbSession, projectDto);
+
+    verify(auditPersister).addComponent(any(), any(), any());
+    verifyNoMoreInteractions(auditPersister);
+  }
+
+  @Test
   public void deleteWebhookIsPersisted() {
     WebhookDto dto = webhookDbTester.insertGlobalWebhook();
 
@@ -151,4 +163,11 @@ public class WebhookDaoWithPersisterTest {
       .containsExactly(dto.getUuid(), dto.getName());
     assertThat(newValue).hasToString("{\"webhookUuid\": \"" + dto.getUuid() + "\", \"name\": \"" + dto.getName() + "\" }");
   }
+
+  @Test
+  public void deleteWebhookWithoutAffectedRowsIsNotPersisted() {
+    underTest.delete(dbSession, "webhook-uuid", "webhook-name");
+
+    verifyNoMoreInteractions(auditPersister);
+  }
 }
diff --git a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/project/ws/UpdateVisibilityAction.java b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/project/ws/UpdateVisibilityAction.java
index b395be13fcc..0ad2ee8c327 100644
--- a/server/sonar-webserver-webapi/src/main/java/org/sonar/server/project/ws/UpdateVisibilityAction.java
+++ b/server/sonar-webserver-webapi/src/main/java/org/sonar/server/project/ws/UpdateVisibilityAction.java
@@ -20,6 +20,7 @@
 package org.sonar.server.project.ws;
 
 import com.google.common.collect.ImmutableSet;
+import java.util.Set;
 import org.sonar.api.config.Configuration;
 import org.sonar.api.resources.Qualifiers;
 import org.sonar.api.server.ws.Request;
@@ -53,7 +54,6 @@ import static org.sonar.server.user.AbstractUserSession.insufficientPrivilegesEx
 import static org.sonar.server.ws.KeyExamples.KEY_PROJECT_EXAMPLE_001;
 import static org.sonarqube.ws.client.project.ProjectsWsParameters.PARAM_PROJECT;
 import static org.sonarqube.ws.client.project.ProjectsWsParameters.PARAM_VISIBILITY;
-import java.util.Set;
 
 public class UpdateVisibilityAction implements ProjectsWsAction {
   private static final Set<String> AUTHORIZED_QUALIFIERS = ImmutableSet.of(Qualifiers.PROJECT, Qualifiers.VIEW, Qualifiers.APP);
@@ -135,7 +135,7 @@ public class UpdateVisibilityAction implements ProjectsWsAction {
     dbClient.componentDao().setPrivateForRootComponentUuid(dbSession, uuid, isPrivate, component.qualifier(), component.name());
 
     if (component.qualifier().equals(Qualifiers.PROJECT) || component.qualifier().equals(Qualifiers.APP)) {
-      dbClient.projectDao().updateVisibility(dbSession, uuid, isPrivate, component.qualifier(), component.name());
+      dbClient.projectDao().updateVisibility(dbSession, uuid, isPrivate);
     }
 
     ComponentMapper mapper = dbSession.getMapper(ComponentMapper.class);