Fixing performance issues when bulk deleting (#12926)

* Fixing performance issues  when bulk deleting

* Removing comments

* Update CHANGELOG.md

* Delete benchmark

Rmoved a benchmark that I was using to test the performance that was accidently pushed.

* Fixing JMH Config

* Checkstyle Fix

Author: Zurtar

CHANGELOG.md

@@ -108,6 +108,7 @@ Note that this project **does not** adhere to [Semantic Versioning](https://semv
 - We fixed an issue where downloading PDFs from URLs to empty entries resulted in meaningless filenames like "-.pdf". [#12917](https://github.com/JabRef/jabref/issues/12917)
 - We fixed an issue where pasting a PDF URL into the main table caused an import error instead of creating a new entry. [#12911](https://github.com/JabRef/jabref/pull/12911)
 - We fixed an issue where libraries would sometimes be hidden when closing tabs with the Welcome tab open. [#12894](https://github.com/JabRef/jabref/issues/12894)
+- We fixed an issue with deleting entries in large libraries that caused it to take a long time. [#8976](https://github.com/JabRef/jabref/issues/8976)
 
 ### Removed
 

build.gradle

@@ -1004,6 +1004,7 @@ jmh {
     warmupIterations = 5
     iterations = 10
     fork = 2
+    zip64 = true
 }
 
 requirementTracing {

src/jmh/java/org/jabref/benchmarks/Benchmarks.java

@@ -3,11 +3,13 @@
 import java.io.IOException;
 import java.io.StringReader;
 import java.io.StringWriter;
+import java.util.Collections;
 import java.util.List;
 import java.util.Random;
 
 import org.jabref.logic.bibtex.FieldPreferences;
 import org.jabref.logic.citationkeypattern.CitationKeyPatternPreferences;
+import org.jabref.logic.exporter.BibDatabaseWriter;
 import org.jabref.logic.exporter.BibWriter;
 import org.jabref.logic.exporter.BibtexDatabaseWriter;
 import org.jabref.logic.exporter.SelfContainedSaveConfiguration;
@@ -31,8 +33,10 @@
 import org.jabref.model.groups.KeywordGroup;
 import org.jabref.model.groups.WordKeywordGroup;
 import org.jabref.model.metadata.MetaData;
+import org.jabref.model.metadata.SaveOrder;
 
 import com.airhacks.afterburner.injection.Injector;
+import org.mockito.Answers;
 import org.openjdk.jmh.Main;
 import org.openjdk.jmh.annotations.Benchmark;
 import org.openjdk.jmh.annotations.Scope;
@@ -77,11 +81,15 @@ public void init() throws Exception {
     private StringWriter getOutputWriter() throws IOException {
         StringWriter outputWriter = new StringWriter();
         BibWriter bibWriter = new BibWriter(outputWriter, OS.NEWLINE);
+        SelfContainedSaveConfiguration saveConfiguration = new SelfContainedSaveConfiguration(SaveOrder.getDefaultSaveOrder(), false, BibDatabaseWriter.SaveType.WITH_JABREF_META_DATA, false);
+        FieldPreferences fieldPreferences = new FieldPreferences(true, Collections.emptyList(), Collections.emptyList());
+        CitationKeyPatternPreferences citationKeyPatternPreferences = mock(CitationKeyPatternPreferences.class, Answers.RETURNS_DEEP_STUBS);
+
         BibtexDatabaseWriter databaseWriter = new BibtexDatabaseWriter(
                 bibWriter,
-                mock(SelfContainedSaveConfiguration.class),
-                mock(FieldPreferences.class),
-                mock(CitationKeyPatternPreferences.class),
+                saveConfiguration,
+                fieldPreferences,
+                citationKeyPatternPreferences,
                 new BibEntryTypesManager());
         databaseWriter.savePartOfDatabase(new BibDatabaseContext(database, new MetaData()), database.getEntries());
         return outputWriter;

src/main/java/org/jabref/model/database/BibDatabase.java

@@ -16,6 +16,7 @@
 import java.util.Set;
 import java.util.TreeSet;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
@@ -28,11 +29,13 @@
 import org.jabref.model.entry.BibEntry;
 import org.jabref.model.entry.BibtexString;
 import org.jabref.model.entry.Month;
+import org.jabref.model.entry.ParsedEntryLink;
 import org.jabref.model.entry.event.EntriesEventSource;
 import org.jabref.model.entry.event.EntryChangedEvent;
 import org.jabref.model.entry.event.FieldChangedEvent;
 import org.jabref.model.entry.field.Field;
 import org.jabref.model.entry.field.FieldFactory;
+import org.jabref.model.entry.field.FieldProperty;
 import org.jabref.model.entry.field.StandardField;
 import org.jabref.model.strings.StringUtil;
 
@@ -61,6 +64,9 @@ public class BibDatabase {
     // Not included in equals, because it is not relevant for the content of the database
     private final EventBus eventBus = new EventBus();
 
+    // Reverse index for citation links
+    private final Map<String, Set<BibEntry>> citationIndex = new ConcurrentHashMap<>();
+
     private String preamble;
 
     // All file contents below the last entry in the file
@@ -192,7 +198,11 @@ public synchronized void insertEntries(List<BibEntry> newEntries, EntriesEventSo
             eventBus.post(new EntriesAddedEvent(newEntries, newEntries.getFirst(), eventSource));
         }
         entries.addAll(newEntries);
-        newEntries.forEach(entry -> entriesId.put(entry.getId(), entry));
+        newEntries.forEach(entry -> {
+                    entriesId.put(entry.getId(), entry);
+                    indexEntry(entry);
+                }
+        );
     }
 
     public synchronized void removeEntry(BibEntry bibEntry) {
@@ -223,17 +233,72 @@ public synchronized void removeEntries(List<BibEntry> toBeDeleted) {
     public synchronized void removeEntries(List<BibEntry> toBeDeleted, EntriesEventSource eventSource) {
         Objects.requireNonNull(toBeDeleted);
 
-        List<String> ids = new ArrayList<>();
+        Collection idsToBeDeleted;
+        if (toBeDeleted.size() > 10) {
+            idsToBeDeleted = new HashSet<>();
+        } else {
+            idsToBeDeleted = new ArrayList<>(toBeDeleted.size());
+        }
+
         for (BibEntry entry : toBeDeleted) {
-            ids.add(entry.getId());
+            idsToBeDeleted.add(entry.getId());
         }
-        boolean anyRemoved = entries.removeIf(entry -> ids.contains(entry.getId()));
-        if (anyRemoved) {
-            toBeDeleted.forEach(entry -> entriesId.remove(entry.getId()));
-            eventBus.post(new EntriesRemovedEvent(toBeDeleted, eventSource));
+
+        List<BibEntry> newEntries = new ArrayList<>(entries);
+        newEntries.removeIf(entry -> idsToBeDeleted.contains(entry.getId()));
+
+        toBeDeleted.forEach(entry -> {
+            entriesId.remove(entry.getId());
+            removeEntryFromIndex(entry);
+        });
+
+        entries.setAll(newEntries);
+        eventBus.post(new EntriesRemovedEvent(toBeDeleted, eventSource));
+    }
+
+    private void forEachCitationKey(BibEntry entry, Consumer<String> keyConsumer) {
+        for (Field field : entry.getFields()) {
+            if (field.getProperties().contains(FieldProperty.SINGLE_ENTRY_LINK) || field.getProperties().contains(FieldProperty.MULTIPLE_ENTRY_LINK)) {
+                List<ParsedEntryLink> parsedLinks = entry.getEntryLinkList(field, this);
+
+                for (ParsedEntryLink link : parsedLinks) {
+                    String key = link.getKey().trim();
+                    if (!key.isEmpty()) {
+                        keyConsumer.accept(key);
+                    }
+                }
+            }
         }
     }
 
+    public Set<BibEntry> getEntriesForCitationKey(String citationKey) {
+        return citationIndex.getOrDefault(citationKey, Collections.emptySet());
+    }
+
+    private Set<String> getReferencedCitationKeys(BibEntry entry) {
+        Set<String> keys = new HashSet<>();
+        forEachCitationKey(entry, key -> keys.add(key));
+        return keys;
+    }
+
+    private void indexEntry(BibEntry entry) {
+        forEachCitationKey(entry, key ->
+                citationIndex.computeIfAbsent(key, k -> ConcurrentHashMap.newKeySet()).add(entry)
+        );
+    }
+
+    private void removeEntryFromIndex(BibEntry entry) {
+        forEachCitationKey(entry, key -> {
+            Set<BibEntry> entriesForKey = citationIndex.get(key);
+            if (entriesForKey != null) {
+                entriesForKey.remove(entry);
+                if (entriesForKey.isEmpty()) {
+                    citationIndex.remove(key);
+                }
+            }
+        });
+    }
+
     /**
      * Returns the database's preamble.
      * If the preamble text consists only of whitespace, then also an empty optional is returned.
@@ -626,13 +691,11 @@ public String getNewLineSeparator() {
 
     /**
      * @return The index of the given entry in the list of entries, or -1 if the entry is not in the list.
-     *
      * @implNote New entries are always added to the end of the list and always get a higher ID.
-     *           See {@link org.jabref.model.entry.BibEntry#BibEntry(org.jabref.model.entry.types.EntryType) BibEntry},
-     *           {@link org.jabref.model.entry.IdGenerator IdGenerator},
-     *           {@link BibDatabase#insertEntries(List, EntriesEventSource) insertEntries}.
-     *           Therefore, using binary search to find the index.
-     *
+     * See {@link org.jabref.model.entry.BibEntry#BibEntry(org.jabref.model.entry.types.EntryType) BibEntry},
+     * {@link org.jabref.model.entry.IdGenerator IdGenerator},
+     * {@link BibDatabase#insertEntries(List, EntriesEventSource) insertEntries}.
+     * Therefore, using binary search to find the index.
      * @implNote IDs are zero-padded strings, so there is no need to convert them to integers for comparison.
      */
     public int indexOf(BibEntry bibEntry) {

src/main/java/org/jabref/model/database/KeyChangeListener.java

@@ -4,6 +4,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
+import java.util.Set;
 
 import org.jabref.model.database.event.EntriesRemovedEvent;
 import org.jabref.model.entry.BibEntry;
@@ -41,17 +42,18 @@ public void listen(EntriesRemovedEvent event) {
     }
 
     private void updateEntryLinks(String newKey, String oldKey) {
-        for (BibEntry entry : database.getEntries()) {
+        Set<BibEntry> affectedEntries = database.getEntriesForCitationKey(oldKey);
+        for (BibEntry entry : affectedEntries) {
             entry.getFields(field -> field.getProperties().contains(FieldProperty.SINGLE_ENTRY_LINK))
                  .forEach(field -> {
                      String fieldContent = entry.getField(field).orElseThrow();
                      replaceSingleKeyInField(newKey, oldKey, entry, field, fieldContent);
                  });
             entry.getFields(field -> field.getProperties().contains(FieldProperty.MULTIPLE_ENTRY_LINK))
                  .forEach(field -> {
-                     String fieldContent = entry.getField(field).orElseThrow();
-                     replaceKeyInMultiplesKeyField(newKey, oldKey, entry, field, fieldContent);
-                 });
+                String fieldContent = entry.getField(field).orElseThrow();
+                replaceKeyInMultiplesKeyField(newKey, oldKey, entry, field, fieldContent);
+            });
         }
     }