[WIP] Initial work on DBMSProcessor batch entry insertion into ENTRY table

src/main/java/org/jabref/logic/shared/DBMSProcessor.java

@@ -16,15 +16,18 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import org.jabref.logic.shared.exception.OfflineLockException;
 import org.jabref.model.database.shared.DBMSType;
 import org.jabref.model.database.shared.DatabaseConnection;
 import org.jabref.model.database.shared.DatabaseConnectionProperties;
 import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.SharedBibEntryData;
 import org.jabref.model.entry.event.EntriesEventSource;
 import org.jabref.model.entry.field.Field;
 import org.jabref.model.entry.field.FieldFactory;
+import org.jabref.model.entry.types.EntryType;
 import org.jabref.model.entry.types.EntryTypeFactory;
 
 import org.slf4j.Logger;
@@ -131,40 +134,61 @@ public void setupSharedDatabase() throws SQLException {
     abstract String escape(String expression);
 
     /**
-     * Inserts the given bibEntry into shared database.
+     * For use in test only. Inserts the BibEntry into the shared database.
      *
-     * @param bibEntry {@link BibEntry} to be inserted
+     * @param bibEntry {@link BibEntry} to be inserted.
+     * */
+     public void insertEntry(BibEntry bibEntry) {
+         insertEntries(Collections.singletonList(bibEntry));
+     }
+
+    /**
+     * Inserts the List of BibEntry into the shared database.
+     *
+     * @param bibEntries List of {@link BibEntry} to be inserted
      */
-    public void insertEntry(BibEntry bibEntry) {
-        if (!checkForBibEntryExistence(bibEntry)) {
-            insertIntoEntryTable(bibEntry);
+    public void insertEntries(List<BibEntry> bibEntries) {
+        List<BibEntry> notYetExistingEntries = getNotYetExistingEntries(bibEntries);
+        insertIntoEntryTable(notYetExistingEntries);
+        // Temporary fix - THIS MUST BE CHANGED BEFORE MERGING TO MASTER
+        for (BibEntry bibEntry : notYetExistingEntries) {
             insertIntoFieldTable(bibEntry);
         }
     }
 
     /**
-     * Inserts the given bibEntry into ENTRY table.
+     * Inserts the given List of BibEntry into the ENTRY table.
      *
-     * @param bibEntry {@link BibEntry} to be inserted
+     * @param bibEntries List of {@link BibEntry} to be inserted
      */
-    protected void insertIntoEntryTable(BibEntry bibEntry) {
-        // This is the only method to get generated keys which is accepted by MySQL, PostgreSQL and Oracle.
-        String insertIntoEntryQuery =
-                "INSERT INTO " +
-                        escape("ENTRY") +
-                        "(" +
-                        escape("TYPE") +
-                        ") VALUES(?)";
-
-        try (PreparedStatement preparedEntryStatement = connection.prepareStatement(insertIntoEntryQuery,
-                new String[]{"SHARED_ID"})) {
+    protected void insertIntoEntryTable(List<BibEntry> bibEntries) {
+        StringBuilder insertIntoEntryQuery = new StringBuilder()
+                .append("INSERT INTO ")
+                .append(escape("ENTRY"))
+                .append("(")
+                .append(escape("TYPE"))
+                .append(") VALUES(?)");
+        // Number of commas is bibEntries.size() - 1
+        for (int i = 0; i < bibEntries.size() - 1; i++) {
+            insertIntoEntryQuery.append(", (?)");
+        }
 
-            preparedEntryStatement.setString(1, bibEntry.getType().getName());
+        try (PreparedStatement preparedEntryStatement = connection.prepareStatement(insertIntoEntryQuery.toString(),
+                new String[]{"SHARED_ID"})) {
+            for (int i = 0; i < bibEntries.size(); i++) {
+                preparedEntryStatement.setString(i + 1, bibEntries.get(i).getType().getName());
+            }
             preparedEntryStatement.executeUpdate();
 
             try (ResultSet generatedKeys = preparedEntryStatement.getGeneratedKeys()) {
+                // The following assumes that we get the generated keys in the order the entries were inserted
+                // This should be the case
+                for (BibEntry bibEntry : bibEntries) {
+                    generatedKeys.next();
+                    bibEntry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1));
+                }
                 if (generatedKeys.next()) {
-                    bibEntry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1)); // set generated ID locally
+                    LOGGER.error("Error: Some shared IDs left unassigned");
                 }
             }
         } catch (SQLException e) {
@@ -173,44 +197,47 @@ protected void insertIntoEntryTable(BibEntry bibEntry) {
     }
 
     /**
-     * Checks whether the given bibEntry already exists on shared database.
+     * Filters a list of BibEntry to and returns those which do not exist in the database
      *
-     * @param bibEntry {@link BibEntry} to be checked
+     * @param bibEntries {@link BibEntry} to be checked
      * @return <code>true</code> if existent, else <code>false</code>
      */
-    private boolean checkForBibEntryExistence(BibEntry bibEntry) {
+    private List<BibEntry> getNotYetExistingEntries(List<BibEntry> bibEntries) {
+
+        List<Integer> remoteIds = new ArrayList<>();
+        List<Integer> localIds = bibEntries.stream()
+                                           .map(BibEntry::getSharedBibEntryData)
+                                           .map(SharedBibEntryData::getSharedID)
+                                           .filter((id) -> id != -1)
+                                           .collect(Collectors.toList());
+        if (localIds.isEmpty()) {
+            return bibEntries;
+        }
         try {
-            // Check if already exists
-            int sharedID = bibEntry.getSharedBibEntryData().getSharedID();
-            if (sharedID != -1) {
-                String selectQuery =
-                        "SELECT * FROM " +
-                                escape("ENTRY") +
-                                " WHERE " +
-                                escape("SHARED_ID") +
-                                " = ?";
-
-                try (PreparedStatement preparedSelectStatement = connection.prepareStatement(selectQuery)) {
-                    preparedSelectStatement.setInt(1, sharedID);
-                    try (ResultSet resultSet = preparedSelectStatement.executeQuery()) {
-                        if (resultSet.next()) {
-                            return true;
-                        }
-                    }
+            StringBuilder selectQuery = new StringBuilder()
+                    .append("SELECT * FROM ")
+                    .append(escape("ENTRY"));
+
+            try (ResultSet resultSet = connection.createStatement().executeQuery(selectQuery.toString())) {
+                while (resultSet.next()) {
+                    int id = resultSet.getInt("SHARED_ID");
+                    remoteIds.add(id);
                 }
             }
         } catch (SQLException e) {
             LOGGER.error("SQL Error: ", e);
         }
-        return false;
-    }
+        return bibEntries.stream().filter((entry) ->
+                !remoteIds.contains(entry.getSharedBibEntryData().getSharedID()))
+                .collect(Collectors.toList());
+        }
 
     /**
      * Inserts the given bibEntry into FIELD table.
      *
      * @param bibEntry {@link BibEntry} to be inserted
      */
-    private void insertIntoFieldTable(BibEntry bibEntry) {
+    protected void insertIntoFieldTable(BibEntry bibEntry) {
         try {
             // Inserting into FIELD table
             // Coerce to ArrayList in order to use List.get()

src/main/java/org/jabref/logic/shared/DBMSSynchronizer.java

@@ -82,12 +82,9 @@ public void listen(EntriesAddedEvent event) {
         if (isEventSourceAccepted(event) && checkCurrentConnection()) {
             synchronizeLocalMetaData();
             synchronizeLocalDatabase(); // Pull changes for the case that there were some
-            List<BibEntry> entries = event.getBibEntries();
-            for (BibEntry entry : entries) {
-                dbmsProcessor.insertEntry(entry);
+            dbmsProcessor.insertEntries(event.getBibEntries());
             }
         }
-    }
 
     /**
      * Listening method. Updates an existing shared {@link BibEntry}.

src/main/java/org/jabref/logic/shared/OracleProcessor.java

@@ -1,11 +1,17 @@
 package org.jabref.logic.shared;
 
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Properties;
 
 import org.jabref.logic.shared.listener.OracleNotificationListener;
 import org.jabref.model.database.shared.DatabaseConnection;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.Field;
 
 import oracle.jdbc.OracleConnection;
 import oracle.jdbc.OracleStatement;
@@ -97,6 +103,79 @@ public void startNotificationListener(DBMSSynchronizer dbmsSynchronizer) {
 
     }
 
+    @Override
+    protected void insertIntoEntryTable(List<BibEntry> entries) {
+        try {
+            // Inserting into ENTRY table
+            StringBuilder insertEntryQuery = new StringBuilder()
+                    .append("INSERT ALL");
+            for (BibEntry entry : entries) {
+                insertEntryQuery.append(" INTO ")
+                                .append(escape("ENTRY"))
+                                .append(" (")
+                                .append(escape("TYPE"))
+                                .append(") VALUES (?)");
+            }
+            insertEntryQuery.append(" SELECT * FROM DUAL");
+            LOGGER.info(insertEntryQuery.toString());
+            try (PreparedStatement preparedEntryStatement = connection.prepareStatement(insertEntryQuery.toString(),
+                    new String[]{"SHARED_ID"})) {
+                for (int i = 0; i < entries.size(); i++) {
+                    // columnIndex starts with 1
+                    preparedEntryStatement.setString(i + 1, entries.get(i).getType().getName());
+                }
+                preparedEntryStatement.executeUpdate();
+                try (ResultSet generatedKeys = preparedEntryStatement.getGeneratedKeys()) {
+                    // The following assumes that we get the generated keys in the order the entries were inserted
+                    // This should be the case
+                    for (BibEntry entry : entries) {
+                        generatedKeys.next();
+                        entry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1));
+                    }
+                    if (generatedKeys.next()) {
+                        LOGGER.error("Error: Some shared IDs left unassigned");
+                    }
+                }
+            }
+        } catch (SQLException e) {
+            LOGGER.error("SQL Error: ", e);
+        }
+    }
+
+    @Override
+    protected void insertIntoFieldTable(BibEntry bibEntry) {
+        try {
+            // Inserting into FIELD table
+            // Coerce to ArrayList in order to use List.get()
+            List<Field> fields = new ArrayList<>(bibEntry.getFields());
+            StringBuilder insertFieldQuery = new StringBuilder()
+                    .append("INSERT ALL");
+            for (Field field : fields) {
+                insertFieldQuery.append(" INTO ")
+                                .append(escape("FIELD"))
+                                .append(" (")
+                                .append(escape("ENTRY_SHARED_ID"))
+                                .append(", ")
+                                .append(escape("NAME"))
+                                .append(", ")
+                                .append(escape("VALUE"))
+                                .append(") VALUES (?, ?, ?)");
+            }
+            insertFieldQuery.append(" SELECT * FROM DUAL");
+            try (PreparedStatement preparedFieldStatement = connection.prepareStatement(insertFieldQuery.toString())) {
+                for (int i = 0; i < fields.size(); i++) {
+                    // columnIndex starts with 1
+                    preparedFieldStatement.setInt((3 * i) + 1, bibEntry.getSharedBibEntryData().getSharedID());
+                    preparedFieldStatement.setString((3 * i) + 2, fields.get(i).getName());
+                    preparedFieldStatement.setString((3 * i) + 3, bibEntry.getField(fields.get(i)).get());
+                }
+                preparedFieldStatement.executeUpdate();
+            }
+        } catch (SQLException e) {
+            LOGGER.error("SQL Error: ", e);
+        }
+    }
+
     @Override
     public void stopNotificationListener() {
         try {

src/main/java/org/jabref/logic/shared/PostgreSQLProcessor.java

@@ -4,6 +4,7 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.util.List;
 
 import org.jabref.JabRefExecutorService;
 import org.jabref.logic.shared.listener.PostgresSQLNotificationListener;
@@ -49,25 +50,34 @@ public void setUp() throws SQLException {
     }
 
     @Override
-    protected void insertIntoEntryTable(BibEntry bibEntry) {
-        // Inserting into ENTRY table
-        StringBuilder insertIntoEntryQuery = new StringBuilder()
-                                                                .append("INSERT INTO ")
-                                                                .append(escape("ENTRY"))
-                                                                .append("(")
-                                                                .append(escape("TYPE"))
-                                                                .append(") VALUES(?)");
-
+    protected void insertIntoEntryTable(List<BibEntry> bibEntries) {
         // This is the only method to get generated keys which is accepted by MySQL, PostgreSQL and Oracle.
+        StringBuilder insertIntoEntryQuery = new StringBuilder()
+                .append("INSERT INTO ")
+                .append(escape("ENTRY"))
+                .append("(")
+                .append(escape("TYPE"))
+                .append(") VALUES(?)");
+        // Number of commas is bibEntries.size() - 1
+        for (int i = 0; i < bibEntries.size() - 1; i++) {
+            insertIntoEntryQuery.append(", (?)");
+        }
         try (PreparedStatement preparedEntryStatement = connection.prepareStatement(insertIntoEntryQuery.toString(),
-                                                                                    Statement.RETURN_GENERATED_KEYS)) {
-
-            preparedEntryStatement.setString(1, bibEntry.getType().getName());
+                Statement.RETURN_GENERATED_KEYS)) {
+            for (int i = 0; i < bibEntries.size(); i++) {
+                preparedEntryStatement.setString(i + 1, bibEntries.get(i).getType().getName());
+            }
             preparedEntryStatement.executeUpdate();
 
             try (ResultSet generatedKeys = preparedEntryStatement.getGeneratedKeys()) {
+                // The following assumes that we get the generated keys in the order the entries were inserted
+                // This should be the case
+                for (BibEntry bibEntry : bibEntries) {
+                    generatedKeys.next();
+                    bibEntry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1));
+                }
                 if (generatedKeys.next()) {
-                    bibEntry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1)); // set generated ID locally
+                    LOGGER.error("Error: Some shared IDs left unassigned");
                 }
             }
         } catch (SQLException e) {