Made all database methods throw runtime exceptions instead

Plan/src/main/java/com/djrapitops/plan/ShutdownHook.java

@@ -6,6 +6,7 @@ package com.djrapitops.plan;
 
 import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.Actions;
 import com.djrapitops.plan.data.container.Action;
 import com.djrapitops.plan.data.container.Session;
@@ -81,7 +82,7 @@ public class ShutdownHook extends Thread {
                 UUID uuid = entry.getKey();
                 int messagesSent = entry.getValue();
                 db.save().action(uuid, new Action(now, Actions.FIRST_LOGOUT, "Messages sent: " + messagesSent));
-            } catch (DBException e) {
+            } catch (DBOpException e) {
                 Log.toLog(this.getClass(), e);
             }
         }
@@ -101,7 +102,7 @@ public class ShutdownHook extends Thread {
             try {
                 Log.debug("Shutdown: Saving a session: " + session.getSessionStart());
                 db.save().session(uuid, session);
-            } catch (DBException e) {
+            } catch (DBOpException e) {
                 Log.toLog(this.getClass(), e);
             }
         }

Plan/src/main/java/com/djrapitops/plan/api/CommonAPI.java

@@ -4,7 +4,7 @@
  */
 package com.djrapitops.plan.api;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.utilities.uuid.UUIDUtility;
 import com.djrapitops.plugin.api.utility.log.Log;
 
@@ -38,7 +38,7 @@ public abstract class CommonAPI implements PlanAPI {
     public Map<UUID, String> getKnownPlayerNames() {
         try {
             return fetchFromPlanDB().getPlayerNames();
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             Log.toLog(this.getClass(), e);
             return new HashMap<>();
         }

Plan/src/main/java/com/djrapitops/plan/api/exceptions/connection/TransferDatabaseException.java

@@ -4,8 +4,6 @@
  */
 package com.djrapitops.plan.api.exceptions.connection;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-
 /**
  * Thrown when DBException occurs during InfoRequest#placeIntoDatabase.
  *
@@ -13,7 +11,7 @@ import com.djrapitops.plan.api.exceptions.database.DBException;
  */
 public class TransferDatabaseException extends WebException {
 
-    public TransferDatabaseException(DBException cause) {
+    public TransferDatabaseException(Exception cause) {
         super(cause);
     }
 }

Plan/src/main/java/com/djrapitops/plan/api/exceptions/database/DBOpException.java

@@ -1,5 +1,7 @@
 package com.djrapitops.plan.api.exceptions.database;
 
+import java.sql.SQLException;
+
 /**
  * Runtime exception for wrapping database errors.
  *
@@ -7,6 +9,8 @@ package com.djrapitops.plan.api.exceptions.database;
  */
 public class DBOpException extends RuntimeException {
 
+    private boolean fatal = false;
+
     public DBOpException(String message) {
         super(message);
     }
@@ -14,4 +18,16 @@ public class DBOpException extends RuntimeException {
     public DBOpException(String message, Throwable cause) {
         super(message, cause);
     }
+
+    public static DBOpException forCause(String sql, SQLException e) {
+        return new DBOpException("SQL Failed: " + sql + "; " + e.getMessage(), e);
+    }
+
+    public boolean isFatal() {
+        return fatal;
+    }
+
+    public void setFatal(boolean fatal) {
+        this.fatal = fatal;
+    }
 }

Plan/src/main/java/com/djrapitops/plan/command/commands/InspectCommand.java

@@ -1,7 +1,6 @@
 package com.djrapitops.plan.command.commands;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-import com.djrapitops.plan.api.exceptions.database.FatalDBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.processing.Processing;
 import com.djrapitops.plan.system.processing.processors.info.InspectCacheRequestProcessor;
@@ -68,12 +67,13 @@ public class InspectCommand extends CommandNode {
                         }
                     }
                     Processing.submit(new InspectCacheRequestProcessor(uuid, sender, playerName));
-                } catch (FatalDBException ex) {
-                    Log.toLog(this.getClass(), ex);
-                    sender.sendMessage("§cFatal database exception occurred: " + ex.getMessage());
-                } catch (DBException ex) {
-                    Log.toLog(this.getClass(), ex);
-                    sender.sendMessage("§eNon-Fatal database exception occurred: " + ex.getMessage());
+                } catch (DBOpException e) {
+                    if (e.isFatal()) {
+                        sender.sendMessage("§cFatal database exception occurred: " + e.getMessage());
+                    } else {
+                        sender.sendMessage("§eNon-Fatal database exception occurred: " + e.getMessage());
+                    }
+                    Log.toLog(this.getClass(), e);
                 } finally {
                     this.cancel();
                 }

Plan/src/main/java/com/djrapitops/plan/command/commands/ListServersCommand.java

@@ -1,7 +1,7 @@
 package com.djrapitops.plan.command.commands;
 
 import com.djrapitops.plan.PlanPlugin;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.server.Server;
 import com.djrapitops.plan.system.settings.Permissions;
@@ -44,7 +44,7 @@ public class ListServersCommand extends CommandNode {
                 sender.sendMessage("  " + tCol + server.getId() + sCol + " : " + server.getName() + " : " + server.getWebAddress());
             }
             sender.sendMessage(Locale.get(Msg.CMD_CONSTANT_FOOTER).toString());
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             sender.sendMessage("§cDatabase Exception occurred.");
             Log.toLog(this.getClass(), e);
         }

Plan/src/main/java/com/djrapitops/plan/command/commands/QInspectCommand.java

@@ -1,7 +1,7 @@
 package com.djrapitops.plan.command.commands;
 
 import com.djrapitops.plan.PlanPlugin;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.PlayerProfile;
 import com.djrapitops.plan.data.calculation.ActivityIndex;
 import com.djrapitops.plan.system.database.databases.Database;
@@ -73,8 +73,13 @@ public class QInspectCommand extends CommandNode {
                     PlayerProfile playerProfile = database.fetch().getPlayerProfile(uuid);
 
                     sendMessages(sender, playerProfile);
-                } catch (DBException ex) {
-                    Log.toLog(this.getClass(), ex);
+                } catch (DBOpException e) {
+                    if (e.isFatal()) {
+                        sender.sendMessage("§cFatal database exception occurred: " + e.getMessage());
+                    } else {
+                        sender.sendMessage("§eNon-Fatal database exception occurred: " + e.getMessage());
+                    }
+                    Log.toLog(this.getClass(), e);
                 } finally {
                     this.cancel();
                 }

Plan/src/main/java/com/djrapitops/plan/command/commands/SearchCommand.java

@@ -1,9 +1,11 @@
 package com.djrapitops.plan.command.commands;
 
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.settings.Permissions;
 import com.djrapitops.plan.system.settings.locale.Locale;
 import com.djrapitops.plan.system.settings.locale.Msg;
 import com.djrapitops.plan.utilities.MiscUtils;
+import com.djrapitops.plugin.api.utility.log.Log;
 import com.djrapitops.plugin.command.CommandNode;
 import com.djrapitops.plugin.command.CommandType;
 import com.djrapitops.plugin.command.ISender;
@@ -57,6 +59,9 @@ public class SearchCommand extends CommandNode {
                     }
 
                     sender.sendMessage(Locale.get(Msg.CMD_CONSTANT_FOOTER).toString());
+                } catch (DBOpException e) {
+                    sender.sendMessage("§cDatabase error occurred: " + e.getMessage());
+                    Log.toLog(this.getClass(), e);
                 } finally {
                     this.cancel();
                 }

Plan/src/main/java/com/djrapitops/plan/command/commands/UpdateCommand.java

@@ -1,7 +1,7 @@
 package com.djrapitops.plan.command.commands;
 
 import com.djrapitops.plan.api.exceptions.connection.*;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.command.commands.manage.ManageConDebugCommand;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.database.databases.operation.FetchOperations;
@@ -101,7 +101,7 @@ public class UpdateCommand extends CommandNode {
         try {
             cancel(sender, Database.getActive().fetch().getServers());
             sender.sendMessage("§aCancel operation performed.");
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             sender.sendMessage("§cDatabase error occurred, cancel could not be performed.");
             Log.toLog(this.getClass().getName(), e);
         }
@@ -120,7 +120,7 @@ public class UpdateCommand extends CommandNode {
         try {
             List<Server> servers = Database.getActive().fetch().getServers();
             update(sender, servers, args);
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             Log.toLog(this.getClass().getName(), e);
         }
     }
@@ -228,7 +228,7 @@ public class UpdateCommand extends CommandNode {
                 success = false;
             }
             return success;
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             sender.sendMessage("§cDatabase error occurred, update has been cancelled.");
             Log.toLog(this.getClass().getName(), e);
             return false;

Plan/src/main/java/com/djrapitops/plan/command/commands/manage/ManageClearCommand.java

@@ -1,8 +1,7 @@
 package com.djrapitops.plan.command.commands.manage;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.api.exceptions.database.DBInitException;
-import com.djrapitops.plan.api.exceptions.database.FatalDBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.DBSystem;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.settings.Permissions;
@@ -66,12 +65,13 @@ public class ManageClearCommand extends CommandNode {
                     database.remove().everything();
 
                     sender.sendMessage(Locale.get(Msg.MANAGE_INFO_CLEAR_SUCCESS).toString());
-                } catch (FatalDBException e) {
-                    sender.sendMessage(Locale.get(Msg.MANAGE_INFO_FAIL).toString()
-                            + " Error was fatal, so all information may not have been removed.");
-                    Log.toLog(this.getClass(), e);
-                } catch (DBException e) {
-                    sender.sendMessage(Locale.get(Msg.MANAGE_INFO_FAIL).toString());
+                } catch (DBOpException e) {
+                    if (e.isFatal()) {
+                        sender.sendMessage(Locale.get(Msg.MANAGE_INFO_FAIL).toString()
+                                + " Error was fatal, so all information may not have been removed.");
+                    } else {
+                        sender.sendMessage(Locale.get(Msg.MANAGE_INFO_FAIL).toString());
+                    }
                     Log.toLog(this.getClass(), e);
                 } finally {
                     this.cancel();

Plan/src/main/java/com/djrapitops/plan/command/commands/manage/ManageConDebugCommand.java

@@ -2,7 +2,6 @@ package com.djrapitops.plan.command.commands.manage;
 
 import com.djrapitops.plan.PlanPlugin;
 import com.djrapitops.plan.api.exceptions.connection.*;
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.InfoSystem;
 import com.djrapitops.plan.system.info.request.CheckConnectionRequest;
@@ -11,7 +10,6 @@ import com.djrapitops.plan.system.info.server.ServerInfo;
 import com.djrapitops.plan.system.processing.Processing;
 import com.djrapitops.plan.system.settings.Permissions;
 import com.djrapitops.plan.system.webserver.WebServerSystem;
-import com.djrapitops.plugin.api.utility.log.Log;
 import com.djrapitops.plugin.command.CommandNode;
 import com.djrapitops.plugin.command.CommandType;
 import com.djrapitops.plugin.command.ISender;
@@ -44,24 +42,19 @@ public class ManageConDebugCommand extends CommandNode {
     }
 
     private void testServers(ISender sender) {
-        try {
-            List<Server> servers = Database.getActive().fetch().getServers();
+        List<Server> servers = Database.getActive().fetch().getServers();
 
-            if (servers.isEmpty()) {
-                sender.sendMessage("§cNo Servers found in the database.");
+        if (servers.isEmpty()) {
+            sender.sendMessage("§cNo Servers found in the database.");
+        }
+
+        String accessAddress = WebServerSystem.getInstance().getWebServer().getAccessAddress();
+        UUID thisServer = ServerInfo.getServerUUID();
+        for (Server server : servers) {
+            if (thisServer.equals(server.getUuid())) {
+                continue;
             }
-
-            String accessAddress = WebServerSystem.getInstance().getWebServer().getAccessAddress();
-            UUID thisServer = ServerInfo.getServerUUID();
-            for (Server server : servers) {
-                if (thisServer.equals(server.getUuid())) {
-                    continue;
-                }
-                testServer(sender, accessAddress, server);
-            }
-
-        } catch (DBException e) {
-            Log.toLog(this.getClass().getName(), e);
+            testServer(sender, accessAddress, server);
         }
     }
 

Plan/src/main/java/com/djrapitops/plan/command/commands/manage/ManageRemoveCommand.java

@@ -1,6 +1,6 @@
 package com.djrapitops.plan.command.commands.manage;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.settings.Permissions;
 import com.djrapitops.plan.system.settings.locale.Locale;
@@ -70,7 +70,7 @@ public class ManageRemoveCommand extends CommandNode {
                     database.remove().player(uuid);
 
                     sender.sendMessage(Locale.get(Msg.MANAGE_INFO_REMOVE_SUCCESS).parse(playerName, Database.getActive().getConfigName()));
-                } catch (DBException e) {
+                } catch (DBOpException e) {
                     Log.toLog(this.getClass(), e);
                     sender.sendMessage(Locale.get(Msg.MANAGE_INFO_FAIL).toString());
                 } finally {

Plan/src/main/java/com/djrapitops/plan/system/cache/DataCache.java

@@ -1,6 +1,6 @@
 package com.djrapitops.plan.system.cache;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.PlanSystem;
 import com.djrapitops.plan.system.SubSystem;
 import com.djrapitops.plan.system.database.databases.Database;
@@ -69,18 +69,6 @@ public class DataCache extends SessionCache implements SubSystem {
         }
     }
 
-    public void cacheSavedNames() {
-        try {
-            Map<UUID, String> playerNames = db.fetch().getPlayerNames();
-            this.playerNames.putAll(playerNames);
-            for (Map.Entry<UUID, String> entry : playerNames.entrySet()) {
-                uuids.put(entry.getValue(), entry.getKey());
-            }
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
-        }
-    }
-
     /**
      * Used to get the player name in the cache.
      *
@@ -93,7 +81,7 @@ public class DataCache extends SessionCache implements SubSystem {
             try {
                 name = db.fetch().getPlayerName(uuid);
                 playerNames.put(uuid, name);
-            } catch (DBException e) {
+            } catch (DBOpException e) {
                 Log.toLog(this.getClass(), e);
                 name = "Error occurred";
             }
@@ -118,7 +106,7 @@ public class DataCache extends SessionCache implements SubSystem {
                 if (!nicknames.isEmpty()) {
                     return nicknames.get(nicknames.size() - 1);
                 }
-            } catch (DBException e) {
+            } catch (DBOpException e) {
                 Log.toLog(this.getClass(), e);
             }
         }

Plan/src/main/java/com/djrapitops/plan/system/cache/SessionCache.java

@@ -1,6 +1,6 @@
 package com.djrapitops.plan.system.cache;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.container.Session;
 import com.djrapitops.plan.system.PlanSystem;
 import com.djrapitops.plan.system.database.databases.Database;
@@ -61,7 +61,7 @@ public class SessionCache {
             }
             session.endSession(time);
             Database.getActive().save().session(uuid, session);
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             Log.toLog(this.getClass(), e);
         } finally {
             activeSessions.remove(uuid);

Plan/src/main/java/com/djrapitops/plan/system/database/databases/operation/BackupOperations.java

@@ -1,14 +1,11 @@
 package com.djrapitops.plan.system.database.databases.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 
-import java.sql.SQLException;
-
 public interface BackupOperations {
 
-    void backup(Database toDatabase) throws SQLException;
+    void backup(Database toDatabase);
 
-    void restore(Database fromDatabase) throws DBException, SQLException;
+    void restore(Database fromDatabase);
 
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/operation/CheckOperations.java

@@ -1,21 +1,20 @@
 package com.djrapitops.plan.system.database.databases.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.info.server.ServerInfo;
 
 import java.util.UUID;
 
 public interface CheckOperations {
 
-    boolean isPlayerRegistered(UUID player) throws DBException;
+    boolean isPlayerRegistered(UUID player);
 
-    boolean isPlayerRegistered(UUID player, UUID server) throws DBException;
+    boolean isPlayerRegistered(UUID player, UUID server);
 
-    boolean doesWebUserExists(String username) throws DBException;
+    boolean doesWebUserExists(String username);
 
-    default boolean isPlayerRegisteredOnThisServer(UUID player) throws DBException {
+    default boolean isPlayerRegisteredOnThisServer(UUID player) {
         return isPlayerRegistered(player, ServerInfo.getServerUUID());
     }
 
-    boolean isServerInDatabase(UUID serverUUID) throws DBException;
+    boolean isServerInDatabase(UUID serverUUID);
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/operation/CountOperations.java

@@ -1,12 +1,10 @@
 package com.djrapitops.plan.system.database.databases.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-
 import java.util.UUID;
 
 public interface CountOperations {
 
-    int getServerPlayerCount(UUID server) throws DBException;
+    int getServerPlayerCount(UUID server);
 
-    int getNetworkPlayerCount() throws DBException;
+    int getNetworkPlayerCount();
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/operation/FetchOperations.java

@@ -1,6 +1,5 @@
 package com.djrapitops.plan.system.database.databases.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.PlayerProfile;
 import com.djrapitops.plan.data.ServerProfile;
 import com.djrapitops.plan.data.WebUser;
@@ -14,83 +13,83 @@ public interface FetchOperations {
 
     // Profiles
 
-    ServerProfile getServerProfile(UUID serverUUID) throws DBException;
+    ServerProfile getServerProfile(UUID serverUUID);
 
-    List<PlayerProfile> getPlayers(UUID serverUUID) throws DBException;
+    List<PlayerProfile> getPlayers(UUID serverUUID);
 
-    PlayerProfile getPlayerProfile(UUID uuid) throws DBException;
+    PlayerProfile getPlayerProfile(UUID uuid);
 
     // UUIDs
 
     PlayerContainer getPlayerContainer(UUID uuid);
 
-    Set<UUID> getSavedUUIDs() throws DBException;
+    Set<UUID> getSavedUUIDs();
 
-    Set<UUID> getSavedUUIDs(UUID server) throws DBException;
+    Set<UUID> getSavedUUIDs(UUID server);
 
-    Map<UUID, String> getServerNames() throws DBException;
+    Map<UUID, String> getServerNames();
 
-    Optional<UUID> getServerUUID(String serverName) throws DBException;
+    Optional<UUID> getServerUUID(String serverName);
 
-    UUID getUuidOf(String playerName) throws DBException;
+    UUID getUuidOf(String playerName);
 
     // WebUsers
 
-    WebUser getWebUser(String username) throws DBException;
+    WebUser getWebUser(String username);
 
     // Servers
 
-    Optional<String> getServerName(UUID serverUUID) throws DBException;
+    Optional<String> getServerName(UUID serverUUID);
 
-    Optional<Server> getBungeeInformation() throws DBException;
+    Optional<Server> getBungeeInformation();
 
-    Optional<Integer> getServerID(UUID serverUUID) throws DBException;
+    Optional<Integer> getServerID(UUID serverUUID);
 
     // Raw Data
 
-    List<TPS> getTPSData(UUID serverUUID) throws DBException;
+    List<TPS> getTPSData(UUID serverUUID);
 
-    List<TPS> getNetworkOnlineData() throws DBException;
+    List<TPS> getNetworkOnlineData();
 
-    List<Long> getRegisterDates() throws DBException;
+    List<Long> getRegisterDates();
 
-    Optional<TPS> getAllTimePeak(UUID serverUUID) throws DBException;
+    Optional<TPS> getAllTimePeak(UUID serverUUID);
 
-    Optional<TPS> getPeakPlayerCount(UUID serverUUID, long afterDate) throws DBException;
+    Optional<TPS> getPeakPlayerCount(UUID serverUUID, long afterDate);
 
-    Map<UUID, Map<UUID, List<Session>>> getSessionsWithNoExtras() throws DBException;
+    Map<UUID, Map<UUID, List<Session>>> getSessionsWithNoExtras();
 
-    Map<UUID, Map<UUID, List<Session>>> getSessionsAndExtras() throws DBException;
+    Map<UUID, Map<UUID, List<Session>>> getSessionsAndExtras();
 
-    Set<String> getWorldNames(UUID serverUuid) throws DBException;
+    Set<String> getWorldNames(UUID serverUuid);
 
-    List<String> getNicknamesOfPlayerOnServer(UUID uuid, UUID serverUUID) throws DBException;
+    List<String> getNicknamesOfPlayerOnServer(UUID uuid, UUID serverUUID);
 
-    List<Action> getActions(UUID uuid) throws DBException;
+    List<Action> getActions(UUID uuid);
 
-    Map<UUID, UserInfo> getUsers() throws DBException;
+    Map<UUID, UserInfo> getUsers();
 
-    Map<UUID, Long> getLastSeenForAllPlayers() throws DBException;
+    Map<UUID, Long> getLastSeenForAllPlayers();
 
-    Map<UUID, List<GeoInfo>> getAllGeoInfo() throws DBException;
+    Map<UUID, List<GeoInfo>> getAllGeoInfo();
 
-    Map<UUID, String> getPlayerNames() throws DBException;
+    Map<UUID, String> getPlayerNames();
 
-    String getPlayerName(UUID playerUUID) throws DBException;
+    String getPlayerName(UUID playerUUID);
 
-    List<String> getNicknames(UUID uuid) throws DBException;
+    List<String> getNicknames(UUID uuid);
 
-    Map<UUID, Server> getBukkitServers() throws DBException;
+    Map<UUID, Server> getBukkitServers();
 
-    List<WebUser> getWebUsers() throws DBException;
+    List<WebUser> getWebUsers();
 
-    Map<Integer, String> getServerNamesByID() throws DBException;
+    Map<Integer, String> getServerNamesByID();
 
-    Map<UUID, Map<UUID, List<Session>>> getSessionsInLastMonth() throws DBException;
+    Map<UUID, Map<UUID, List<Session>>> getSessionsInLastMonth();
 
-    List<Server> getServers() throws DBException;
+    List<Server> getServers();
 
-    List<UUID> getServerUUIDs() throws DBException;
+    List<UUID> getServerUUIDs();
 
-    List<String> getNetworkGeolocations() throws DBException;
+    List<String> getNetworkGeolocations();
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/operation/RemoveOperations.java

@@ -1,18 +1,12 @@
 package com.djrapitops.plan.system.database.databases.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-
 import java.util.UUID;
 
 public interface RemoveOperations {
 
-    void player(UUID uuid) throws DBException;
+    void player(UUID uuid);
 
-    void player(UUID player, UUID server) throws DBException;
+    void everything();
 
-    void server(UUID serverUUID) throws DBException;
-
-    void everything() throws DBException;
-
-    void webUser(String name) throws DBException;
+    void webUser(String name);
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/operation/SaveOperations.java

@@ -4,7 +4,6 @@
  */
 package com.djrapitops.plan.system.database.databases.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.WebUser;
 import com.djrapitops.plan.data.container.*;
 import com.djrapitops.plan.system.info.server.Server;
@@ -15,7 +14,7 @@ import java.util.UUID;
 
 /**
  * Operation methods for saving data.
- *
+ * <p>
  * Note: Method names subject to change (TODO remove insert update and such)
  *
  * @author Rsl1122
@@ -24,50 +23,49 @@ public interface SaveOperations {
 
     // Bulk save
 
-    void insertTPS(Map<UUID, List<TPS>> ofServers) throws DBException;
+    void insertTPS(Map<UUID, List<TPS>> ofServers);
 
-    void insertCommandUsage(Map<UUID, Map<String, Integer>> ofServers) throws DBException;
+    void insertCommandUsage(Map<UUID, Map<String, Integer>> ofServers);
 
-    void insertUsers(Map<UUID, UserInfo> ofServers) throws DBException;
+    void insertUsers(Map<UUID, UserInfo> ofServers);
 
-    void insertSessions(Map<UUID, Map<UUID, List<Session>>> ofServers, boolean containsExtraData)
-            throws DBException;
+    void insertSessions(Map<UUID, Map<UUID, List<Session>>> ofServers, boolean containsExtraData);
 
-    void kickAmount(Map<UUID, Integer> ofUsers) throws DBException;
+    void kickAmount(Map<UUID, Integer> ofUsers);
 
-    void insertUserInfo(Map<UUID, List<UserInfo>> ofServers) throws DBException;
+    void insertUserInfo(Map<UUID, List<UserInfo>> ofServers);
 
-    void insertNicknames(Map<UUID, Map<UUID, List<String>>> ofServers) throws DBException;
+    void insertNicknames(Map<UUID, Map<UUID, List<String>>> ofServers);
 
-    void insertAllGeoInfo(Map<UUID, List<GeoInfo>> ofUsers) throws DBException;
+    void insertAllGeoInfo(Map<UUID, List<GeoInfo>> ofUsers);
 
     // Single data point
 
-    void banStatus(UUID uuid, boolean banned) throws DBException;
+    void banStatus(UUID uuid, boolean banned);
 
-    void opStatus(UUID uuid, boolean op) throws DBException;
+    void opStatus(UUID uuid, boolean op);
 
-    void registerNewUser(UUID uuid, long registered, String name) throws DBException;
+    void registerNewUser(UUID uuid, long registered, String name);
 
-    void action(UUID uuid, Action action) throws DBException;
+    void action(UUID uuid, Action action);
 
-    void geoInfo(UUID uuid, GeoInfo geoInfo) throws DBException;
+    void geoInfo(UUID uuid, GeoInfo geoInfo);
 
-    void playerWasKicked(UUID uuid) throws DBException;
+    void playerWasKicked(UUID uuid);
 
-    void playerName(UUID uuid, String playerName) throws DBException;
+    void playerName(UUID uuid, String playerName);
 
-    void playerDisplayName(UUID uuid, String displayName) throws DBException;
+    void playerDisplayName(UUID uuid, String displayName);
 
-    void registerNewUserOnThisServer(UUID uuid, long registered) throws DBException;
+    void registerNewUserOnThisServer(UUID uuid, long registered);
 
-    void commandUsed(String commandName) throws DBException;
+    void commandUsed(String commandName);
 
-    void insertTPSforThisServer(TPS tps) throws DBException;
+    void insertTPSforThisServer(TPS tps);
 
-    void session(UUID uuid, Session session) throws DBException;
+    void session(UUID uuid, Session session);
 
-    void serverInfoForThisServer(Server server) throws DBException;
+    void serverInfoForThisServer(Server server);
 
-    void webUser(WebUser webUser) throws DBException;
+    void webUser(WebUser webUser);
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/operation/SearchOperations.java

@@ -1,11 +1,9 @@
 package com.djrapitops.plan.system.database.databases.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-
 import java.util.List;
 
 public interface SearchOperations {
 
-    List<String> matchingPlayers(String search) throws DBException;
+    List<String> matchingPlayers(String search);
 
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/operation/TransferOperations.java

@@ -4,8 +4,6 @@
  */
 package com.djrapitops.plan.system.database.databases.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-
 import java.util.Optional;
 import java.util.UUID;
 
@@ -20,12 +18,12 @@ public interface TransferOperations {
 
     // Save
 
-    void storeConfigSettings(String encodedSettingString) throws DBException;
+    void storeConfigSettings(String encodedSettingString);
 
     // Get
 
     @Deprecated
-    Optional<UUID> getServerPlayerIsOnlineOn(UUID playerUUID) throws DBException;
+    Optional<UUID> getServerPlayerIsOnlineOn(UUID playerUUID);
 
-    Optional<String> getEncodedConfigSettings() throws DBException;
+    Optional<String> getEncodedConfigSettings();
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/SQLDB.java

@@ -1,10 +1,12 @@
 package com.djrapitops.plan.system.database.databases.sql;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.database.databases.operation.*;
 import com.djrapitops.plan.system.database.databases.sql.operation.*;
+import com.djrapitops.plan.system.database.databases.sql.processing.ExecStatement;
+import com.djrapitops.plan.system.database.databases.sql.processing.QueryStatement;
 import com.djrapitops.plan.system.database.databases.sql.tables.*;
 import com.djrapitops.plan.system.database.databases.sql.tables.move.Version8TransferTable;
 import com.djrapitops.plan.system.settings.Settings;
@@ -16,6 +18,7 @@ import com.djrapitops.plugin.task.RunnableFactory;
 import org.apache.commons.dbcp2.BasicDataSource;
 
 import java.sql.Connection;
+import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.util.List;
 import java.util.Map;
@@ -115,7 +118,7 @@ public abstract class SQLDB extends Database {
                     if (isOpen()) {
                         clean();
                     }
-                } catch (SQLException e) {
+                } catch (DBOpException e) {
                     Log.toLog(this.getClass(), e);
                     cancel();
                 }
@@ -151,7 +154,7 @@ public abstract class SQLDB extends Database {
                     public void run() {
                         try {
                             new Version8TransferTable(db).alterTablesToV10();
-                        } catch (DBInitException | SQLException e) {
+                        } catch (DBInitException | DBOpException e) {
                             Log.toLog(this.getClass(), e);
                         }
                     }
@@ -191,7 +194,7 @@ public abstract class SQLDB extends Database {
                 geoInfoTable.alterTableV18();
                 // version set in the runnable in above method
             }
-        } catch (SQLException e) {
+        } catch (DBOpException e) {
             throw new DBInitException("Failed to set-up Database", e);
         }
     }
@@ -249,15 +252,15 @@ public abstract class SQLDB extends Database {
         }
     }
 
-    public int getVersion() throws SQLException {
+    public int getVersion() {
         return versionTable.getVersion();
     }
 
-    public void setVersion(int version) throws SQLException {
+    public void setVersion(int version) {
         versionTable.setVersion(version);
     }
 
-    private void clean() throws SQLException {
+    private void clean() {
         tpsTable.clean();
         transferTable.clean();
         geoInfoTable.clean();
@@ -270,11 +273,7 @@ public abstract class SQLDB extends Database {
                 .map(Map.Entry::getKey)
                 .collect(Collectors.toList());
         for (UUID uuid : inactivePlayers) {
-            try {
-                removeOps.player(uuid);
-            } catch (DBException e) {
-                Log.toLog(this.getClass().getName(), e);
-            }
+            removeOps.player(uuid);
         }
         int removed = inactivePlayers.size();
         if (removed > 0) {
@@ -289,7 +288,7 @@ public abstract class SQLDB extends Database {
      * <p>
      * MySQL has Auto Commit enabled.
      */
-    public void commit(Connection connection) throws SQLException {
+    public void commit(Connection connection) {
         try {
             if (!usingMySQL) {
                 connection.commit();
@@ -303,9 +302,13 @@ public abstract class SQLDB extends Database {
         }
     }
 
-    public void returnToPool(Connection connection) throws SQLException {
-        if (usingMySQL && connection != null) {
-            connection.close();
+    public void returnToPool(Connection connection) {
+        try {
+            if (usingMySQL && connection != null) {
+                connection.close();
+            }
+        } catch (SQLException e) {
+            Log.toLog(this.getClass(), e);
         }
     }
 
@@ -324,6 +327,48 @@ public abstract class SQLDB extends Database {
         }
     }
 
+    public boolean execute(ExecStatement statement) {
+        Connection connection = null;
+        try {
+            connection = getConnection();
+            try (PreparedStatement preparedStatement = connection.prepareStatement(statement.getSql())) {
+                return statement.execute(preparedStatement);
+            }
+        } catch (SQLException e) {
+            throw DBOpException.forCause(statement.getSql(), e);
+        } finally {
+            commit(connection);
+        }
+    }
+
+    public void executeBatch(ExecStatement statement) {
+        Connection connection = null;
+        try {
+            connection = getConnection();
+            try (PreparedStatement preparedStatement = connection.prepareStatement(statement.getSql())) {
+                statement.executeBatch(preparedStatement);
+            }
+        } catch (SQLException e) {
+            throw DBOpException.forCause(statement.getSql(), e);
+        } finally {
+            commit(connection);
+        }
+    }
+
+    public <T> T query(QueryStatement<T> statement) {
+        Connection connection = null;
+        try {
+            connection = getConnection();
+            try (PreparedStatement preparedStatement = connection.prepareStatement(statement.getSql())) {
+                return statement.executeQuery(preparedStatement);
+            }
+        } catch (SQLException e) {
+            throw DBOpException.forCause(statement.getSql(), e);
+        } finally {
+            returnToPool(connection);
+        }
+    }
+
     public UsersTable getUsersTable() {
         return usersTable;
     }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLBackupOps.java

@@ -5,8 +5,6 @@ import com.djrapitops.plan.system.database.databases.operation.BackupOperations;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.database.databases.sql.tables.move.BatchOperationTable;
 
-import java.sql.SQLException;
-
 public class SQLBackupOps extends SQLOps implements BackupOperations {
 
     public SQLBackupOps(SQLDB db) {
@@ -14,7 +12,7 @@ public class SQLBackupOps extends SQLOps implements BackupOperations {
     }
 
     @Override
-    public void backup(Database toDatabase) throws SQLException {
+    public void backup(Database toDatabase) {
         BatchOperationTable toDB = new BatchOperationTable((SQLDB) toDatabase);
         BatchOperationTable fromDB = new BatchOperationTable(db);
 
@@ -23,7 +21,7 @@ public class SQLBackupOps extends SQLOps implements BackupOperations {
     }
 
     @Override
-    public void restore(Database fromDatabase) throws SQLException {
+    public void restore(Database fromDatabase) {
         fromDatabase.backup().backup(db);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLCheckOps.java

@@ -1,11 +1,9 @@
 package com.djrapitops.plan.system.database.databases.sql.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.operation.CheckOperations;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.info.server.ServerInfo;
 
-import java.sql.SQLException;
 import java.util.UUID;
 
 public class SQLCheckOps extends SQLOps implements CheckOperations {
@@ -15,43 +13,27 @@ public class SQLCheckOps extends SQLOps implements CheckOperations {
     }
 
     @Override
-    public boolean isPlayerRegistered(UUID player) throws DBException {
-        try {
-            return usersTable.isRegistered(player);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public boolean isPlayerRegistered(UUID player) {
+        return usersTable.isRegistered(player);
     }
 
     @Override
-    public boolean isPlayerRegistered(UUID player, UUID server) throws DBException {
-        try {
-            return userInfoTable.isRegistered(player, server);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public boolean isPlayerRegistered(UUID player, UUID server) {
+        return userInfoTable.isRegistered(player, server);
     }
 
     @Override
-    public boolean doesWebUserExists(String username) throws DBException {
-        try {
-            return securityTable.userExists(username);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public boolean doesWebUserExists(String username) {
+        return securityTable.userExists(username);
     }
 
     @Override
-    public boolean isPlayerRegisteredOnThisServer(UUID player) throws DBException {
+    public boolean isPlayerRegisteredOnThisServer(UUID player) {
         return isPlayerRegistered(player, ServerInfo.getServerUUID());
     }
 
     @Override
-    public boolean isServerInDatabase(UUID serverUUID) throws DBException {
-        try {
-            return serverTable.getServerID(serverUUID).isPresent();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public boolean isServerInDatabase(UUID serverUUID) {
+        return serverTable.getServerID(serverUUID).isPresent();
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLCountOps.java

@@ -1,10 +1,8 @@
 package com.djrapitops.plan.system.database.databases.sql.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.operation.CountOperations;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 
-import java.sql.SQLException;
 import java.util.UUID;
 
 public class SQLCountOps extends SQLOps implements CountOperations {
@@ -14,20 +12,12 @@ public class SQLCountOps extends SQLOps implements CountOperations {
     }
 
     @Override
-    public int getServerPlayerCount(UUID server) throws DBException {
-        try {
-            return userInfoTable.getServerUserCount(server);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public int getServerPlayerCount(UUID server) {
+        return userInfoTable.getServerUserCount(server);
     }
 
     @Override
-    public int getNetworkPlayerCount() throws DBException {
-        try {
-            return usersTable.getPlayerCount();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public int getNetworkPlayerCount() {
+        return usersTable.getPlayerCount();
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLFetchOps.java

@@ -1,7 +1,5 @@
 package com.djrapitops.plan.system.database.databases.sql.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.PlayerProfile;
 import com.djrapitops.plan.data.ServerProfile;
 import com.djrapitops.plan.data.WebUser;
@@ -13,7 +11,6 @@ import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.info.server.Server;
 import com.djrapitops.plugin.api.TimeAmount;
 
-import java.sql.SQLException;
 import java.util.*;
 
 public class SQLFetchOps extends SQLOps implements FetchOperations {
@@ -23,116 +20,91 @@ public class SQLFetchOps extends SQLOps implements FetchOperations {
     }
 
     @Override
-    public ServerProfile getServerProfile(UUID serverUUID) throws DBException {
-        try {
-            ServerProfile profile = new ServerProfile(serverUUID);
+    public ServerProfile getServerProfile(UUID serverUUID) {
+        ServerProfile profile = new ServerProfile(serverUUID);
 
-            profile.setPlayers(getPlayers(serverUUID));
-            profile.setTps(tpsTable.getTPSData(serverUUID));
-            Optional<TPS> allTimePeak = tpsTable.getAllTimePeak(serverUUID);
-            allTimePeak.ifPresent(peak -> {
-                profile.setAllTimePeak(peak.getDate());
-                profile.setAllTimePeakPlayers(peak.getPlayers());
-            });
-            Optional<TPS> lastPeak = tpsTable.getPeakPlayerCount(serverUUID, System.currentTimeMillis() - (TimeAmount.DAY.ms() * 2L));
-            lastPeak.ifPresent(peak -> {
-                profile.setLastPeakDate(peak.getDate());
-                profile.setLastPeakPlayers(peak.getPlayers());
-            });
+        profile.setPlayers(getPlayers(serverUUID));
+        profile.setTps(tpsTable.getTPSData(serverUUID));
+        Optional<TPS> allTimePeak = tpsTable.getAllTimePeak(serverUUID);
+        allTimePeak.ifPresent(peak -> {
+            profile.setAllTimePeak(peak.getDate());
+            profile.setAllTimePeakPlayers(peak.getPlayers());
+        });
+        Optional<TPS> lastPeak = tpsTable.getPeakPlayerCount(serverUUID, System.currentTimeMillis() - (TimeAmount.DAY.ms() * 2L));
+        lastPeak.ifPresent(peak -> {
+            profile.setLastPeakDate(peak.getDate());
+            profile.setLastPeakPlayers(peak.getPlayers());
+        });
 
-            profile.setCommandUsage(commandUseTable.getCommandUse(serverUUID));
-            profile.setServerWorldtimes(worldTimesTable.getWorldTimesOfServer(serverUUID));
+        profile.setCommandUsage(commandUseTable.getCommandUse(serverUUID));
+        profile.setServerWorldtimes(worldTimesTable.getWorldTimesOfServer(serverUUID));
 
-            return profile;
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+        return profile;
     }
 
     @Override
-    public List<PlayerProfile> getPlayers(UUID serverUUID) throws DBException {
-        try {
-            List<UserInfo> serverUserInfo = userInfoTable.getServerUserInfo(serverUUID);
-            Map<UUID, Integer> timesKicked = usersTable.getAllTimesKicked();
-            Map<UUID, List<Action>> actions = actionsTable.getServerActions(serverUUID);
-            Map<UUID, List<GeoInfo>> geoInfo = geoInfoTable.getAllGeoInfo();
+    public List<PlayerProfile> getPlayers(UUID serverUUID) {
+        List<UserInfo> serverUserInfo = userInfoTable.getServerUserInfo(serverUUID);
+        Map<UUID, Integer> timesKicked = usersTable.getAllTimesKicked();
+        Map<UUID, List<Action>> actions = actionsTable.getServerActions(serverUUID);
+        Map<UUID, List<GeoInfo>> geoInfo = geoInfoTable.getAllGeoInfo();
 
-            Map<UUID, List<Session>> sessions = sessionsTable.getSessionInfoOfServer(serverUUID);
-            Map<UUID, Map<UUID, List<Session>>> map = new HashMap<>();
-            map.put(serverUUID, sessions);
-            killsTable.addKillsToSessions(map);
-            worldTimesTable.addWorldTimesToSessions(map);
+        Map<UUID, List<Session>> sessions = sessionsTable.getSessionInfoOfServer(serverUUID);
+        Map<UUID, Map<UUID, List<Session>>> map = new HashMap<>();
+        map.put(serverUUID, sessions);
+        killsTable.addKillsToSessions(map);
+        worldTimesTable.addWorldTimesToSessions(map);
 
-            List<PlayerProfile> players = new ArrayList<>();
+        List<PlayerProfile> players = new ArrayList<>();
 
-            for (UserInfo userInfo : serverUserInfo) {
-                UUID uuid = userInfo.getUuid();
-                PlayerProfile profile = new PlayerProfile(uuid, userInfo.getName(), userInfo.getRegistered());
-                profile.setTimesKicked(timesKicked.getOrDefault(uuid, 0));
-                if (userInfo.isBanned()) {
-                    profile.bannedOnServer(serverUUID);
-                }
-                if (userInfo.isOpped()) {
-                    profile.oppedOnServer(serverUUID);
-                }
-                profile.setActions(actions.getOrDefault(uuid, new ArrayList<>()));
-                profile.setGeoInformation(geoInfo.getOrDefault(uuid, new ArrayList<>()));
-                profile.setSessions(serverUUID, sessions.getOrDefault(uuid, new ArrayList<>()));
-
-                players.add(profile);
+        for (UserInfo userInfo : serverUserInfo) {
+            UUID uuid = userInfo.getUuid();
+            PlayerProfile profile = new PlayerProfile(uuid, userInfo.getName(), userInfo.getRegistered());
+            profile.setTimesKicked(timesKicked.getOrDefault(uuid, 0));
+            if (userInfo.isBanned()) {
+                profile.bannedOnServer(serverUUID);
             }
-            return players;
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
+            if (userInfo.isOpped()) {
+                profile.oppedOnServer(serverUUID);
+            }
+            profile.setActions(actions.getOrDefault(uuid, new ArrayList<>()));
+            profile.setGeoInformation(geoInfo.getOrDefault(uuid, new ArrayList<>()));
+            profile.setSessions(serverUUID, sessions.getOrDefault(uuid, new ArrayList<>()));
+
+            players.add(profile);
         }
+        return players;
     }
 
     @Override
-    public PlayerProfile getPlayerProfile(UUID uuid) throws DBException {
-        try {
-            if (!usersTable.isRegistered(uuid)) {
-                return null;
-            }
-
-            String playerName = usersTable.getPlayerName(uuid);
-            Optional<Long> registerDate = usersTable.getRegisterDate(uuid);
-
-            if (!registerDate.isPresent()) {
-                throw new IllegalStateException("User has been saved with null register date to a NOT NULL column");
-            }
-
-            PlayerProfile profile = new PlayerProfile(uuid, playerName, registerDate.get());
-            profile.setTimesKicked(usersTable.getTimesKicked(uuid));
-
-            Map<UUID, UserInfo> userInfo = userInfoTable.getAllUserInfo(uuid);
-            addUserInfoToProfile(profile, userInfo);
-
-            profile.setActions(actionsTable.getActions(uuid));
-            profile.setNicknames(nicknamesTable.getAllNicknames(uuid));
-            profile.setGeoInformation(geoInfoTable.getGeoInfo(uuid));
-
-            Map<UUID, List<Session>> sessions = sessionsTable.getSessions(uuid);
-            profile.setSessions(sessions);
-            profile.calculateWorldTimesPerServer();
-            profile.setTotalWorldTimes(worldTimesTable.getWorldTimesOfUser(uuid));
-
-            return profile;
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        } catch (DBOpException e) {
-            throw new DBException(e);
+    public PlayerProfile getPlayerProfile(UUID uuid) {
+        if (!usersTable.isRegistered(uuid)) {
+            return null;
         }
-    }
 
-    @Override
-    public PlayerContainer getPlayerContainer(UUID uuid) {
-        PlayerContainer container = new PlayerContainer();
-        container.putRawData(PlayerKeys.UUID, uuid);
+        String playerName = usersTable.getPlayerName(uuid);
+        Optional<Long> registerDate = usersTable.getRegisterDate(uuid);
 
-        container.putAll(usersTable.getUserInformation(uuid));
+        if (!registerDate.isPresent()) {
+            throw new IllegalStateException("User has been saved with null register date to a NOT NULL column");
+        }
 
-        container.put(PlayerKeys.GEO_INFO, () -> GeoInfo.intoDateMap(geoInfoTable.getGeoInfo(uuid)));
-        return container;
+        PlayerProfile profile = new PlayerProfile(uuid, playerName, registerDate.get());
+        profile.setTimesKicked(usersTable.getTimesKicked(uuid));
+
+        Map<UUID, UserInfo> userInfo = userInfoTable.getAllUserInfo(uuid);
+        addUserInfoToProfile(profile, userInfo);
+
+        profile.setActions(actionsTable.getActions(uuid));
+        profile.setNicknames(nicknamesTable.getAllNicknames(uuid));
+        profile.setGeoInformation(geoInfoTable.getGeoInfo(uuid));
+
+        Map<UUID, List<Session>> sessions = sessionsTable.getSessions(uuid);
+        profile.setSessions(sessions);
+        profile.calculateWorldTimesPerServer();
+        profile.setTotalWorldTimes(worldTimesTable.getWorldTimesOfUser(uuid));
+
+        return profile;
     }
 
     private void addUserInfoToProfile(PlayerProfile profile, Map<UUID, UserInfo> userInfo) {
@@ -151,268 +123,163 @@ public class SQLFetchOps extends SQLOps implements FetchOperations {
     }
 
     @Override
-    public Set<UUID> getSavedUUIDs() throws DBException {
-        try {
-            return usersTable.getSavedUUIDs();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public PlayerContainer getPlayerContainer(UUID uuid) {
+        PlayerContainer container = new PlayerContainer();
+        container.putRawData(PlayerKeys.UUID, uuid);
+
+        container.putAll(usersTable.getUserInformation(uuid));
+        container.put(PlayerKeys.GEO_INFO, () -> GeoInfo.intoDateMap(geoInfoTable.getGeoInfo(uuid)));
+        container.put(PlayerKeys.NICKNAMES, () -> nicknamesTable.getNicknameInformation(uuid));
+        return container;
     }
 
     @Override
-    public Set<UUID> getSavedUUIDs(UUID server) throws DBException {
-        try {
-            return userInfoTable.getSavedUUIDs(server);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Set<UUID> getSavedUUIDs() {
+        return usersTable.getSavedUUIDs();
     }
 
     @Override
-    public Map<UUID, String> getServerNames() throws DBException {
-        try {
-            return serverTable.getServerNames();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Set<UUID> getSavedUUIDs(UUID server) {
+        return userInfoTable.getSavedUUIDs(server);
     }
 
     @Override
-    public Optional<UUID> getServerUUID(String serverName) throws DBException {
-        try {
-            return serverTable.getServerUUID(serverName);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, String> getServerNames() {
+        return serverTable.getServerNames();
     }
 
     @Override
-    public UUID getUuidOf(String playerName) throws DBException {
-        try {
-            return usersTable.getUuidOf(playerName);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Optional<UUID> getServerUUID(String serverName) {
+        return serverTable.getServerUUID(serverName);
     }
 
     @Override
-    public WebUser getWebUser(String username) throws DBException {
-        try {
-            return securityTable.getWebUser(username);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public UUID getUuidOf(String playerName) {
+        return usersTable.getUuidOf(playerName);
     }
 
     @Override
-    public List<TPS> getTPSData(UUID serverUUID) throws DBException {
-        try {
-            return tpsTable.getTPSData(serverUUID);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public WebUser getWebUser(String username) {
+        return securityTable.getWebUser(username);
     }
 
     @Override
-    public List<TPS> getNetworkOnlineData() throws DBException {
-        try {
-            return tpsTable.getNetworkOnlineData();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<TPS> getTPSData(UUID serverUUID) {
+        return tpsTable.getTPSData(serverUUID);
     }
 
     @Override
-    public List<Long> getRegisterDates() throws DBException {
-        try {
-            return usersTable.getRegisterDates();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<TPS> getNetworkOnlineData() {
+        return tpsTable.getNetworkOnlineData();
     }
 
     @Override
-    public Optional<TPS> getAllTimePeak(UUID serverUUID) throws DBException {
-        try {
-            return tpsTable.getAllTimePeak(serverUUID);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<Long> getRegisterDates() {
+        return usersTable.getRegisterDates();
     }
 
     @Override
-    public Optional<TPS> getPeakPlayerCount(UUID serverUUID, long afterDate) throws DBException {
-        try {
-            return tpsTable.getPeakPlayerCount(serverUUID, afterDate);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Optional<TPS> getAllTimePeak(UUID serverUUID) {
+        return tpsTable.getAllTimePeak(serverUUID);
     }
 
     @Override
-    public Map<UUID, Map<UUID, List<Session>>> getSessionsWithNoExtras() throws DBException {
-        try {
-            return sessionsTable.getAllSessions(false);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Optional<TPS> getPeakPlayerCount(UUID serverUUID, long afterDate) {
+        return tpsTable.getPeakPlayerCount(serverUUID, afterDate);
     }
 
     @Override
-    public Map<UUID, Map<UUID, List<Session>>> getSessionsAndExtras() throws DBException {
-        try {
-            return sessionsTable.getAllSessions(true);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, Map<UUID, List<Session>>> getSessionsWithNoExtras() {
+        return sessionsTable.getAllSessions(false);
     }
 
     @Override
-    public Map<UUID, Map<UUID, List<Session>>> getSessionsInLastMonth() throws DBException {
-        try {
-            return sessionsTable.getSessionInLastMonth();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, Map<UUID, List<Session>>> getSessionsAndExtras() {
+        return sessionsTable.getAllSessions(true);
     }
 
     @Override
-    public Set<String> getWorldNames(UUID serverUuid) throws DBException {
-        try {
-            return worldTable.getWorldNames(serverUuid);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, Map<UUID, List<Session>>> getSessionsInLastMonth() {
+        return sessionsTable.getSessionInLastMonth();
     }
 
     @Override
-    public List<String> getNicknamesOfPlayerOnServer(UUID uuid, UUID serverUUID) throws DBException {
-        try {
-            return nicknamesTable.getNicknames(uuid, serverUUID);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Set<String> getWorldNames(UUID serverUuid) {
+        return worldTable.getWorldNames(serverUuid);
     }
 
     @Override
-    public List<Action> getActions(UUID uuid) throws DBException {
-        try {
-            return actionsTable.getActions(uuid);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<String> getNicknamesOfPlayerOnServer(UUID uuid, UUID serverUUID) {
+        return nicknamesTable.getNicknames(uuid, serverUUID);
     }
 
     @Override
-    public Map<UUID, UserInfo> getUsers() throws DBException {
-        try {
-            return usersTable.getUsers();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<Action> getActions(UUID uuid) {
+        return actionsTable.getActions(uuid);
     }
 
     @Override
-    public Map<UUID, Long> getLastSeenForAllPlayers() throws DBException {
-        try {
-            return sessionsTable.getLastSeenForAllPlayers();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, UserInfo> getUsers() {
+        return usersTable.getUsers();
     }
 
     @Override
-    public Map<UUID, List<GeoInfo>> getAllGeoInfo() throws DBException {
-        try {
-            return geoInfoTable.getAllGeoInfo();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, Long> getLastSeenForAllPlayers() {
+        return sessionsTable.getLastSeenForAllPlayers();
     }
 
     @Override
-    public Map<UUID, String> getPlayerNames() throws DBException {
-        try {
-            return usersTable.getPlayerNames();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, List<GeoInfo>> getAllGeoInfo() {
+        return geoInfoTable.getAllGeoInfo();
     }
 
     @Override
-    public String getPlayerName(UUID playerUUID) throws DBException {
-        try {
-            return usersTable.getPlayerName(playerUUID);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, String> getPlayerNames() {
+        return usersTable.getPlayerNames();
     }
 
     @Override
-    public Optional<String> getServerName(UUID serverUUID) throws DBException {
-        try {
-            return serverTable.getServerName(serverUUID);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public String getPlayerName(UUID playerUUID) {
+        return usersTable.getPlayerName(playerUUID);
     }
 
     @Override
-    public List<String> getNicknames(UUID uuid) throws DBException {
-        try {
-            return nicknamesTable.getNicknames(uuid);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Optional<String> getServerName(UUID serverUUID) {
+        return serverTable.getServerName(serverUUID);
     }
 
     @Override
-    public Optional<Server> getBungeeInformation() throws DBException {
-        try {
-            return serverTable.getBungeeInfo();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<String> getNicknames(UUID uuid) {
+        return nicknamesTable.getNicknames(uuid);
     }
 
     @Override
-    public Optional<Integer> getServerID(UUID serverUUID) throws DBException {
-        try {
-            return serverTable.getServerID(serverUUID);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Optional<Server> getBungeeInformation() {
+        return serverTable.getBungeeInfo();
     }
 
     @Override
-    public Map<UUID, Server> getBukkitServers() throws DBException {
-        try {
-            return serverTable.getBukkitServers();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Optional<Integer> getServerID(UUID serverUUID) {
+        return serverTable.getServerID(serverUUID);
     }
 
     @Override
-    public List<WebUser> getWebUsers() throws DBException {
-        try {
-            return securityTable.getUsers();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Map<UUID, Server> getBukkitServers() {
+        return serverTable.getBukkitServers();
     }
 
     @Override
-    public Map<Integer, String> getServerNamesByID() throws DBException {
-        try {
-            return serverTable.getServerNamesByID();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<WebUser> getWebUsers() {
+        return securityTable.getUsers();
     }
 
     @Override
-    public List<Server> getServers() throws DBException {
+    public Map<Integer, String> getServerNamesByID() {
+        return serverTable.getServerNamesByID();
+    }
+
+    @Override
+    public List<Server> getServers() {
         Map<UUID, Server> bukkitServers = getBukkitServers();
         Optional<Server> bungeeInformation = getBungeeInformation();
 
@@ -424,20 +291,12 @@ public class SQLFetchOps extends SQLOps implements FetchOperations {
     }
 
     @Override
-    public List<UUID> getServerUUIDs() throws DBException {
-        try {
-            return serverTable.getServerUUIDs();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<UUID> getServerUUIDs() {
+        return serverTable.getServerUUIDs();
     }
 
     @Override
-    public List<String> getNetworkGeolocations() throws DBException {
-        try {
-            return geoInfoTable.getNetworkGeolocations();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<String> getNetworkGeolocations() {
+        return geoInfoTable.getNetworkGeolocations();
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLRemoveOps.java

@@ -1,13 +1,10 @@
 package com.djrapitops.plan.system.database.databases.sql.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-import com.djrapitops.plan.api.exceptions.database.FatalDBException;
 import com.djrapitops.plan.system.database.databases.operation.RemoveOperations;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.database.databases.sql.tables.Table;
 import com.djrapitops.plan.system.database.databases.sql.tables.UserIDTable;
 
-import java.sql.SQLException;
 import java.util.UUID;
 
 public class SQLRemoveOps extends SQLOps implements RemoveOperations {
@@ -17,56 +14,34 @@ public class SQLRemoveOps extends SQLOps implements RemoveOperations {
     }
 
     @Override
-    public void player(UUID uuid) throws DBException {
+    public void player(UUID uuid) {
         if (uuid == null) {
             return;
         }
 
-        try {
-            String webUser = usersTable.getPlayerName(uuid);
+        String webUser = usersTable.getPlayerName(uuid);
 
-            for (Table t : db.getAllTablesInRemoveOrder()) {
-                if (!(t instanceof UserIDTable)) {
-                    continue;
-                }
-
-                UserIDTable table = (UserIDTable) t;
-                table.removeUser(uuid);
+        for (Table t : db.getAllTablesInRemoveOrder()) {
+            if (!(t instanceof UserIDTable)) {
+                continue;
             }
 
-            securityTable.removeUser(webUser);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getFatalExceptionFor(e);
+            UserIDTable table = (UserIDTable) t;
+            table.removeUser(uuid);
+        }
+
+        securityTable.removeUser(webUser);
+    }
+
+    @Override
+    public void everything() {
+        for (Table table : db.getAllTablesInRemoveOrder()) {
+            table.removeAllData();
         }
     }
 
     @Override
-    public void player(UUID player, UUID server) throws DBException {
-        throw new FatalDBException("Not Implemented");
-    }
-
-    @Override
-    public void server(UUID serverUUID) throws DBException {
-        throw new FatalDBException("Not Implemented");
-    }
-
-    @Override
-    public void everything() throws DBException {
-        try {
-            for (Table table : db.getAllTablesInRemoveOrder()) {
-                table.removeAllData();
-            }
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getFatalExceptionFor(e);
-        }
-    }
-
-    @Override
-    public void webUser(String userName) throws DBException {
-        try {
-            securityTable.removeUser(userName);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getFatalExceptionFor(e);
-        }
+    public void webUser(String userName) {
+        securityTable.removeUser(userName);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLSaveOps.java

@@ -4,14 +4,12 @@
  */
 package com.djrapitops.plan.system.database.databases.sql.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.WebUser;
 import com.djrapitops.plan.data.container.*;
 import com.djrapitops.plan.system.database.databases.operation.SaveOperations;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.info.server.Server;
 
-import java.sql.SQLException;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
@@ -28,200 +26,112 @@ public class SQLSaveOps extends SQLOps implements SaveOperations {
     }
 
     @Override
-    public void insertTPS(Map<UUID, List<TPS>> ofServers) throws DBException {
-        try {
-            tpsTable.insertAllTPS(ofServers);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void insertTPS(Map<UUID, List<TPS>> ofServers) {
+        tpsTable.insertAllTPS(ofServers);
     }
 
     @Override
-    public void insertCommandUsage(Map<UUID, Map<String, Integer>> ofServers) throws DBException {
-        try {
-            commandUseTable.insertCommandUsage(ofServers);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void insertCommandUsage(Map<UUID, Map<String, Integer>> ofServers) {
+        commandUseTable.insertCommandUsage(ofServers);
     }
 
     @Override
-    public void insertUsers(Map<UUID, UserInfo> ofServers) throws DBException {
-        try {
-            usersTable.insertUsers(ofServers);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void insertUsers(Map<UUID, UserInfo> ofServers) {
+        usersTable.insertUsers(ofServers);
     }
 
     @Override
-    public void insertSessions(Map<UUID, Map<UUID, List<Session>>> ofServers, boolean containsExtraData) throws DBException {
-        try {
-            sessionsTable.insertSessions(ofServers, containsExtraData);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void insertSessions(Map<UUID, Map<UUID, List<Session>>> ofServers, boolean containsExtraData) {
+        sessionsTable.insertSessions(ofServers, containsExtraData);
     }
 
     @Override
-    public void kickAmount(Map<UUID, Integer> ofUsers) throws DBException {
-        try {
-            usersTable.updateKicked(ofUsers);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void kickAmount(Map<UUID, Integer> ofUsers) {
+        usersTable.updateKicked(ofUsers);
     }
 
     @Override
-    public void insertUserInfo(Map<UUID, List<UserInfo>> ofServers) throws DBException {
-        try {
-            userInfoTable.insertUserInfo(ofServers);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void insertUserInfo(Map<UUID, List<UserInfo>> ofServers) {
+        userInfoTable.insertUserInfo(ofServers);
     }
 
     @Override
-    public void insertNicknames(Map<UUID, Map<UUID, List<String>>> ofServers) throws DBException {
-        try {
-            nicknamesTable.insertNicknames(ofServers);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void insertNicknames(Map<UUID, Map<UUID, List<String>>> ofServers) {
+        nicknamesTable.insertNicknames(ofServers);
     }
 
     @Override
-    public void insertAllGeoInfo(Map<UUID, List<GeoInfo>> ofUsers) throws DBException {
-        try {
-            geoInfoTable.insertAllGeoInfo(ofUsers);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void insertAllGeoInfo(Map<UUID, List<GeoInfo>> ofUsers) {
+        geoInfoTable.insertAllGeoInfo(ofUsers);
     }
 
     @Override
-    public void banStatus(UUID uuid, boolean banned) throws DBException {
-        try {
-            userInfoTable.updateBanStatus(uuid, banned);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void banStatus(UUID uuid, boolean banned) {
+        userInfoTable.updateBanStatus(uuid, banned);
     }
 
     @Override
-    public void opStatus(UUID uuid, boolean op) throws DBException {
-        try {
-            userInfoTable.updateOpStatus(uuid, op);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void opStatus(UUID uuid, boolean op) {
+        userInfoTable.updateOpStatus(uuid, op);
     }
 
     @Override
-    public void registerNewUser(UUID uuid, long registered, String name) throws DBException {
-        try {
-            usersTable.registerUser(uuid, registered, name);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void registerNewUser(UUID uuid, long registered, String name) {
+        usersTable.registerUser(uuid, registered, name);
     }
 
     @Override
-    public void action(UUID uuid, Action action) throws DBException {
-        try {
-            actionsTable.insertAction(uuid, action);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void action(UUID uuid, Action action) {
+        actionsTable.insertAction(uuid, action);
     }
 
     @Override
-    public void geoInfo(UUID uuid, GeoInfo geoInfo) throws DBException {
-        try {
-            geoInfoTable.saveGeoInfo(uuid, geoInfo);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void geoInfo(UUID uuid, GeoInfo geoInfo) {
+        geoInfoTable.saveGeoInfo(uuid, geoInfo);
     }
 
     @Override
-    public void playerWasKicked(UUID uuid) throws DBException {
-        try {
-            usersTable.kicked(uuid);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void playerWasKicked(UUID uuid) {
+        usersTable.kicked(uuid);
     }
 
     @Override
-    public void playerName(UUID uuid, String playerName) throws DBException {
-        try {
-            usersTable.updateName(uuid, playerName);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void playerName(UUID uuid, String playerName) {
+        usersTable.updateName(uuid, playerName);
     }
 
     @Override
-    public void playerDisplayName(UUID uuid, String displayName) throws DBException {
-        try {
-            nicknamesTable.saveUserName(uuid, displayName);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void playerDisplayName(UUID uuid, String displayName) {
+        nicknamesTable.saveUserName(uuid, displayName);
     }
 
     @Override
-    public void registerNewUserOnThisServer(UUID uuid, long registered) throws DBException {
-        try {
-            userInfoTable.registerUserInfo(uuid, registered);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void registerNewUserOnThisServer(UUID uuid, long registered) {
+        userInfoTable.registerUserInfo(uuid, registered);
     }
 
     @Override
-    public void commandUsed(String commandName) throws DBException {
-        try {
-            commandUseTable.commandUsed(commandName);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void commandUsed(String commandName) {
+        commandUseTable.commandUsed(commandName);
     }
 
     @Override
-    public void insertTPSforThisServer(TPS tps) throws DBException {
-        try {
-            tpsTable.insertTPS(tps);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void insertTPSforThisServer(TPS tps) {
+        tpsTable.insertTPS(tps);
     }
 
     @Override
-    public void session(UUID uuid, Session session) throws DBException {
-        try {
-            sessionsTable.saveSession(uuid, session);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void session(UUID uuid, Session session) {
+        sessionsTable.saveSession(uuid, session);
     }
 
     @Override
-    public void serverInfoForThisServer(Server server) throws DBException {
-        try {
-            serverTable.saveCurrentServerInfo(server);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void serverInfoForThisServer(Server server) {
+        serverTable.saveCurrentServerInfo(server);
     }
 
     @Override
-    public void webUser(WebUser webUser) throws DBException {
-        try {
-            securityTable.addNewUser(webUser);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void webUser(WebUser webUser) {
+        securityTable.addNewUser(webUser);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLSearchOps.java

@@ -1,10 +1,8 @@
 package com.djrapitops.plan.system.database.databases.sql.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.operation.SearchOperations;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 
-import java.sql.SQLException;
 import java.util.List;
 
 public class SQLSearchOps extends SQLOps implements SearchOperations {
@@ -14,11 +12,7 @@ public class SQLSearchOps extends SQLOps implements SearchOperations {
     }
 
     @Override
-    public List<String> matchingPlayers(String search) throws DBException {
-        try {
-            return usersTable.getMatchingNames(search);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public List<String> matchingPlayers(String search) {
+        return usersTable.getMatchingNames(search);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/operation/SQLTransferOps.java

@@ -4,11 +4,9 @@
  */
 package com.djrapitops.plan.system.database.databases.sql.operation;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.operation.TransferOperations;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 
-import java.sql.SQLException;
 import java.util.Optional;
 import java.util.UUID;
 
@@ -24,30 +22,18 @@ public class SQLTransferOps extends SQLOps implements TransferOperations {
     }
 
     @Override
-    public Optional<UUID> getServerPlayerIsOnlineOn(UUID playerUUID) throws DBException {
-        try {
-            return transferTable.getServerPlayerIsOnline(playerUUID);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Optional<UUID> getServerPlayerIsOnlineOn(UUID playerUUID) {
+        return transferTable.getServerPlayerIsOnline(playerUUID);
     }
 
     @Override
-    public void storeConfigSettings(String encodedSettingString) throws DBException {
-        try {
-            transferTable.storeConfigSettings(encodedSettingString);
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public void storeConfigSettings(String encodedSettingString) {
+        transferTable.storeConfigSettings(encodedSettingString);
     }
 
     @Override
-    public Optional<String> getEncodedConfigSettings() throws DBException {
-        try {
-            return transferTable.getConfigSettings();
-        } catch (SQLException e) {
-            throw SQLErrorUtil.getExceptionFor(e);
-        }
+    public Optional<String> getEncodedConfigSettings() {
+        return transferTable.getConfigSettings();
     }
 
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/ActionsTable.java

@@ -78,9 +78,8 @@ public class ActionsTable extends UserIDTable {
      *
      * @param uuid UUID of the player
      * @return List of actions done by the player. Does not include the kills.
-     * @throws SQLException DB Error
      */
-    public List<Action> getActions(UUID uuid) throws SQLException {
+    public List<Action> getActions(UUID uuid) {
         String sql = Select.all(tableName)
                 .where(Col.USER_ID + "=" + usersTable.statementSelectID)
                 .toString();
@@ -106,7 +105,7 @@ public class ActionsTable extends UserIDTable {
         });
     }
 
-    public void insertAction(UUID uuid, Action action) throws SQLException {
+    public void insertAction(UUID uuid, Action action) {
         execute(new ExecStatement(insertStatement) {
             @Override
             public void prepare(PreparedStatement statement) throws SQLException {
@@ -119,7 +118,7 @@ public class ActionsTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, Map<UUID, List<Action>>> getAllActions() throws SQLException {
+    public Map<UUID, Map<UUID, List<Action>>> getAllActions() {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
@@ -159,7 +158,7 @@ public class ActionsTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, List<Action>> getServerActions(UUID serverUUID) throws SQLException {
+    public Map<UUID, List<Action>> getServerActions(UUID serverUUID) {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String sql = "SELECT " +
@@ -198,7 +197,7 @@ public class ActionsTable extends UserIDTable {
         });
     }
 
-    public void insertActions(Map<UUID, Map<UUID, List<Action>>> allActions) throws SQLException {
+    public void insertActions(Map<UUID, Map<UUID, List<Action>>> allActions) {
         if (Verify.isEmpty(allActions)) {
             return;
         }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/CommandUseTable.java

@@ -62,9 +62,8 @@ public class CommandUseTable extends Table {
      *
      * @param serverUUID UUID of the server.
      * @return command - times used Map
-     * @throws SQLException DB Error
      */
-    public Map<String, Integer> getCommandUse(UUID serverUUID) throws SQLException {
+    public Map<String, Integer> getCommandUse(UUID serverUUID) {
         String sql = Select.from(tableName,
                 Col.COMMAND, Col.TIMES_USED)
                 .where(Col.SERVER_ID + "=" + serverTable.statementSelectServerID)
@@ -93,13 +92,12 @@ public class CommandUseTable extends Table {
      * Used to get all commands used in this server.
      *
      * @return command - times used Map
-     * @throws SQLException DB Error
      */
-    public Map<String, Integer> getCommandUse() throws SQLException {
+    public Map<String, Integer> getCommandUse() {
         return getCommandUse(ServerInfo.getServerUUID());
     }
 
-    public void commandUsed(String command) throws SQLException {
+    public void commandUsed(String command) {
         if (command.length() > 20) {
             return;
         }
@@ -121,7 +119,7 @@ public class CommandUseTable extends Table {
         }
     }
 
-    public Optional<String> getCommandByID(int id) throws SQLException {
+    public Optional<String> getCommandByID(int id) {
         String sql = Select.from(tableName, Col.COMMAND).where(Col.COMMAND_ID + "=?").toString();
 
         return query(new QueryStatement<Optional<String>>(sql) {
@@ -140,7 +138,7 @@ public class CommandUseTable extends Table {
         });
     }
 
-    private void insertCommand(String command) throws SQLException {
+    private void insertCommand(String command) {
         execute(new ExecStatement(insertStatement) {
             @Override
             public void prepare(PreparedStatement statement) throws SQLException {
@@ -151,7 +149,7 @@ public class CommandUseTable extends Table {
         });
     }
 
-    public Optional<Integer> getCommandID(String command) throws SQLException {
+    public Optional<Integer> getCommandID(String command) {
         String sql = Select.from(tableName, Col.COMMAND_ID).where(Col.COMMAND + "=?").toString();
 
         return query(new QueryStatement<Optional<Integer>>(sql) {
@@ -170,7 +168,7 @@ public class CommandUseTable extends Table {
         });
     }
 
-    public Map<UUID, Map<String, Integer>> getAllCommandUsages() throws SQLException {
+    public Map<UUID, Map<String, Integer>> getAllCommandUsages() {
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
         String serverUUIDColumn = serverTable + "." + ServerTable.Col.SERVER_UUID + " as s_uuid";
         String sql = "SELECT " +
@@ -223,7 +221,7 @@ public class CommandUseTable extends Table {
         }
     }
 
-    public void insertCommandUsage(Map<UUID, Map<String, Integer>> allCommandUsages) throws SQLException {
+    public void insertCommandUsage(Map<UUID, Map<String, Integer>> allCommandUsages) {
         if (allCommandUsages.isEmpty()) {
             return;
         }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/GeoInfoTable.java

@@ -119,7 +119,7 @@ public class GeoInfoTable extends UserIDTable {
                     });
                     new Version18TransferTable(db).alterTableV18();
                     db.setVersion(18);
-                } catch (SQLException | DBInitException e) {
+                } catch (DBOpException | DBInitException e) {
                     Log.toLog(this.getClass(), e);
                 }
             }
@@ -134,32 +134,28 @@ public class GeoInfoTable extends UserIDTable {
         String sql = "SELECT DISTINCT * FROM " + tableName +
                 " WHERE " + Col.USER_ID + "=" + usersTable.statementSelectID;
 
-        try {
-            return query(new QueryStatement<List<GeoInfo>>(sql, 100) {
-                @Override
-                public void prepare(PreparedStatement statement) throws SQLException {
-                    statement.setString(1, uuid.toString());
-                }
+        return query(new QueryStatement<List<GeoInfo>>(sql, 100) {
+            @Override
+            public void prepare(PreparedStatement statement) throws SQLException {
+                statement.setString(1, uuid.toString());
+            }
 
-                @Override
-                public List<GeoInfo> processResults(ResultSet set) throws SQLException {
-                    List<GeoInfo> geoInfo = new ArrayList<>();
-                    while (set.next()) {
-                        String ip = set.getString(Col.IP.get());
-                        String geolocation = set.getString(Col.GEOLOCATION.get());
-                        String ipHash = set.getString(Col.IP_HASH.get());
-                        long lastUsed = set.getLong(Col.LAST_USED.get());
-                        geoInfo.add(new GeoInfo(ip, geolocation, lastUsed, ipHash));
-                    }
-                    return geoInfo;
+            @Override
+            public List<GeoInfo> processResults(ResultSet set) throws SQLException {
+                List<GeoInfo> geoInfo = new ArrayList<>();
+                while (set.next()) {
+                    String ip = set.getString(Col.IP.get());
+                    String geolocation = set.getString(Col.GEOLOCATION.get());
+                    String ipHash = set.getString(Col.IP_HASH.get());
+                    long lastUsed = set.getLong(Col.LAST_USED.get());
+                    geoInfo.add(new GeoInfo(ip, geolocation, lastUsed, ipHash));
                 }
-            });
-        } catch (SQLException e) {
-            throw new DBOpException("SQL Failed: " + sql, e);
-        }
+                return geoInfo;
+            }
+        });
     }
 
-    private void updateGeoInfo(UUID uuid, GeoInfo info) throws SQLException {
+    private void updateGeoInfo(UUID uuid, GeoInfo info) {
         String sql = "UPDATE " + tableName + " SET "
                 + Col.LAST_USED + "=?" +
                 " WHERE " + Col.USER_ID + "=" + usersTable.statementSelectID +
@@ -177,7 +173,7 @@ public class GeoInfoTable extends UserIDTable {
         });
     }
 
-    public void saveGeoInfo(UUID uuid, GeoInfo info) throws SQLException {
+    public void saveGeoInfo(UUID uuid, GeoInfo info) {
         List<GeoInfo> geoInfo = getGeoInfo(uuid);
         if (geoInfo.contains(info)) {
             updateGeoInfo(uuid, info);
@@ -186,7 +182,7 @@ public class GeoInfoTable extends UserIDTable {
         }
     }
 
-    private void insertGeoInfo(UUID uuid, GeoInfo info) throws SQLException {
+    private void insertGeoInfo(UUID uuid, GeoInfo info) {
         execute(new ExecStatement(insertStatement) {
             @Override
             public void prepare(PreparedStatement statement) throws SQLException {
@@ -199,7 +195,7 @@ public class GeoInfoTable extends UserIDTable {
         });
     }
 
-    public Optional<String> getGeolocation(String ip) throws SQLException {
+    public Optional<String> getGeolocation(String ip) {
         String sql = Select.from(tableName, Col.GEOLOCATION)
                 .where(Col.IP + "=?")
                 .toString();
@@ -220,7 +216,7 @@ public class GeoInfoTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, List<GeoInfo>> getAllGeoInfo() throws SQLException {
+    public Map<UUID, List<GeoInfo>> getAllGeoInfo() {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String sql = "SELECT " +
@@ -254,7 +250,7 @@ public class GeoInfoTable extends UserIDTable {
         });
     }
 
-    public List<String> getNetworkGeolocations() throws SQLException {
+    public List<String> getNetworkGeolocations() {
         List<String> geolocations = new ArrayList<>();
 
         Map<UUID, List<GeoInfo>> geoInfo = getAllGeoInfo();
@@ -269,7 +265,7 @@ public class GeoInfoTable extends UserIDTable {
         return geolocations;
     }
 
-    public void insertAllGeoInfo(Map<UUID, List<GeoInfo>> allIPsAndGeolocations) throws SQLException {
+    public void insertAllGeoInfo(Map<UUID, List<GeoInfo>> allIPsAndGeolocations) {
         if (Verify.isEmpty(allIPsAndGeolocations)) {
             return;
         }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/KillsTable.java

@@ -70,7 +70,7 @@ public class KillsTable extends UserIDTable {
     }
 
     @Override
-    public void removeUser(UUID uuid) throws SQLException {
+    public void removeUser(UUID uuid) {
         String sql = "DELETE FROM " + tableName +
                 " WHERE " + Col.KILLER_ID + " = " + usersTable.statementSelectID +
                 " OR " + Col.VICTIM_ID + " = " + usersTable.statementSelectID;
@@ -84,7 +84,7 @@ public class KillsTable extends UserIDTable {
         });
     }
 
-    public void addKillsToSessions(UUID uuid, Map<Integer, Session> sessions) throws SQLException {
+    public void addKillsToSessions(UUID uuid, Map<Integer, Session> sessions) {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as victim_uuid";
         String sql = "SELECT " +
@@ -121,7 +121,7 @@ public class KillsTable extends UserIDTable {
         });
     }
 
-    public void savePlayerKills(UUID uuid, int sessionID, List<PlayerKill> playerKills) throws SQLException {
+    public void savePlayerKills(UUID uuid, int sessionID, List<PlayerKill> playerKills) {
         if (Verify.isEmpty(playerKills)) {
             return;
         }
@@ -149,7 +149,7 @@ public class KillsTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, List<PlayerKill>> getPlayerKills() throws SQLException {
+    public Map<UUID, List<PlayerKill>> getPlayerKills() {
         String usersVictimIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersKillerIDColumn = "a." + UsersTable.Col.ID;
         String usersVictimUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as victim_uuid";
@@ -181,7 +181,7 @@ public class KillsTable extends UserIDTable {
         });
     }
 
-    public Map<Integer, List<PlayerKill>> getAllPlayerKillsBySessionID() throws SQLException {
+    public Map<Integer, List<PlayerKill>> getAllPlayerKillsBySessionID() {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as victim_uuid";
         String sql = "SELECT " +
@@ -214,7 +214,7 @@ public class KillsTable extends UserIDTable {
         });
     }
 
-    public void addKillsToSessions(Map<UUID, Map<UUID, List<Session>>> map) throws SQLException {
+    public void addKillsToSessions(Map<UUID, Map<UUID, List<Session>>> map) {
         Map<Integer, List<PlayerKill>> playerKillsBySessionID = getAllPlayerKillsBySessionID();
         for (UUID serverUUID : map.keySet()) {
             for (List<Session> sessions : map.get(serverUUID).values()) {
@@ -228,7 +228,7 @@ public class KillsTable extends UserIDTable {
         }
     }
 
-    public void savePlayerKills(Map<UUID, Map<UUID, List<Session>>> allSessions) throws SQLException {
+    public void savePlayerKills(Map<UUID, Map<UUID, List<Session>>> allSessions) {
         if (Verify.isEmpty(allSessions)) {
             return;
         }
@@ -265,7 +265,7 @@ public class KillsTable extends UserIDTable {
         });
     }
 
-    public void alterTableV16() throws SQLException {
+    public void alterTableV16() {
         addColumns(Col.SERVER_ID + " integer NOT NULL DEFAULT 0");
 
         Map<Integer, Integer> sessionIDServerIDRelation = sessionsTable.getIDServerIDRelation();

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/NicknamesTable.java

@@ -1,6 +1,7 @@
 package com.djrapitops.plan.system.database.databases.sql.tables;
 
 import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.data.store.objects.Nickname;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.database.databases.sql.processing.ExecStatement;
 import com.djrapitops.plan.system.database.databases.sql.processing.QueryAllStatement;
@@ -64,9 +65,8 @@ public class NicknamesTable extends UserIDTable {
      *
      * @param uuid UUID of the Player
      * @return The nicknames of the User in a map by ServerUUID
-     * @throws SQLException when an error at retrieval happens
      */
-    public Map<UUID, List<String>> getAllNicknames(UUID uuid) throws SQLException {
+    public Map<UUID, List<String>> getAllNicknames(UUID uuid) {
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
         String serverUUIDColumn = serverTable + "." + ServerTable.Col.SERVER_UUID + " as s_uuid";
         String sql = "SELECT " +
@@ -108,9 +108,8 @@ public class NicknamesTable extends UserIDTable {
      * @param uuid       UUID of the Player
      * @param serverUUID UUID of the server
      * @return The nicknames of the User
-     * @throws SQLException when an error at retrieval happens
      */
-    public List<String> getNicknames(UUID uuid, UUID serverUUID) throws SQLException {
+    public List<String> getNicknames(UUID uuid, UUID serverUUID) {
         String sql = "SELECT " + Col.NICKNAME + " FROM " + tableName +
                 " WHERE (" + Col.USER_ID + "=" + usersTable.statementSelectID + ")" +
                 " AND " + Col.SERVER_ID + "=" + serverTable.statementSelectServerID;
@@ -146,13 +145,12 @@ public class NicknamesTable extends UserIDTable {
      *
      * @param uuid UUID of the Player
      * @return The nicknames of the User
-     * @throws SQLException when an error at retrieval happens
      */
-    public List<String> getNicknames(UUID uuid) throws SQLException {
+    public List<String> getNicknames(UUID uuid) {
         return getNicknames(uuid, ServerInfo.getServerUUID());
     }
 
-    public Map<UUID, Map<UUID, List<String>>> getAllNicknames() throws SQLException {
+    public Map<UUID, Map<UUID, List<String>>> getAllNicknames() {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
@@ -186,7 +184,7 @@ public class NicknamesTable extends UserIDTable {
         });
     }
 
-    public void saveUserName(UUID uuid, String displayName) throws SQLException {
+    public void saveUserName(UUID uuid, String displayName) {
         List<String> saved = getNicknames(uuid);
         if (saved.contains(displayName)) {
             return;
@@ -202,6 +200,36 @@ public class NicknamesTable extends UserIDTable {
         });
     }
 
+    public List<Nickname> getNicknameInformation(UUID uuid) {
+        String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
+        String serverUUIDColumn = serverTable + "." + ServerTable.Col.SERVER_UUID + " as s_uuid";
+        String sql = "SELECT " +
+                Col.NICKNAME + ", " +
+                serverUUIDColumn +
+                " FROM " + tableName +
+                " INNER JOIN " + serverTable + " on " + serverIDColumn + "=" + Col.SERVER_ID +
+                " WHERE (" + Col.USER_ID + "=" + usersTable.statementSelectID + ")";
+
+        return query(new QueryStatement<List<Nickname>>(sql, 5000) {
+
+            @Override
+            public void prepare(PreparedStatement statement) throws SQLException {
+                statement.setString(1, uuid.toString());
+            }
+
+            @Override
+            public List<Nickname> processResults(ResultSet set) throws SQLException {
+                List<Nickname> nicknames = new ArrayList<>();
+                while (set.next()) {
+                    UUID serverUUID = UUID.fromString(set.getString("s_uuid"));
+                    String nickname = set.getString(Col.NICKNAME.get());
+                    nicknames.add(new Nickname(nickname, -1, serverUUID)); // TODO Add last used
+                }
+                return nicknames;
+            }
+        });
+    }
+
     public enum Col implements Column {
         USER_ID(UserIDTable.Col.USER_ID.get()),
         SERVER_ID("server_id"),
@@ -224,7 +252,7 @@ public class NicknamesTable extends UserIDTable {
         }
     }
 
-    public void insertNicknames(Map<UUID, Map<UUID, List<String>>> allNicknames) throws SQLException {
+    public void insertNicknames(Map<UUID, Map<UUID, List<String>>> allNicknames) {
         if (Verify.isEmpty(allNicknames)) {
             return;
         }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/SecurityTable.java

@@ -52,7 +52,7 @@ public class SecurityTable extends Table {
         );
     }
 
-    public void removeUser(String user) throws SQLException {
+    public void removeUser(String user) {
         String sql = "DELETE FROM " + tableName + " WHERE (" + Col.USERNAME + "=?)";
 
         execute(new ExecStatement(sql) {
@@ -63,7 +63,7 @@ public class SecurityTable extends Table {
         });
     }
 
-    public WebUser getWebUser(String user) throws SQLException {
+    public WebUser getWebUser(String user) {
         String sql = Select.all(tableName).where(Col.USERNAME + "=?").toString();
 
         return query(new QueryStatement<WebUser>(sql) {
@@ -84,11 +84,11 @@ public class SecurityTable extends Table {
         });
     }
 
-    public void addNewUser(WebUser info) throws SQLException {
+    public void addNewUser(WebUser info) {
         addNewUser(info.getName(), info.getSaltedPassHash(), info.getPermLevel());
     }
 
-    public void addNewUser(String user, String saltPassHash, int permLevel) throws SQLException {
+    public void addNewUser(String user, String saltPassHash, int permLevel) {
         execute(new ExecStatement(insertStatement) {
             @Override
             public void prepare(PreparedStatement statement) throws SQLException {
@@ -99,11 +99,11 @@ public class SecurityTable extends Table {
         });
     }
 
-    public boolean userExists(String user) throws SQLException {
+    public boolean userExists(String user) {
         return getWebUser(user) != null;
     }
 
-    public List<WebUser> getUsers() throws SQLException {
+    public List<WebUser> getUsers() {
         String sql = Select.all(tableName).toString();
 
         return query(new QueryAllStatement<List<WebUser>>(sql, 5000) {
@@ -144,7 +144,7 @@ public class SecurityTable extends Table {
         }
     }
 
-    public void addUsers(List<WebUser> users) throws SQLException {
+    public void addUsers(List<WebUser> users) {
         if (Verify.isEmpty(users)) {
             return;
         }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/ServerTable.java

@@ -73,7 +73,7 @@ public class ServerTable extends Table {
         }
     }
 
-    private void updateServerInfo(Server info) throws SQLException {
+    private void updateServerInfo(Server info) {
         String sql = Update.values(tableName,
                 Col.SERVER_UUID,
                 Col.NAME,
@@ -96,7 +96,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public void saveCurrentServerInfo(Server info) throws SQLException {
+    public void saveCurrentServerInfo(Server info) {
         if (getServerID(info.getUuid()).isPresent()) {
             updateServerInfo(info);
         } else {
@@ -109,9 +109,8 @@ public class ServerTable extends Table {
      *
      * @param serverUUID UUID of the server.
      * @return ID or or empty optional.
-     * @throws SQLException DB Error
      */
-    public Optional<Integer> getServerID(UUID serverUUID) throws SQLException {
+    public Optional<Integer> getServerID(UUID serverUUID) {
         String sql = Select.from(tableName,
                 Col.SERVER_ID)
                 .where(Col.SERVER_UUID + "=?")
@@ -139,9 +138,8 @@ public class ServerTable extends Table {
      *
      * @param info Info to instert (All variables should be present.
      * @throws IllegalStateException if one of the Server variables is null
-     * @throws SQLException          DB Error
      */
-    private void saveNewServerInfo(Server info) throws SQLException {
+    private void saveNewServerInfo(Server info) {
         UUID uuid = info.getUuid();
         String name = info.getName();
         String webAddress = info.getWebAddress();
@@ -164,9 +162,8 @@ public class ServerTable extends Table {
      *
      * @param serverUUID UUID of the server.
      * @return Name or empty optional.
-     * @throws SQLException DB Error
      */
-    public Optional<String> getServerName(UUID serverUUID) throws SQLException {
+    public Optional<String> getServerName(UUID serverUUID) {
         String sql = Select.from(tableName,
                 Col.NAME)
                 .where(Col.SERVER_UUID + "=?")
@@ -189,7 +186,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public Map<Integer, String> getServerNamesByID() throws SQLException {
+    public Map<Integer, String> getServerNamesByID() {
         String sql = Select.from(tableName,
                 Col.SERVER_ID, Col.NAME)
                 .toString();
@@ -207,7 +204,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public Map<UUID, String> getServerNames() throws SQLException {
+    public Map<UUID, String> getServerNames() {
         String sql = Select.from(tableName,
                 Col.SERVER_UUID, Col.NAME)
                 .toString();
@@ -225,7 +222,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public Map<Integer, UUID> getServerUUIDsByID() throws SQLException {
+    public Map<Integer, UUID> getServerUUIDsByID() {
         String sql = Select.from(tableName,
                 Col.SERVER_ID, Col.SERVER_UUID)
                 .toString();
@@ -247,9 +244,8 @@ public class ServerTable extends Table {
      * Used to get BungeeCord WebServer info if present.
      *
      * @return information about Bungee server.
-     * @throws SQLException DB Error
      */
-    public Optional<Server> getBungeeInfo() throws SQLException {
+    public Optional<Server> getBungeeInfo() {
         String sql = Select.from(tableName, "*")
                 .where(Col.NAME + "=?")
                 .toString();
@@ -276,7 +272,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public Map<UUID, Server> getBukkitServers() throws SQLException {
+    public Map<UUID, Server> getBukkitServers() {
         String sql = Select.from(tableName, "*")
                 .where(Col.NAME + "!=?")
                 .toString();
@@ -304,7 +300,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public List<UUID> getServerUUIDs() throws SQLException {
+    public List<UUID> getServerUUIDs() {
         String sql = Select.from(tableName, Col.SERVER_UUID)
                 .toString();
 
@@ -325,7 +321,7 @@ public class ServerTable extends Table {
         return Col.SERVER_UUID.get();
     }
 
-    public void insertAllServers(List<Server> allServer) throws SQLException {
+    public void insertAllServers(List<Server> allServer) {
         if (Verify.isEmpty(allServer)) {
             return;
         }
@@ -353,7 +349,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public Optional<UUID> getServerUUID(String serverName) throws SQLException {
+    public Optional<UUID> getServerUUID(String serverName) {
         String sql = Select.from(tableName,
                 Col.SERVER_UUID)
                 .where(Col.NAME + "=?")
@@ -376,7 +372,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public Optional<Server> getServerInfo(UUID serverUUID) throws SQLException {
+    public Optional<Server> getServerInfo(UUID serverUUID) {
         String sql = Select.from(tableName, "*")
                 .where(Col.SERVER_UUID + "=?")
                 .toString();
@@ -402,7 +398,7 @@ public class ServerTable extends Table {
         });
     }
 
-    public int getMaxPlayers() throws SQLException {
+    public int getMaxPlayers() {
         String sql = "SELECT SUM(" + Col.MAX_PLAYERS + ") AS max FROM " + tableName;
 
         return query(new QueryAllStatement<Integer>(sql) {

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/SessionsTable.java

@@ -73,7 +73,7 @@ public class SessionsTable extends UserIDTable {
      * @param session session inserted.
      * @return ID of the inserted session or -1 if session has not been inserted.
      */
-    private int getSessionID(UUID uuid, Session session) throws SQLException {
+    private int getSessionID(UUID uuid, Session session) {
         String sql = "SELECT " + Col.ID + " FROM " + tableName +
                 " WHERE " + Col.USER_ID + "=" + usersTable.statementSelectID +
                 " AND " + Col.SESSION_START + "=?" +
@@ -104,9 +104,8 @@ public class SessionsTable extends UserIDTable {
      *
      * @param uuid    UUID of the player.
      * @param session Session of the player that has ended ({@code endSession} has been called)
-     * @throws SQLException DB Error
      */
-    public void saveSession(UUID uuid, Session session) throws SQLException {
+    public void saveSession(UUID uuid, Session session) {
         saveSessionInformation(uuid, session);
         int sessionID = getSessionID(uuid, session);
         if (sessionID == -1) {
@@ -124,9 +123,8 @@ public class SessionsTable extends UserIDTable {
      *
      * @param uuid    UUID of the player.
      * @param session Session of the player that has ended ({@code endSession} has been called)
-     * @throws SQLException DB Error
      */
-    private void saveSessionInformation(UUID uuid, Session session) throws SQLException {
+    private void saveSessionInformation(UUID uuid, Session session) {
         execute(new ExecStatement(insertStatement) {
             @Override
             public void prepare(PreparedStatement statement) throws SQLException {
@@ -149,9 +147,8 @@ public class SessionsTable extends UserIDTable {
      *
      * @param uuid UUID of the player
      * @return Map with Sessions that don't contain Kills or WorldTimes.
-     * @throws SQLException DB Error
      */
-    private Map<UUID, List<Session>> getSessionInformation(UUID uuid) throws SQLException {
+    private Map<UUID, List<Session>> getSessionInformation(UUID uuid) {
         Map<Integer, UUID> serverUUIDs = serverTable.getServerUUIDsByID();
         String sql = Select.from(tableName, "*")
                 .where(Col.USER_ID + "=" + usersTable.statementSelectID)
@@ -196,9 +193,8 @@ public class SessionsTable extends UserIDTable {
      * @param serverUUID UUID of the server. @see ServerTable
      * @param afterDate  Epoch ms (Playtime after this date is calculated)
      * @return Milliseconds played after given epoch ms on the server. 0 if player or server not found.
-     * @throws SQLException DB Error
      */
-    public long getPlaytime(UUID uuid, UUID serverUUID, long afterDate) throws SQLException {
+    public long getPlaytime(UUID uuid, UUID serverUUID, long afterDate) {
         String sql = "SELECT" +
                 " (SUM(" + Col.SESSION_END + ") - SUM(" + Col.SESSION_START + ")) as playtime" +
                 " FROM " + tableName +
@@ -224,7 +220,7 @@ public class SessionsTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, List<Session>> getSessions(UUID uuid) throws SQLException {
+    public Map<UUID, List<Session>> getSessions(UUID uuid) {
         Map<UUID, List<Session>> sessions = getSessionInformation(uuid);
         Map<Integer, Session> allSessions = sessions.values().stream().flatMap(Collection::stream).collect(Collectors.toMap(Session::getSessionID, Function.identity()));
 
@@ -238,9 +234,8 @@ public class SessionsTable extends UserIDTable {
      *
      * @param uuid UUID of the player.
      * @return Milliseconds played on THIS server. 0 if player or server not found.
-     * @throws SQLException DB Error
      */
-    public long getPlaytime(UUID uuid) throws SQLException {
+    public long getPlaytime(UUID uuid) {
         return getPlaytime(uuid, ServerInfo.getServerUUID());
     }
 
@@ -250,9 +245,8 @@ public class SessionsTable extends UserIDTable {
      * @param uuid      UUID of the player.
      * @param afterDate Epoch ms (Playtime after this date is calculated)
      * @return Milliseconds played on THIS server. 0 if player or server not found.
-     * @throws SQLException DB Error
      */
-    public long getPlaytime(UUID uuid, long afterDate) throws SQLException {
+    public long getPlaytime(UUID uuid, long afterDate) {
         return getPlaytime(uuid, ServerInfo.getServerUUID(), afterDate);
     }
 
@@ -262,9 +256,8 @@ public class SessionsTable extends UserIDTable {
      * @param uuid       UUID of the player.
      * @param serverUUID UUID of the server. @see ServerTable
      * @return Milliseconds played on the server. 0 if player or server not found.
-     * @throws SQLException DB Error
      */
-    public long getPlaytime(UUID uuid, UUID serverUUID) throws SQLException {
+    public long getPlaytime(UUID uuid, UUID serverUUID) {
         return getPlaytime(uuid, serverUUID, 0L);
     }
 
@@ -274,9 +267,8 @@ public class SessionsTable extends UserIDTable {
      * @param uuid      UUID of the Player.
      * @param afterDate Epoch ms (Playtime after this date is calculated)
      * @return key - ServerName, value ms played
-     * @throws SQLException DB Error
      */
-    public Map<String, Long> getPlaytimeByServer(UUID uuid, long afterDate) throws SQLException {
+    public Map<String, Long> getPlaytimeByServer(UUID uuid, long afterDate) {
         Map<Integer, String> serverNames = serverTable.getServerNamesByID();
         String sql = "SELECT " +
                 "(SUM(" + Col.SESSION_END + ") - SUM(" + Col.SESSION_START + ")) as playtime, " +
@@ -310,9 +302,8 @@ public class SessionsTable extends UserIDTable {
      *
      * @param uuid UUID of the Player.
      * @return key - ServerName, value ms played
-     * @throws SQLException DB Error
      */
-    public Map<String, Long> getPlaytimeByServer(UUID uuid) throws SQLException {
+    public Map<String, Long> getPlaytimeByServer(UUID uuid) {
         return getPlaytimeByServer(uuid, 0L);
     }
 
@@ -322,9 +313,8 @@ public class SessionsTable extends UserIDTable {
      * @param serverUUID UUID of the server.
      * @param afterDate  Epoch ms (Playtime after this date is calculated)
      * @return Milliseconds played  after given epoch ms on the server. 0 if server not found.
-     * @throws SQLException DB Error
      */
-    public long getPlaytimeOfServer(UUID serverUUID, long afterDate) throws SQLException {
+    public long getPlaytimeOfServer(UUID serverUUID, long afterDate) {
         String sql = "SELECT" +
                 " (SUM(" + Col.SESSION_END + ") - SUM(" + Col.SESSION_START + ")) as playtime" +
                 " FROM " + tableName +
@@ -352,9 +342,8 @@ public class SessionsTable extends UserIDTable {
      * Used to get the Total Playtime of THIS Server.
      *
      * @return Milliseconds played on the server. 0 if server not found.
-     * @throws SQLException DB Error
      */
-    public long getPlaytimeOfServer() throws SQLException {
+    public long getPlaytimeOfServer() {
         return getPlaytimeOfServer(ServerInfo.getServerUUID());
     }
 
@@ -363,9 +352,8 @@ public class SessionsTable extends UserIDTable {
      *
      * @param serverUUID UUID of the server.
      * @return Milliseconds played on the server. 0 if server not found.
-     * @throws SQLException DB Error
      */
-    public long getPlaytimeOfServer(UUID serverUUID) throws SQLException {
+    public long getPlaytimeOfServer(UUID serverUUID) {
         return getPlaytimeOfServer(serverUUID, 0L);
     }
 
@@ -374,9 +362,8 @@ public class SessionsTable extends UserIDTable {
      *
      * @param afterDate Epoch ms (Playtime after this date is calculated)
      * @return Milliseconds played  after given epoch ms on the server. 0 if server not found.
-     * @throws SQLException DB Error
      */
-    public long getPlaytimeOfServer(long afterDate) throws SQLException {
+    public long getPlaytimeOfServer(long afterDate) {
         return getPlaytimeOfServer(ServerInfo.getServerUUID(), afterDate);
     }
 
@@ -387,9 +374,8 @@ public class SessionsTable extends UserIDTable {
      * @param serverUUID UUID of the server.
      * @param afterDate  Epoch ms (Session count after this date is calculated)
      * @return How many sessions player has. 0 if player or server not found.
-     * @throws SQLException DB Error
      */
-    public int getSessionCount(UUID uuid, UUID serverUUID, long afterDate) throws SQLException {
+    public int getSessionCount(UUID uuid, UUID serverUUID, long afterDate) {
         String sql = "SELECT" +
                 " COUNT(*) as logintimes" +
                 " FROM " + tableName +
@@ -420,9 +406,8 @@ public class SessionsTable extends UserIDTable {
      *
      * @param uuid UUID of the player.
      * @return How many sessions player has. 0 if player or server not found.
-     * @throws SQLException DB Error
      */
-    public int getSessionCount(UUID uuid) throws SQLException {
+    public int getSessionCount(UUID uuid) {
         return getSessionCount(uuid, 0L);
     }
 
@@ -432,9 +417,8 @@ public class SessionsTable extends UserIDTable {
      * @param uuid      UUID of the player.
      * @param afterDate Epoch ms (Session count after this date is calculated)
      * @return How many sessions player has. 0 if player or server not found.
-     * @throws SQLException DB Error
      */
-    public int getSessionCount(UUID uuid, long afterDate) throws SQLException {
+    public int getSessionCount(UUID uuid, long afterDate) {
         return getSessionCount(uuid, ServerInfo.getServerUUID(), afterDate);
     }
 
@@ -444,9 +428,8 @@ public class SessionsTable extends UserIDTable {
      * @param uuid       UUID of the player.
      * @param serverUUID UUID of the server.
      * @return How many sessions player has. 0 if player or server not found.
-     * @throws SQLException DB Error
      */
-    public int getSessionCount(UUID uuid, UUID serverUUID) throws SQLException {
+    public int getSessionCount(UUID uuid, UUID serverUUID) {
         return getSessionCount(uuid, serverUUID, 0L);
     }
 
@@ -455,7 +438,7 @@ public class SessionsTable extends UserIDTable {
         return Col.ID.get();
     }
 
-    public Map<UUID, List<Session>> getSessionInfoOfServer(UUID serverUUID) throws SQLException {
+    public Map<UUID, List<Session>> getSessionInfoOfServer(UUID serverUUID) {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String sql = "SELECT " +
@@ -498,12 +481,12 @@ public class SessionsTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, List<Session>> getSessionInfoOfServer() throws SQLException {
+    public Map<UUID, List<Session>> getSessionInfoOfServer() {
         return getSessionInfoOfServer(ServerInfo.getServerUUID());
     }
 
     // TODO Write tests for this method
-    public long getLastSeen(UUID uuid) throws SQLException {
+    public long getLastSeen(UUID uuid) {
         String sql = "SELECT" +
                 " MAX(" + Col.SESSION_END + ") as last_seen" +
                 " FROM " + tableName +
@@ -525,7 +508,7 @@ public class SessionsTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, Long> getLastSeenForAllPlayers() throws SQLException {
+    public Map<UUID, Long> getLastSeenForAllPlayers() {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String sql = "SELECT" +
@@ -549,7 +532,7 @@ public class SessionsTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, Map<UUID, List<Session>>> getAllSessions(boolean getKillsAndWorldTimes) throws SQLException {
+    public Map<UUID, Map<UUID, List<Session>>> getAllSessions(boolean getKillsAndWorldTimes) {
         Map<Integer, UUID> uuidsByID = usersTable.getUUIDsByID();
         Map<Integer, UUID> serverUUIDsByID = serverTable.getServerUUIDsByID();
 
@@ -599,7 +582,7 @@ public class SessionsTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, Map<UUID, List<Session>>> getSessionInLastMonth() throws SQLException {
+    public Map<UUID, Map<UUID, List<Session>>> getSessionInLastMonth() {
         Map<Integer, UUID> uuidsByID = usersTable.getUUIDsByID();
         Map<Integer, UUID> serverUUIDsByID = serverTable.getServerUUIDsByID();
 
@@ -651,7 +634,7 @@ public class SessionsTable extends UserIDTable {
         });
     }
 
-    public void insertSessions(Map<UUID, Map<UUID, List<Session>>> allSessions, boolean saveKillsAndWorldTimes) throws SQLException {
+    public void insertSessions(Map<UUID, Map<UUID, List<Session>>> allSessions, boolean saveKillsAndWorldTimes) {
         if (Verify.isEmpty(allSessions)) {
             return;
         }
@@ -751,7 +734,7 @@ public class SessionsTable extends UserIDTable {
         addColumns(Col.AFK_TIME + " bigint NOT NULL DEFAULT 0");
     }
 
-    public Map<Integer, Integer> getIDServerIDRelation() throws SQLException {
+    public Map<Integer, Integer> getIDServerIDRelation() {
         String sql = "SELECT " +
                 Col.ID + ", " +
                 Col.SERVER_ID +

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/TPSTable.java

@@ -68,7 +68,7 @@ public class TPSTable extends Table {
         );
     }
 
-    public List<TPS> getTPSData(UUID serverUUID) throws SQLException {
+    public List<TPS> getTPSData(UUID serverUUID) {
         String sql = Select.all(tableName)
                 .where(Col.SERVER_ID + "=" + serverTable.statementSelectServerID)
                 .toString();
@@ -104,16 +104,14 @@ public class TPSTable extends Table {
     /**
      * @return @throws SQLException
      */
-    public List<TPS> getTPSData() throws SQLException {
+    public List<TPS> getTPSData() {
         return getTPSData(ServerInfo.getServerUUID());
     }
 
     /**
      * Clean the TPS Table of old data.
-     *
-     * @throws SQLException DB Error
      */
-    public void clean() throws SQLException {
+    public void clean() {
         Optional<TPS> allTimePeak = getAllTimePeak();
         int p = -1;
         if (allTimePeak.isPresent()) {
@@ -137,7 +135,7 @@ public class TPSTable extends Table {
         });
     }
 
-    public void insertTPS(TPS tps) throws SQLException {
+    public void insertTPS(TPS tps) {
         execute(new ExecStatement(insertStatement) {
             @Override
             public void prepare(PreparedStatement statement) throws SQLException {
@@ -153,7 +151,7 @@ public class TPSTable extends Table {
         });
     }
 
-    public Optional<TPS> getPeakPlayerCount(UUID serverUUID, long afterDate) throws SQLException {
+    public Optional<TPS> getPeakPlayerCount(UUID serverUUID, long afterDate) {
         String sql = Select.all(tableName)
                 .where(Col.SERVER_ID + "=" + serverTable.statementSelectServerID)
                 .and(Col.PLAYERS_ONLINE + "= (SELECT MAX(" + Col.PLAYERS_ONLINE + ") FROM " + tableName + ")")
@@ -188,19 +186,19 @@ public class TPSTable extends Table {
         });
     }
 
-    public Optional<TPS> getAllTimePeak(UUID serverUUID) throws SQLException {
+    public Optional<TPS> getAllTimePeak(UUID serverUUID) {
         return getPeakPlayerCount(serverUUID, 0);
     }
 
-    public Optional<TPS> getAllTimePeak() throws SQLException {
+    public Optional<TPS> getAllTimePeak() {
         return getPeakPlayerCount(0);
     }
 
-    public Optional<TPS> getPeakPlayerCount(long afterDate) throws SQLException {
+    public Optional<TPS> getPeakPlayerCount(long afterDate) {
         return getPeakPlayerCount(ServerInfo.getServerUUID(), afterDate);
     }
 
-    public Map<UUID, List<TPS>> getAllTPS() throws SQLException {
+    public Map<UUID, List<TPS>> getAllTPS() {
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
         String serverUUIDColumn = serverTable + "." + ServerTable.Col.SERVER_UUID + " as s_uuid";
         String sql = "SELECT " +
@@ -242,7 +240,7 @@ public class TPSTable extends Table {
         });
     }
 
-    public List<TPS> getNetworkOnlineData() throws SQLException {
+    public List<TPS> getNetworkOnlineData() {
         Optional<Server> bungeeInfo = serverTable.getBungeeInfo();
         if (!bungeeInfo.isPresent()) {
             return new ArrayList<>();
@@ -279,7 +277,7 @@ public class TPSTable extends Table {
         });
     }
 
-    public void insertAllTPS(Map<UUID, List<TPS>> allTPS) throws SQLException {
+    public void insertAllTPS(Map<UUID, List<TPS>> allTPS) {
         if (Verify.isEmpty(allTPS)) {
             return;
         }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/Table.java

@@ -1,6 +1,7 @@
 package com.djrapitops.plan.system.database.databases.sql.tables;
 
 import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.database.databases.sql.processing.ExecStatement;
 import com.djrapitops.plan.system.database.databases.sql.processing.QueryStatement;
@@ -13,6 +14,8 @@ import java.sql.PreparedStatement;
 import java.sql.SQLException;
 
 /**
+ * Abstract representation of a SQL database table.
+ *
  * @author Rsl1122
  */
 public abstract class Table {
@@ -38,12 +41,12 @@ public abstract class Table {
     protected void createTable(String sql) throws DBInitException {
         try {
             execute(sql);
-        } catch (SQLException e) {
+        } catch (DBOpException e) {
             throw new DBInitException("Failed to create table: " + tableName, e);
         }
     }
 
-    protected void renameTable(String to) throws SQLException {
+    protected void renameTable(String to) {
         String sql = usingMySQL ?
                 "RENAME TABLE " + tableName + " TO " + to :
                 "ALTER TABLE " + tableName + " RENAME TO " + to;
@@ -55,7 +58,9 @@ public abstract class Table {
      *
      * @return SQL Connection
      * @throws SQLException DB Error
+     * @deprecated Use db.getConnection - db is protected variable.
      */
+    @Deprecated
     protected Connection getConnection() throws SQLException {
         return db.getConnection();
     }
@@ -64,20 +69,20 @@ public abstract class Table {
      * Get the Database Schema version from VersionTable.
      *
      * @return Database Schema version.
-     * @throws SQLException DB Error
+     * @deprecated Use db.getVersion - db is protected variable.
      */
-    public int getVersion() throws SQLException {
+    @Deprecated
+    public int getVersion() {
         return db.getVersion();
     }
 
     /**
      * Executes an SQL Statement
      *
-     * @param statementString Statement to setUp
-     * @return What setUp returns.
-     * @throws SQLException DB error
+     * @param statementString Statement to execute in the database.
+     * @return true if rows were updated.
      */
-    protected boolean execute(String statementString) throws SQLException {
+    protected boolean execute(String statementString) {
         return execute(new ExecStatement(statementString) {
             @Override
             public void prepare(PreparedStatement statement) {
@@ -87,7 +92,7 @@ public abstract class Table {
     }
 
     /**
-     * Used to setUp queries while possible SQLExceptions are suppressed.
+     * Used to execute statements while possible exceptions are suppressed.
      *
      * @param statements SQL statements to setUp
      */
@@ -96,8 +101,8 @@ public abstract class Table {
         for (String statement : statements) {
             try {
                 execute(statement);
-            } catch (SQLException ignored) {
-                /* Ignored */
+            } catch (DBOpException ignored) {
+                /* ignored */
             }
         }
     }
@@ -118,7 +123,7 @@ public abstract class Table {
     /**
      * Removes all data from the table.
      */
-    public void removeAllData() throws SQLException {
+    public void removeAllData() {
         execute("DELETE FROM " + tableName);
     }
 
@@ -158,7 +163,11 @@ public abstract class Table {
                 Objects.equal(db, table.db);
     }
 
-    protected void commit(Connection connection) throws SQLException {
+    /**
+     * @deprecated Use db.commit - db is a protected variable.
+     */
+    @Deprecated
+    protected void commit(Connection connection) {
         db.commit(connection);
     }
 
@@ -167,45 +176,15 @@ public abstract class Table {
         return Objects.hashCode(tableName, db, usingMySQL);
     }
 
-    public SQLDB getDb() {
-        return db;
+    protected boolean execute(ExecStatement statement) {
+        return db.execute(statement);
     }
 
-    protected boolean execute(ExecStatement statement) throws SQLException {
-        Connection connection = null;
-        try {
-            connection = getConnection();
-            try (PreparedStatement preparedStatement = connection.prepareStatement(statement.getSql())) {
-                return statement.execute(preparedStatement);
-            }
-        } finally {
-            commit(connection);
-            db.returnToPool(connection);
-        }
+    protected void executeBatch(ExecStatement statement) {
+        db.executeBatch(statement);
     }
 
-    protected void executeBatch(ExecStatement statement) throws SQLException {
-        Connection connection = null;
-        try {
-            connection = getConnection();
-            try (PreparedStatement preparedStatement = connection.prepareStatement(statement.getSql())) {
-                statement.executeBatch(preparedStatement);
-            }
-        } finally {
-            commit(connection);
-            db.returnToPool(connection);
-        }
-    }
-
-    protected <T> T query(QueryStatement<T> statement) throws SQLException {
-        Connection connection = null;
-        try {
-            connection = getConnection();
-            try (PreparedStatement preparedStatement = connection.prepareStatement(statement.getSql())) {
-                return statement.executeQuery(preparedStatement);
-            }
-        } finally {
-            db.returnToPool(connection);
-        }
+    protected <T> T query(QueryStatement<T> statement) {
+        return db.query(statement);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/TransferTable.java

@@ -75,7 +75,7 @@ public class TransferTable extends Table {
         addColumns(Col.PART + " bigint NOT NULL DEFAULT 0");
     }
 
-    public void clean() throws SQLException {
+    public void clean() {
         String sql = "DELETE FROM " + tableName +
                 " WHERE " + Col.EXPIRY + " < ?" +
                 " AND " + Col.INFO_TYPE + " != ?";
@@ -101,7 +101,7 @@ public class TransferTable extends Table {
     }
 
     @Deprecated
-    public Optional<UUID> getServerPlayerIsOnline(UUID playerUUID) throws SQLException {
+    public Optional<UUID> getServerPlayerIsOnline(UUID playerUUID) {
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
         String serverUUIDColumn = serverTable + "." + ServerTable.Col.SERVER_UUID + " as s_uuid";
         String sql = "SELECT " +
@@ -127,7 +127,7 @@ public class TransferTable extends Table {
         });
     }
 
-    public void storeConfigSettings(String encodedSettingString) throws SQLException {
+    public void storeConfigSettings(String encodedSettingString) {
         execute(new ExecStatement(insertStatementNoParts) {
             @Override
             public void prepare(PreparedStatement statement) throws SQLException {
@@ -140,7 +140,7 @@ public class TransferTable extends Table {
         });
     }
 
-    public Optional<String> getConfigSettings() throws SQLException {
+    public Optional<String> getConfigSettings() {
         return query(new QueryStatement<Optional<String>>(selectStatement, 100) {
             @Override
             public void prepare(PreparedStatement statement) throws SQLException {

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UserIDTable.java

@@ -42,7 +42,7 @@ public abstract class UserIDTable extends Table {
         usersTable = db.getUsersTable();
     }
 
-    public void removeUser(UUID uuid) throws SQLException {
+    public void removeUser(UUID uuid) {
         String sql = "DELETE FROM " + tableName + " WHERE (" + Col.USER_ID + "=" + usersTable.statementSelectID + ")";
 
         execute(new ExecStatement(sql) {

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UserInfoTable.java

@@ -50,7 +50,7 @@ public class UserInfoTable extends UserIDTable {
         serverTable = db.getServerTable();
     }
 
-    public void registerUserInfo(UUID uuid, long registered) throws SQLException {
+    public void registerUserInfo(UUID uuid, long registered) {
         if (!usersTable.isRegistered(uuid)) {
             usersTable.registerUser(uuid, registered, "Waiting for Update..");
         }
@@ -74,7 +74,7 @@ public class UserInfoTable extends UserIDTable {
         });
     }
 
-    public boolean isRegistered(UUID uuid, UUID serverUUID) throws SQLException {
+    public boolean isRegistered(UUID uuid, UUID serverUUID) {
         String sql = Select.from(tableName, "COUNT(" + Col.USER_ID + ") as c")
                 .where(Col.USER_ID + "=" + usersTable.statementSelectID)
                 .and(Col.SERVER_ID + "=" + serverTable.statementSelectServerID)
@@ -94,11 +94,11 @@ public class UserInfoTable extends UserIDTable {
         });
     }
 
-    public boolean isRegistered(UUID uuid) throws SQLException {
+    public boolean isRegistered(UUID uuid) {
         return isRegistered(uuid, ServerInfo.getServerUUID());
     }
 
-    public void updateOpStatus(UUID uuid, boolean op) throws SQLException {
+    public void updateOpStatus(UUID uuid, boolean op) {
         String sql = Update.values(tableName, Col.OP)
                 .where(Col.USER_ID + "=" + usersTable.statementSelectID)
                 .toString();
@@ -112,7 +112,7 @@ public class UserInfoTable extends UserIDTable {
         });
     }
 
-    public void updateBanStatus(UUID uuid, boolean banned) throws SQLException {
+    public void updateBanStatus(UUID uuid, boolean banned) {
         String sql = Update.values(tableName, Col.BANNED)
                 .where(Col.USER_ID + "=" + usersTable.statementSelectID)
                 .toString();
@@ -126,7 +126,7 @@ public class UserInfoTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, UserInfo> getAllUserInfo(UUID uuid) throws SQLException {
+    public Map<UUID, UserInfo> getAllUserInfo(UUID uuid) {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
         String usersNameColumn = usersTable + "." + UsersTable.Col.USER_NAME + " as name";
@@ -165,11 +165,11 @@ public class UserInfoTable extends UserIDTable {
         });
     }
 
-    public UserInfo getUserInfo(UUID uuid) throws SQLException {
+    public UserInfo getUserInfo(UUID uuid) {
         return getAllUserInfo(uuid).get(ServerInfo.getServerUUID());
     }
 
-    public List<UserInfo> getServerUserInfo(UUID serverUUID) throws SQLException {
+    public List<UserInfo> getServerUserInfo(UUID serverUUID) {
         Optional<Integer> serverID = serverTable.getServerID(serverUUID);
         if (!serverID.isPresent()) {
             return new ArrayList<>();
@@ -212,11 +212,11 @@ public class UserInfoTable extends UserIDTable {
      *
      * @return List of UserInfo objects.
      */
-    public List<UserInfo> getServerUserInfo() throws SQLException {
+    public List<UserInfo> getServerUserInfo() {
         return getServerUserInfo(ServerInfo.getServerUUID());
     }
 
-    public Map<UUID, List<UserInfo>> getAllUserInfo() throws SQLException {
+    public Map<UUID, List<UserInfo>> getAllUserInfo() {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
@@ -254,7 +254,7 @@ public class UserInfoTable extends UserIDTable {
         });
     }
 
-    public void insertUserInfo(Map<UUID, List<UserInfo>> allUserInfos) throws SQLException {
+    public void insertUserInfo(Map<UUID, List<UserInfo>> allUserInfos) {
         if (Verify.isEmpty(allUserInfos)) {
             return;
         }
@@ -290,7 +290,7 @@ public class UserInfoTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, Set<UUID>> getSavedUUIDs() throws SQLException {
+    public Map<UUID, Set<UUID>> getSavedUUIDs() {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;
@@ -320,7 +320,7 @@ public class UserInfoTable extends UserIDTable {
         });
     }
 
-    public int getServerUserCount(UUID serverUUID) throws SQLException {
+    public int getServerUserCount(UUID serverUUID) {
         String sql = "SELECT " +
                 " COUNT(" + Col.REGISTERED + ") as c" +
                 " FROM " + tableName +
@@ -366,7 +366,7 @@ public class UserInfoTable extends UserIDTable {
         }
     }
 
-    public Set<UUID> getSavedUUIDs(UUID serverUUID) throws SQLException {
+    public Set<UUID> getSavedUUIDs(UUID serverUUID) {
         String usersIDColumn = usersTable + "." + UsersTable.Col.ID;
         String usersUUIDColumn = usersTable + "." + UsersTable.Col.UUID + " as uuid";
         String serverIDColumn = serverTable + "." + ServerTable.Col.SERVER_ID;

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/UsersTable.java

@@ -1,7 +1,6 @@
 package com.djrapitops.plan.system.database.databases.sql.tables;
 
 import com.djrapitops.plan.api.exceptions.database.DBInitException;
-import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.container.UserInfo;
 import com.djrapitops.plan.data.store.Key;
 import com.djrapitops.plan.data.store.containers.DataContainer;
@@ -57,9 +56,8 @@ public class UsersTable extends UserIDTable {
 
     /**
      * @return a {@link Set} of the saved UUIDs.
-     * @throws SQLException when an error at retrieving the UUIDs happens
      */
-    public Set<UUID> getSavedUUIDs() throws SQLException {
+    public Set<UUID> getSavedUUIDs() {
         String sql = Select.from(tableName, Col.UUID).toString();
 
         return query(new QueryAllStatement<Set<UUID>>(sql, 50000) {
@@ -79,10 +77,9 @@ public class UsersTable extends UserIDTable {
      * Remove a user from Users Table.
      *
      * @param uuid the UUID of the user that should be removed.
-     * @throws SQLException DB Error
      */
     @Override
-    public void removeUser(UUID uuid) throws SQLException {
+    public void removeUser(UUID uuid) {
         String sql = "DELETE FROM " + tableName + " WHERE (" + Col.UUID + "=?)";
 
         execute(new ExecStatement(sql) {
@@ -114,9 +111,8 @@ public class UsersTable extends UserIDTable {
      *
      * @param playerName Name of a player
      * @return UUID of the player
-     * @throws SQLException DB Error
      */
-    public UUID getUuidOf(String playerName) throws SQLException {
+    public UUID getUuidOf(String playerName) {
         String sql = Select.from(tableName, Col.UUID)
                 .where("UPPER(" + Col.USER_NAME + ")=UPPER(?)")
                 .toString();
@@ -138,7 +134,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public List<Long> getRegisterDates() throws SQLException {
+    public List<Long> getRegisterDates() {
         String sql = Select.from(tableName, Col.REGISTERED).toString();
 
         return query(new QueryAllStatement<List<Long>>(sql, 50000) {
@@ -153,7 +149,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public boolean isRegistered(UUID uuid) throws SQLException {
+    public boolean isRegistered(UUID uuid) {
         String sql = Select.from(tableName, "COUNT(" + Col.ID + ") as c")
                 .where(Col.UUID + "=?")
                 .toString();
@@ -177,10 +173,9 @@ public class UsersTable extends UserIDTable {
      * @param uuid       UUID of the player.
      * @param registered Register date.
      * @param name       Name of the player.
-     * @throws SQLException             DB Error
      * @throws IllegalArgumentException If uuid or name are null.
      */
-    public void registerUser(UUID uuid, long registered, String name) throws SQLException {
+    public void registerUser(UUID uuid, long registered, String name) {
         Verify.nullCheck(uuid, name);
 
         execute(new ExecStatement(insertStatement) {
@@ -193,7 +188,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public void updateName(UUID uuid, String name) throws SQLException {
+    public void updateName(UUID uuid, String name) {
         String sql = Update.values(tableName, Col.USER_NAME.get())
                 .where(Col.UUID + "=?")
                 .toString();
@@ -207,7 +202,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public int getTimesKicked(UUID uuid) throws SQLException {
+    public int getTimesKicked(UUID uuid) {
         String sql = Select.from(tableName, Col.TIMES_KICKED)
                 .where(Col.UUID + "=?")
                 .toString();
@@ -228,7 +223,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public void kicked(UUID uuid) throws SQLException {
+    public void kicked(UUID uuid) {
         String sql = "UPDATE " + tableName + " SET "
                 + Col.TIMES_KICKED + "=" + Col.TIMES_KICKED + "+ 1" +
                 " WHERE " + Col.UUID + "=?";
@@ -241,7 +236,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public String getPlayerName(UUID uuid) throws SQLException {
+    public String getPlayerName(UUID uuid) {
         String sql = Select.from(tableName, Col.USER_NAME).where(Col.UUID + "=?").toString();
 
         return query(new QueryStatement<String>(sql) {
@@ -265,9 +260,8 @@ public class UsersTable extends UserIDTable {
      *
      * @param name the name / nickname.
      * @return a list of distinct names.
-     * @throws SQLException when an error at fetching the names happens.
      */
-    public List<String> getMatchingNames(String name) throws SQLException {
+    public List<String> getMatchingNames(String name) {
         String searchString = "%" + name.toLowerCase() + "%";
         NicknamesTable nicknamesTable = db.getNicknamesTable();
         String sql = "SELECT DISTINCT " + Col.USER_NAME + " FROM " + tableName +
@@ -302,7 +296,7 @@ public class UsersTable extends UserIDTable {
         return Col.USER_NAME.get();
     }
 
-    public Map<UUID, UserInfo> getUsers() throws SQLException {
+    public Map<UUID, UserInfo> getUsers() {
         String sql = Select.all(tableName).toString();
 
         return query(new QueryAllStatement<Map<UUID, UserInfo>>(sql, 20000) {
@@ -328,9 +322,8 @@ public class UsersTable extends UserIDTable {
      * Use UserInfoTable instead.
      *
      * @param users Users to insert
-     * @throws SQLException DB Error
      */
-    public void insertUsers(Map<UUID, UserInfo> users) throws SQLException {
+    public void insertUsers(Map<UUID, UserInfo> users) {
         if (Verify.isEmpty(users)) {
             return;
         }
@@ -353,7 +346,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public void updateKicked(Map<UUID, Integer> timesKicked) throws SQLException {
+    public void updateKicked(Map<UUID, Integer> timesKicked) {
         if (Verify.isEmpty(timesKicked)) {
             return;
         }
@@ -374,7 +367,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, Integer> getAllTimesKicked() throws SQLException {
+    public Map<UUID, Integer> getAllTimesKicked() {
         String sql = Select.from(tableName, Col.UUID, Col.TIMES_KICKED).toString();
 
         return query(new QueryAllStatement<Map<UUID, Integer>>(sql, 20000) {
@@ -392,7 +385,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public Map<UUID, String> getPlayerNames() throws SQLException {
+    public Map<UUID, String> getPlayerNames() {
         String sql = Select.from(tableName, Col.UUID, Col.USER_NAME).toString();
 
         return query(new QueryAllStatement<Map<UUID, String>>(sql, 20000) {
@@ -410,7 +403,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public Optional<Long> getRegisterDate(UUID uuid) throws SQLException {
+    public Optional<Long> getRegisterDate(UUID uuid) {
         String sql = Select.from(tableName, Col.REGISTERED).where(Col.UUID + "=?").toString();
 
         return query(new QueryStatement<Optional<Long>>(sql) {
@@ -429,7 +422,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public int getPlayerCount() throws SQLException {
+    public int getPlayerCount() {
         String sql = "SELECT COUNT(*) AS player_count FROM " + tableName;
 
         return query(new QueryAllStatement<Integer>(sql) {
@@ -443,7 +436,7 @@ public class UsersTable extends UserIDTable {
         });
     }
 
-    public Map<Integer, UUID> getUUIDsByID() throws SQLException {
+    public Map<Integer, UUID> getUUIDsByID() {
         String sql = Select.from(tableName, Col.ID, Col.UUID).toString();
 
         return query(new QueryAllStatement<Map<Integer, UUID>>(sql, 20000) {
@@ -467,33 +460,29 @@ public class UsersTable extends UserIDTable {
         DataContainer returnValue = new DataContainer();
 
         Supplier<DataContainer> usersTableResults = () -> {
-            try {
-                String sql = "SELECT * FROM " + tableName + " WHERE " + Col.UUID + "=?";
+            String sql = "SELECT * FROM " + tableName + " WHERE " + Col.UUID + "=?";
 
-                return query(new QueryStatement<DataContainer>(sql) {
-                    @Override
-                    public void prepare(PreparedStatement statement) throws SQLException {
-                        statement.setString(1, uuid.toString());
+            return query(new QueryStatement<DataContainer>(sql) {
+                @Override
+                public void prepare(PreparedStatement statement) throws SQLException {
+                    statement.setString(1, uuid.toString());
+                }
+
+                @Override
+                public DataContainer processResults(ResultSet set) throws SQLException {
+                    DataContainer container = new DataContainer();
+
+                    if (set.next()) {
+                        long registered = set.getLong(Col.REGISTERED.get());
+                        String name = set.getString(Col.USER_NAME.get());
+
+                        container.putRawData(PlayerKeys.REGISTERED, registered);
+                        container.putRawData(PlayerKeys.NAME, name);
                     }
 
-                    @Override
-                    public DataContainer processResults(ResultSet set) throws SQLException {
-                        DataContainer container = new DataContainer();
-
-                        if (set.next()) {
-                            long registered = set.getLong(Col.REGISTERED.get());
-                            String name = set.getString(Col.USER_NAME.get());
-
-                            container.putRawData(PlayerKeys.REGISTERED, registered);
-                            container.putRawData(PlayerKeys.NAME, name);
-                        }
-
-                        return container;
-                    }
-                });
-            } catch (SQLException e) {
-                throw new DBOpException("Failed to fetch user info from plan_users", e);
-            }
+                    return container;
+                }
+            });
         };
 
         returnValue.putSupplier(key, usersTableResults);

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/VersionTable.java

@@ -29,7 +29,7 @@ public class VersionTable extends Table {
         );
     }
 
-    public boolean isNewDatabase() throws SQLException {
+    public boolean isNewDatabase() {
         String sql = usingMySQL ?
                 "SHOW TABLES LIKE ?" :
                 "SELECT tbl_name FROM sqlite_master WHERE tbl_name=?";
@@ -51,7 +51,7 @@ public class VersionTable extends Table {
      * @return @throws SQLException
      */
     @Override
-    public int getVersion() throws SQLException {
+    public int getVersion() {
         String sql = "SELECT * FROM " + tableName;
 
         return query(new QueryAllStatement<Integer>(sql) {
@@ -70,9 +70,8 @@ public class VersionTable extends Table {
      * Set the DB Schema version
      *
      * @param version DB Schema version
-     * @throws SQLException DB Error
      */
-    public void setVersion(int version) throws SQLException {
+    public void setVersion(int version) {
         removeAllData();
 
         String sql = "INSERT INTO " + tableName + " (version) VALUES (?)";

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/WorldTable.java

@@ -58,9 +58,8 @@ public class WorldTable extends Table {
      * Used to get the available world names.
      *
      * @return List of all world names in the database.
-     * @throws SQLException Database error occurs.
      */
-    public List<String> getAllWorlds() throws SQLException {
+    public List<String> getAllWorlds() {
         String sql = "SELECT * FROM " + tableName;
 
         return query(new QueryAllStatement<List<String>>(sql) {
@@ -76,7 +75,7 @@ public class WorldTable extends Table {
         });
     }
 
-    public Map<UUID, List<String>> getWorldsPerServer() throws SQLException {
+    public Map<UUID, List<String>> getWorldsPerServer() {
         Map<Integer, UUID> serverUUIDsByID = serverTable.getServerUUIDsByID();
         String sql = "SELECT * FROM " + tableName;
 
@@ -96,7 +95,7 @@ public class WorldTable extends Table {
         });
     }
 
-    public Map<Integer, UUID> getServerUUIDByWorldID() throws SQLException {
+    public Map<Integer, UUID> getServerUUIDByWorldID() {
         Map<Integer, UUID> serverUUIDsByID = serverTable.getServerUUIDsByID();
         String sql = "SELECT DISTINCT " +
                 Col.ID + ", " +
@@ -117,11 +116,11 @@ public class WorldTable extends Table {
         });
     }
 
-    public List<String> getWorlds() throws SQLException {
+    public List<String> getWorlds() {
         return getWorlds(ServerInfo.getServerUUID());
     }
 
-    public List<String> getWorlds(UUID serverUUID) throws SQLException {
+    public List<String> getWorlds(UUID serverUUID) {
         String sql = "SELECT * FROM " + tableName +
                 " WHERE " + Col.SERVER_ID + "=" + serverTable.statementSelectServerID;
 
@@ -144,7 +143,7 @@ public class WorldTable extends Table {
         });
     }
 
-    public void saveWorlds(Collection<String> worlds) throws SQLException {
+    public void saveWorlds(Collection<String> worlds) {
         saveWorlds(worlds, ServerInfo.getServerUUID());
     }
 
@@ -154,9 +153,8 @@ public class WorldTable extends Table {
      * Already saved names will not be saved.
      *
      * @param worlds List of world names.
-     * @throws SQLException Database error occurs.
      */
-    public void saveWorlds(Collection<String> worlds, UUID serverUUID) throws SQLException {
+    public void saveWorlds(Collection<String> worlds, UUID serverUUID) {
         Verify.nullCheck(worlds);
         Set<String> worldsToSave = new HashSet<>(worlds);
 
@@ -183,7 +181,7 @@ public class WorldTable extends Table {
         });
     }
 
-    public Set<String> getWorldNames(UUID serverUUID) throws SQLException {
+    public Set<String> getWorldNames(UUID serverUUID) {
         String sql = "SELECT DISTINCT " + Col.NAME + " FROM " + tableName +
                 " WHERE " + Col.SERVER_ID + "=" + serverTable.statementSelectServerID;
         return query(new QueryStatement<Set<String>>(sql, 100) {
@@ -208,11 +206,10 @@ public class WorldTable extends Table {
      *
      * @param serverUUID UUID of the Server
      * @return World names known for that server
-     * @throws SQLException If DB Error occurs
      * @deprecated Use getWorldNames instead, this method is slower.
      */
     @Deprecated
-    public Set<String> getWorldNamesOld(UUID serverUUID) throws SQLException {
+    public Set<String> getWorldNamesOld(UUID serverUUID) {
         WorldTimesTable worldTimesTable = db.getWorldTimesTable();
         SessionsTable sessionsTable = db.getSessionsTable();
 
@@ -247,7 +244,7 @@ public class WorldTable extends Table {
         });
     }
 
-    public void alterTableV16() throws SQLException {
+    public void alterTableV16() {
         addColumns(Col.SERVER_ID + " integer NOT NULL DEFAULT 0");
 
         List<UUID> serverUUIDs = serverTable.getServerUUIDs();
@@ -268,7 +265,7 @@ public class WorldTable extends Table {
         execute("DELETE FROM " + tableName + " WHERE " + Col.SERVER_ID + "=0");
     }
 
-    private void updateWorldTimesTableWorldIDs() throws SQLException {
+    private void updateWorldTimesTableWorldIDs() {
         List<WorldObj> worldObjects = getWorldObjects();
         Map<WorldObj, List<WorldObj>> oldToNewMap =
                 worldObjects.stream()
@@ -302,7 +299,7 @@ public class WorldTable extends Table {
         });
     }
 
-    public Map<Integer, List<Integer>> getWorldIDsByServerIDs() throws SQLException {
+    public Map<Integer, List<Integer>> getWorldIDsByServerIDs() {
         String sql = "SELECT " +
                 Col.ID + ", " +
                 Col.SERVER_ID +
@@ -324,7 +321,7 @@ public class WorldTable extends Table {
         });
     }
 
-    public List<WorldObj> getWorldObjects() throws SQLException {
+    public List<WorldObj> getWorldObjects() {
         String sql = "SELECT * FROM " + tableName;
         return query(new QueryAllStatement<List<WorldObj>>(sql, 100) {
             @Override

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/WorldTimesTable.java

@@ -1,6 +1,7 @@
 package com.djrapitops.plan.system.database.databases.sql.tables;
 
 import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.container.Session;
 import com.djrapitops.plan.data.time.GMTimes;
 import com.djrapitops.plan.data.time.WorldTimes;
@@ -81,7 +82,7 @@ public class WorldTimesTable extends UserIDTable {
         );
     }
 
-    public void addWorldTimesToSessions(UUID uuid, Map<Integer, Session> sessions) throws SQLException {
+    public void addWorldTimesToSessions(UUID uuid, Map<Integer, Session> sessions) {
         String worldIDColumn = worldTable + "." + WorldTable.Col.ID;
         String worldNameColumn = worldTable + "." + WorldTable.Col.NAME + " as world_name";
         String sql = "SELECT " +
@@ -129,7 +130,7 @@ public class WorldTimesTable extends UserIDTable {
         });
     }
 
-    public void saveWorldTimes(UUID uuid, int sessionID, WorldTimes worldTimes) throws SQLException {
+    public void saveWorldTimes(UUID uuid, int sessionID, WorldTimes worldTimes) {
         Map<String, GMTimes> worldTimesMap = worldTimes.getWorldTimes();
         if (Verify.isEmpty(worldTimesMap)) {
             return;
@@ -162,7 +163,7 @@ public class WorldTimesTable extends UserIDTable {
         });
     }
 
-    public WorldTimes getWorldTimesOfServer(UUID serverUUID) throws SQLException {
+    public WorldTimes getWorldTimesOfServer(UUID serverUUID) {
         String worldIDColumn = worldTable + "." + WorldTable.Col.ID;
         String worldNameColumn = worldTable + "." + WorldTable.Col.NAME + " as world_name";
         String sql = "SELECT " +
@@ -204,7 +205,7 @@ public class WorldTimesTable extends UserIDTable {
         });
     }
 
-    public WorldTimes getWorldTimesOfUser(UUID uuid) throws SQLException {
+    public WorldTimes getWorldTimesOfUser(UUID uuid) {
         String worldIDColumn = worldTable + "." + WorldTable.Col.ID;
         String worldNameColumn = worldTable + "." + WorldTable.Col.NAME + " as world_name";
         String sql = "SELECT " +
@@ -246,7 +247,7 @@ public class WorldTimesTable extends UserIDTable {
         });
     }
 
-    public Map<Integer, WorldTimes> getAllWorldTimesBySessionID() throws SQLException {
+    public Map<Integer, WorldTimes> getAllWorldTimesBySessionID() {
         String worldIDColumn = worldTable + "." + WorldTable.Col.ID;
         String worldNameColumn = worldTable + "." + WorldTable.Col.NAME + " as world_name";
         String sql = "SELECT " +
@@ -286,7 +287,7 @@ public class WorldTimesTable extends UserIDTable {
         });
     }
 
-    public void addWorldTimesToSessions(Map<UUID, Map<UUID, List<Session>>> map) throws SQLException {
+    public void addWorldTimesToSessions(Map<UUID, Map<UUID, List<Session>>> map) {
         Map<Integer, WorldTimes> worldTimesBySessionID = getAllWorldTimesBySessionID();
 
         for (UUID serverUUID : map.keySet()) {
@@ -301,7 +302,7 @@ public class WorldTimesTable extends UserIDTable {
         }
     }
 
-    public void saveWorldTimes(Map<UUID, Map<UUID, List<Session>>> allSessions) throws SQLException {
+    public void saveWorldTimes(Map<UUID, Map<UUID, List<Session>>> allSessions) {
         if (Verify.isEmpty(allSessions)) {
             return;
         }
@@ -380,7 +381,7 @@ public class WorldTimesTable extends UserIDTable {
                     });
 
                     worldTable.alterTableV16();
-                } catch (SQLException e) {
+                } catch (DBOpException e) {
                     Log.toLog(this.getClass().getName(), e);
                 } finally {
                     cancel();

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/move/BatchOperationTable.java

@@ -4,7 +4,6 @@
  */
 package com.djrapitops.plan.system.database.databases.sql.tables.move;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.container.UserInfo;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.database.databases.sql.tables.ServerTable;
@@ -13,7 +12,6 @@ import com.djrapitops.plan.system.database.databases.sql.tables.UsersTable;
 import com.djrapitops.plan.system.info.server.Server;
 import com.djrapitops.plugin.api.utility.log.Log;
 
-import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
@@ -60,24 +58,16 @@ public class BatchOperationTable extends Table {
         throw new IllegalStateException("Method not supposed to be used on this table.");
     }
 
-    public void clearTable(Table table) throws SQLException {
+    public void clearTable(Table table) {
         table.removeAllData();
     }
 
     @Override
-    public void removeAllData() throws SQLException {
-        try {
-            db.remove().everything();
-        } catch (DBException e) {
-            if (e.getCause() instanceof SQLException) {
-                throw (SQLException) e.getCause();
-            } else {
-                Log.toLog(this.getClass(), e);
-            }
-        }
+    public void removeAllData() {
+        db.remove().everything();
     }
 
-    public void copyEverything(BatchOperationTable toDB) throws SQLException {
+    public void copyEverything(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
@@ -97,47 +87,47 @@ public class BatchOperationTable extends Table {
         copyUserInfo(toDB);
     }
 
-    public void copyActions(BatchOperationTable toDB) throws SQLException {
+    public void copyActions(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy Actions");
-        toDB.getDb().getActionsTable().insertActions(db.getActionsTable().getAllActions());
+        toDB.db.getActionsTable().insertActions(db.getActionsTable().getAllActions());
     }
 
-    public void copyCommandUse(BatchOperationTable toDB) throws SQLException {
+    public void copyCommandUse(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy Commands");
-        toDB.getDb().getCommandUseTable().insertCommandUsage(db.getCommandUseTable().getAllCommandUsages());
+        toDB.db.getCommandUseTable().insertCommandUsage(db.getCommandUseTable().getAllCommandUsages());
     }
 
-    public void copyIPsAndGeolocs(BatchOperationTable toDB) throws SQLException {
+    public void copyIPsAndGeolocs(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy IPs, Geolocations & Last used dates");
-        toDB.getDb().getGeoInfoTable().insertAllGeoInfo(db.getGeoInfoTable().getAllGeoInfo());
+        toDB.db.getGeoInfoTable().insertAllGeoInfo(db.getGeoInfoTable().getAllGeoInfo());
     }
 
-    public void copyNicknames(BatchOperationTable toDB) throws SQLException {
+    public void copyNicknames(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy Nicknames");
-        toDB.getDb().getNicknamesTable().insertNicknames(db.getNicknamesTable().getAllNicknames());
+        toDB.db.getNicknamesTable().insertNicknames(db.getNicknamesTable().getAllNicknames());
     }
 
-    public void copyWebUsers(BatchOperationTable toDB) throws SQLException {
+    public void copyWebUsers(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy WebUsers");
-        toDB.getDb().getSecurityTable().addUsers(db.getSecurityTable().getUsers());
+        toDB.db.getSecurityTable().addUsers(db.getSecurityTable().getUsers());
     }
 
-    public void copyServers(BatchOperationTable toDB) throws SQLException {
+    public void copyServers(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
@@ -145,50 +135,50 @@ public class BatchOperationTable extends Table {
         ServerTable serverTable = db.getServerTable();
         List<Server> servers = new ArrayList<>(serverTable.getBukkitServers().values());
         serverTable.getBungeeInfo().ifPresent(servers::add);
-        toDB.getDb().getServerTable().insertAllServers(servers);
+        toDB.db.getServerTable().insertAllServers(servers);
     }
 
-    public void copyTPS(BatchOperationTable toDB) throws SQLException {
+    public void copyTPS(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy TPS");
-        toDB.getDb().getTpsTable().insertAllTPS(db.getTpsTable().getAllTPS());
+        toDB.db.getTpsTable().insertAllTPS(db.getTpsTable().getAllTPS());
     }
 
-    public void copyUserInfo(BatchOperationTable toDB) throws SQLException {
+    public void copyUserInfo(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy UserInfo");
-        toDB.getDb().getUserInfoTable().insertUserInfo(db.getUserInfoTable().getAllUserInfo());
+        toDB.db.getUserInfoTable().insertUserInfo(db.getUserInfoTable().getAllUserInfo());
     }
 
-    public void copyWorlds(BatchOperationTable toDB) throws SQLException {
+    public void copyWorlds(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy Worlds");
-        toDB.getDb().getWorldTable().saveWorlds(db.getWorldTable().getAllWorlds());
+        toDB.db.getWorldTable().saveWorlds(db.getWorldTable().getAllWorlds());
     }
 
-    public void copyUsers(BatchOperationTable toDB) throws SQLException {
+    public void copyUsers(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy Users");
         UsersTable fromTable = db.getUsersTable();
-        UsersTable toTable = toDB.getDb().getUsersTable();
+        UsersTable toTable = toDB.db.getUsersTable();
         Map<UUID, UserInfo> users = fromTable.getUsers();
         toTable.insertUsers(users);
         toTable.updateKicked(fromTable.getAllTimesKicked());
     }
 
-    public void copySessions(BatchOperationTable toDB) throws SQLException {
+    public void copySessions(BatchOperationTable toDB) {
         if (toDB.equals(this)) {
             return;
         }
         Log.debug("Batch Copy Sessions");
-        toDB.getDb().getSessionsTable().insertSessions(db.getSessionsTable().getAllSessions(true), true);
+        toDB.db.getSessionsTable().insertSessions(db.getSessionsTable().getAllSessions(true), true);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/move/TransferTable.java

@@ -3,8 +3,6 @@ package com.djrapitops.plan.system.database.databases.sql.tables.move;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.database.databases.sql.tables.Table;
 
-import java.sql.SQLException;
-
 /**
  * Abstract table used for transferring a whole table to a new table.
  *
@@ -21,14 +19,14 @@ public class TransferTable extends Table {
         throw new IllegalStateException("Method not supposed to be used on this table.");
     }
 
-    protected void renameTable(String from, String to) throws SQLException {
+    protected void renameTable(String from, String to) {
         String sql = usingMySQL ?
                 "RENAME TABLE " + from + " TO " + to :
                 "ALTER TABLE " + from + " RENAME TO " + to;
         execute(sql);
     }
 
-    protected void dropTable(String name) throws SQLException {
+    protected void dropTable(String name) {
         String sql = "DROP TABLE " + name;
         execute(sql);
     }

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/move/Version18TransferTable.java

@@ -1,10 +1,9 @@
 package com.djrapitops.plan.system.database.databases.sql.tables.move;
 
 import com.djrapitops.plan.api.exceptions.database.DBInitException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 
-import java.sql.SQLException;
-
 /**
  * DB Schema v17 -> 18 table.
  * <p>
@@ -14,16 +13,16 @@ import java.sql.SQLException;
  */
 public class Version18TransferTable extends TransferTable {
 
-    public Version18TransferTable(SQLDB db) throws SQLException {
+    public Version18TransferTable(SQLDB db) {
         super(db);
     }
 
-    public void alterTableV18() throws SQLException, DBInitException {
+    public void alterTableV18() throws DBInitException {
         String tempTableName = "plan_ips_temp";
         String ipTableName = "plan_ips";
         try {
             renameTable(ipTableName, tempTableName);
-        } catch (SQLException e) {
+        } catch (DBOpException e) {
             // Temp table already exists
             if (!e.getMessage().contains("plan_ips_temp")) {
                 throw e;

Plan/src/main/java/com/djrapitops/plan/system/database/databases/sql/tables/move/Version8TransferTable.java

@@ -10,7 +10,6 @@ import com.djrapitops.plan.system.database.databases.sql.tables.*;
 import com.djrapitops.plan.system.info.server.ServerInfo;
 import com.djrapitops.plugin.api.Benchmark;
 
-import java.sql.SQLException;
 import java.util.Optional;
 
 /**
@@ -24,7 +23,7 @@ public class Version8TransferTable extends TransferTable {
 
     private final int serverID;
 
-    public Version8TransferTable(SQLDB db) throws SQLException {
+    public Version8TransferTable(SQLDB db) {
         super(db);
         Optional<Integer> serverID = db.getServerTable().getServerID(ServerInfo.getServerUUID());
         if (!serverID.isPresent()) {
@@ -33,7 +32,7 @@ public class Version8TransferTable extends TransferTable {
         this.serverID = serverID.get();
     }
 
-    public void alterTablesToV10() throws SQLException, DBInitException {
+    public void alterTablesToV10() throws DBInitException {
         Benchmark.start("Schema copy from 8 to 10");
         copyCommandUsage();
 
@@ -61,7 +60,7 @@ public class Version8TransferTable extends TransferTable {
         Benchmark.stop("Schema copy from 8 to 10");
     }
 
-    private void copyUsers() throws SQLException, DBInitException {
+    private void copyUsers() throws DBInitException {
         String tempTableName = "temp_users";
         UsersTable usersTable = db.getUsersTable();
         renameTable("plan_users", tempTableName);
@@ -122,7 +121,7 @@ public class Version8TransferTable extends TransferTable {
         }
     }
 
-    private void copyCommandUsage() throws SQLException, DBInitException {
+    private void copyCommandUsage() throws DBInitException {
         String tempTableName = "temp_cmdusg";
         CommandUseTable commandUseTable = db.getCommandUseTable();
 
@@ -141,7 +140,7 @@ public class Version8TransferTable extends TransferTable {
         dropTable(tempTableName);
     }
 
-    private void copyTPS() throws SQLException, DBInitException {
+    private void copyTPS() throws DBInitException {
         String tempTableName = "temp_tps";
         TPSTable tpsTable = db.getTpsTable();
 

Plan/src/main/java/com/djrapitops/plan/system/info/connection/BungeeConnectionSystem.java

@@ -5,7 +5,7 @@
 package com.djrapitops.plan.system.info.connection;
 
 import com.djrapitops.plan.api.exceptions.connection.NoServersException;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.request.*;
 import com.djrapitops.plan.system.info.server.Server;
@@ -35,7 +35,7 @@ public class BungeeConnectionSystem extends ConnectionSystem {
             try {
                 bukkitServers = Database.getActive().fetch().getBukkitServers();
                 latestServerMapRefresh = System.currentTimeMillis();
-            } catch (DBException e) {
+            } catch (DBOpException e) {
                 Log.toLog(this.getClass(), e);
             }
         }

Plan/src/main/java/com/djrapitops/plan/system/info/connection/ConnectionIn.java

@@ -1,7 +1,7 @@
 package com.djrapitops.plan.system.info.connection;
 
 import com.djrapitops.plan.api.exceptions.connection.*;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.request.InfoRequest;
 import com.djrapitops.plan.system.info.request.SetupRequest;
@@ -40,7 +40,7 @@ public class ConnectionIn {
             if (Database.getActive().check().isServerInDatabase(serverUUID)) {
                 return;
             }
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             throw new TransferDatabaseException(e);
         }
 

Plan/src/main/java/com/djrapitops/plan/system/info/connection/ConnectionSystem.java

@@ -8,7 +8,7 @@ import com.djrapitops.plan.Plan;
 import com.djrapitops.plan.api.exceptions.connection.NoServersException;
 import com.djrapitops.plan.api.exceptions.connection.UnsupportedTransferDatabaseException;
 import com.djrapitops.plan.api.exceptions.connection.WebException;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.SubSystem;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.InfoSystem;
@@ -104,7 +104,7 @@ public abstract class ConnectionSystem implements SubSystem {
             return Database.getActive().transfer().getServerPlayerIsOnlineOn(playerUUID);
         } catch (UnsupportedTransferDatabaseException e) {
             /* Do nothing */
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             Log.toLog(this.getClass(), e);
         }
         return Optional.empty();

Plan/src/main/java/com/djrapitops/plan/system/info/connection/ServerConnectionSystem.java

@@ -6,7 +6,6 @@ package com.djrapitops.plan.system.info.connection;
 
 import com.djrapitops.plan.api.exceptions.connection.ConnectionFailException;
 import com.djrapitops.plan.api.exceptions.connection.NoServersException;
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.request.*;
 import com.djrapitops.plan.system.info.server.Server;
@@ -40,15 +39,11 @@ public class ServerConnectionSystem extends ConnectionSystem {
     private void refreshServerMap() {
         Processing.submitNonCritical(() -> {
             if (latestServerMapRefresh < System.currentTimeMillis() - TimeAmount.SECOND.ms() * 15L) {
-                try {
-                    Database database = Database.getActive();
-                    Optional<Server> bungeeInformation = database.fetch().getBungeeInformation();
-                    bungeeInformation.ifPresent(server -> mainServer = server);
-                    bukkitServers = database.fetch().getBukkitServers();
-                    latestServerMapRefresh = System.currentTimeMillis();
-                } catch (DBException e) {
-                    Log.toLog(this.getClass(), e);
-                }
+                Database database = Database.getActive();
+                Optional<Server> bungeeInformation = database.fetch().getBungeeInformation();
+                bungeeInformation.ifPresent(server -> mainServer = server);
+                bukkitServers = database.fetch().getBukkitServers();
+                latestServerMapRefresh = System.currentTimeMillis();
             }
         });
     }

Plan/src/main/java/com/djrapitops/plan/system/info/server/BukkitServerInfo.java

@@ -6,12 +6,11 @@ package com.djrapitops.plan.system.info.server;
 
 import com.djrapitops.plan.Plan;
 import com.djrapitops.plan.api.exceptions.EnableException;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.file.FileSystem;
 import com.djrapitops.plan.system.settings.Settings;
 import com.djrapitops.plan.system.webserver.WebServerSystem;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.io.IOException;
 import java.util.Optional;
@@ -53,7 +52,7 @@ public class BukkitServerInfo extends ServerInfo {
         Optional<UUID> serverUUID = serverInfoFile.getUUID();
         try {
             return serverUUID.isPresent() ? updateDbInfo(serverUUID.get()) : registerServer();
-        } catch (DBException e) {
+        } catch (DBOpException e) {
             String causeMsg = e.getCause().getMessage();
             throw new EnableException("Failed to read Server information from Database: " + causeMsg, e);
         } catch (IOException e) {
@@ -61,7 +60,7 @@ public class BukkitServerInfo extends ServerInfo {
         }
     }
 
-    private Server updateDbInfo(UUID serverUUID) throws IOException, DBException {
+    private Server updateDbInfo(UUID serverUUID) throws IOException {
         Optional<Integer> serverID = database.fetch().getServerID(serverUUID);
         if (!serverID.isPresent()) {
             return registerServer(serverUUID);
@@ -78,11 +77,11 @@ public class BukkitServerInfo extends ServerInfo {
         return server;
     }
 
-    private Server registerServer() throws DBException, IOException {
+    private Server registerServer() throws IOException {
         return registerServer(generateNewUUID(serverProperties));
     }
 
-    private Server registerServer(UUID serverUUID) throws DBException, IOException {
+    private Server registerServer(UUID serverUUID) throws IOException {
         String webAddress = WebServerSystem.getInstance().getWebServer().getAccessAddress();
         String name = Settings.SERVER_NAME.toString().replaceAll("[^a-zA-Z0-9_\\s]", "_");
         int maxPlayers = ServerInfo.getServerProperties().getMaxPlayers();
@@ -106,17 +105,4 @@ public class BukkitServerInfo extends ServerInfo {
         String seed = serverProperties.getServerId() + serverProperties.getName() + serverProperties.getIp() + serverProperties.getPort() + serverProperties.getVersion() + serverProperties.getImplVersion();
         return UUID.nameUUIDFromBytes(seed.getBytes());
     }
-
-    @Deprecated
-    public Optional<String> getBungeeConnectionAddress() {
-        try {
-            Optional<Server> bungeeInfo = Database.getActive().fetch().getBungeeInformation();
-            if (bungeeInfo.isPresent()) {
-                return Optional.of(bungeeInfo.get().getWebAddress());
-            }
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
-        }
-        return Optional.empty();
-    }
 }

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/CommandProcessor.java

@@ -4,10 +4,8 @@
  */
 package com.djrapitops.plan.system.processing.processors;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.processing.CriticalRunnable;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 /**
  * Updates Command usage amount in the database.
@@ -24,10 +22,6 @@ public class CommandProcessor implements CriticalRunnable {
 
     @Override
     public void run() {
-        try {
-            Database.getActive().save().commandUsed(command);
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
-        }
+        Database.getActive().save().commandUsed(command);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/TPSInsertProcessor.java

@@ -4,13 +4,11 @@
  */
 package com.djrapitops.plan.system.processing.processors;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.container.TPS;
 import com.djrapitops.plan.data.container.builders.TPSBuilder;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.processing.CriticalRunnable;
 import com.djrapitops.plan.utilities.analysis.MathUtils;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.util.List;
 
@@ -48,10 +46,6 @@ public class TPSInsertProcessor implements CriticalRunnable {
                 .chunksLoaded(averageChunksLoaded)
                 .toTPS();
 
-        try {
-            Database.getActive().save().insertTPSforThisServer(tps);
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
-        }
+        Database.getActive().save().insertTPSforThisServer(tps);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/BanAndOpProcessor.java

@@ -4,10 +4,8 @@
  */
 package com.djrapitops.plan.system.processing.processors.player;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.database.databases.operation.SaveOperations;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.util.UUID;
 
@@ -30,12 +28,8 @@ public class BanAndOpProcessor implements Runnable {
 
     @Override
     public void run() {
-        try {
-            SaveOperations save = Database.getActive().save();
-            save.banStatus(uuid, banned);
-            save.opStatus(uuid, op);
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
-        }
+        SaveOperations save = Database.getActive().save();
+        save.banStatus(uuid, banned);
+        save.opStatus(uuid, op);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/BungeePlayerRegisterProcessor.java

@@ -4,11 +4,9 @@
  */
 package com.djrapitops.plan.system.processing.processors.player;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.processing.CriticalRunnable;
 import com.djrapitops.plan.system.processing.Processing;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.util.UUID;
 
@@ -39,8 +37,6 @@ public class BungeePlayerRegisterProcessor implements CriticalRunnable {
                 return;
             }
             database.save().registerNewUser(uuid, registered, name);
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
         } finally {
             for (Runnable process : afterProcess) {
                 Processing.submit(process);

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/FirstLeaveProcessor.java

@@ -4,13 +4,11 @@
  */
 package com.djrapitops.plan.system.processing.processors.player;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.Actions;
 import com.djrapitops.plan.data.container.Action;
 import com.djrapitops.plan.system.cache.SessionCache;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.processing.CriticalRunnable;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.util.UUID;
 
@@ -34,8 +32,6 @@ public class FirstLeaveProcessor implements CriticalRunnable {
     public void run() {
         try {
             Database.getActive().save().action(uuid, leaveAction);
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
         } finally {
             SessionCache.getInstance().endFirstSessionActionTracking(uuid);
         }

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/IPUpdateProcessor.java

@@ -4,7 +4,6 @@
  */
 package com.djrapitops.plan.system.processing.processors.player;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.container.GeoInfo;
 import com.djrapitops.plan.system.cache.GeolocationCache;
 import com.djrapitops.plan.system.database.databases.Database;
@@ -40,7 +39,7 @@ public class IPUpdateProcessor implements CriticalRunnable {
             try {
                 GeoInfo geoInfo = new GeoInfo(ip, country, time);
                 Database.getActive().save().geoInfo(uuid, geoInfo);
-            } catch (DBException | UnsupportedEncodingException | NoSuchAlgorithmException e) {
+            } catch (UnsupportedEncodingException | NoSuchAlgorithmException e) {
                 Log.toLog(this.getClass(), e);
             }
         }

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/KickProcessor.java

@@ -4,10 +4,8 @@
  */
 package com.djrapitops.plan.system.processing.processors.player;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.processing.CriticalRunnable;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.util.UUID;
 
@@ -26,10 +24,6 @@ public class KickProcessor implements CriticalRunnable {
 
     @Override
     public void run() {
-        try {
-            Database.getActive().save().playerWasKicked(uuid);
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
-        }
+        Database.getActive().save().playerWasKicked(uuid);
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/NameProcessor.java

@@ -4,7 +4,6 @@
  */
 package com.djrapitops.plan.system.processing.processors.player;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.Actions;
 import com.djrapitops.plan.data.container.Action;
 import com.djrapitops.plan.system.cache.DataCache;
@@ -13,7 +12,6 @@ import com.djrapitops.plan.system.info.server.ServerInfo;
 import com.djrapitops.plan.system.processing.CriticalRunnable;
 import com.djrapitops.plan.system.processing.Processing;
 import com.djrapitops.plan.utilities.html.HtmlUtils;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.util.List;
 import java.util.UUID;
@@ -47,20 +45,16 @@ public class NameProcessor implements CriticalRunnable {
             return;
         }
 
-        Database database = Database.getActive();
-        try {
-            cueNameChangeActionProcessor(uuid, database);
-            database.save().playerName(uuid, playerName);
-
-            database.save().playerDisplayName(uuid, displayName);
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
-        }
-
         dataCache.updateNames(uuid, playerName, displayName);
+
+        Database database = Database.getActive();
+        cueNameChangeActionProcessor(uuid, database);
+        database.save().playerName(uuid, playerName);
+
+        database.save().playerDisplayName(uuid, displayName);
     }
 
-    private void cueNameChangeActionProcessor(UUID uuid, Database db) throws DBException {
+    private void cueNameChangeActionProcessor(UUID uuid, Database db) {
         List<String> nicknames = db.fetch().getNicknamesOfPlayerOnServer(uuid, ServerInfo.getServerUUID());
         if (nicknames.contains(displayName)) {
             return;
@@ -73,11 +67,7 @@ public class NameProcessor implements CriticalRunnable {
 
             Action action = new Action(time, Actions.NEW_NICKNAME, info);
 
-            try {
-                Database.getActive().save().action(uuid, action);
-            } catch (DBException e) {
-                Log.toLog(this.getClass(), e);
-            }
+            Database.getActive().save().action(uuid, action);
         });
     }
 }

Plan/src/main/java/com/djrapitops/plan/system/processing/processors/player/RegisterProcessor.java

@@ -4,14 +4,12 @@
  */
 package com.djrapitops.plan.system.processing.processors.player;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.Actions;
 import com.djrapitops.plan.data.container.Action;
 import com.djrapitops.plan.system.cache.SessionCache;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.processing.CriticalRunnable;
 import com.djrapitops.plan.system.processing.Processing;
-import com.djrapitops.plugin.api.utility.log.Log;
 import com.djrapitops.plugin.utilities.Verify;
 
 import java.util.UUID;
@@ -55,8 +53,6 @@ public class RegisterProcessor implements CriticalRunnable {
             }
             SessionCache.getInstance().markFirstSession(uuid);
             db.save().action(uuid, new Action(time, Actions.FIRST_SESSION, "Online: " + playersOnline + " Players"));
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
         } finally {
             for (Runnable runnable : afterProcess) {
                 Processing.submit(runnable);

Plan/src/main/java/com/djrapitops/plan/system/webserver/auth/BasicAuthentication.java

@@ -6,7 +6,7 @@ package com.djrapitops.plan.system.webserver.auth;
 
 import com.djrapitops.plan.api.exceptions.PassEncryptException;
 import com.djrapitops.plan.api.exceptions.WebUserAuthException;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.WebUser;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.utilities.Base64Util;
@@ -54,7 +54,7 @@ public class BasicAuthentication implements Authentication {
                 throw new WebUserAuthException(FailReason.USER_PASS_MISMATCH, user);
             }
             return webUser;
-        } catch (DBException | PassEncryptException e) {
+        } catch (DBOpException | PassEncryptException e) {
             throw new WebUserAuthException(e);
         }
     }

Plan/src/main/java/com/djrapitops/plan/system/webserver/pages/PlayerPageHandler.java

@@ -5,10 +5,8 @@
 package com.djrapitops.plan.system.webserver.pages;
 
 import com.djrapitops.plan.api.exceptions.WebUserAuthException;
-import com.djrapitops.plan.api.exceptions.connection.InternalErrorException;
 import com.djrapitops.plan.api.exceptions.connection.NoServersException;
 import com.djrapitops.plan.api.exceptions.connection.WebException;
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.data.WebUser;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.InfoSystem;
@@ -21,7 +19,6 @@ import com.djrapitops.plan.system.webserver.response.cache.ResponseCache;
 import com.djrapitops.plan.system.webserver.response.errors.NotFoundResponse;
 import com.djrapitops.plan.system.webserver.response.pages.InspectPageResponse;
 import com.djrapitops.plan.utilities.uuid.UUIDUtility;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.util.List;
 import java.util.UUID;
@@ -45,7 +42,6 @@ public class PlayerPageHandler extends PageHandler {
         if (uuid == null) {
             return notFound("Player UUID was not found in the database.");
         }
-
         try {
             if (Database.getActive().check().isPlayerRegistered(uuid)) {
                 Response response = ResponseCache.loadResponse(PageId.PLAYER.of(uuid));
@@ -57,9 +53,6 @@ public class PlayerPageHandler extends PageHandler {
             } else {
                 return notFound("Player has not played on this server.");
             }
-        } catch (DBException e) {
-            Log.toLog(this.getClass(), e);
-            throw new InternalErrorException("Analysis", e);
         } catch (NoServersException e) {
             ResponseCache.loadResponse(PageId.PLAYER.of(uuid), () -> new NotFoundResponse(e.getMessage()));
         }

Plan/src/main/java/com/djrapitops/plan/system/webserver/pages/ServerPageHandler.java

@@ -6,7 +6,6 @@ package com.djrapitops.plan.system.webserver.pages;
 
 import com.djrapitops.plan.api.exceptions.WebUserAuthException;
 import com.djrapitops.plan.api.exceptions.connection.WebException;
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.InfoSystem;
 import com.djrapitops.plan.system.info.server.ServerInfo;
@@ -17,7 +16,6 @@ import com.djrapitops.plan.system.webserver.response.cache.PageId;
 import com.djrapitops.plan.system.webserver.response.cache.ResponseCache;
 import com.djrapitops.plan.system.webserver.response.pages.AnalysisPageResponse;
 import com.djrapitops.plugin.api.Check;
-import com.djrapitops.plugin.api.utility.log.Log;
 
 import java.util.List;
 import java.util.Optional;
@@ -61,8 +59,6 @@ public class ServerPageHandler extends PageHandler {
                 }
             } catch (IllegalArgumentException ignore) {
                 /*ignored*/
-            } catch (DBException e) {
-                Log.toLog(this.getClass(), e);
             }
         }
         return serverUUID;

Plan/src/main/java/com/djrapitops/plan/system/webserver/response/pages/DebugPageResponse.java

@@ -5,6 +5,7 @@
 package com.djrapitops.plan.system.webserver.response.pages;
 
 import com.djrapitops.plan.PlanPlugin;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.database.databases.sql.SQLDB;
 import com.djrapitops.plan.system.info.connection.ConnectionLog;
@@ -25,7 +26,6 @@ import java.io.IOException;
 import java.lang.management.ManagementFactory;
 import java.lang.management.RuntimeMXBean;
 import java.nio.charset.Charset;
-import java.sql.SQLException;
 import java.util.*;
 
 /**
@@ -121,7 +121,7 @@ public class DebugPageResponse extends ErrorResponse {
         if (database instanceof SQLDB) {
             try {
                 content.append(" schema v").append(((SQLDB) database).getVersion());
-            } catch (SQLException e) {
+            } catch (DBOpException e) {
                 Log.toLog(this.getClass(), e);
             }
         }

Plan/src/main/java/com/djrapitops/plan/system/webserver/response/pages/PlayersPageResponse.java

@@ -1,7 +1,7 @@
 package com.djrapitops.plan.system.webserver.response.pages;
 
 import com.djrapitops.plan.PlanPlugin;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.container.GeoInfo;
 import com.djrapitops.plan.data.container.Session;
 import com.djrapitops.plan.data.container.UserInfo;
@@ -124,8 +124,8 @@ public class PlayersPageResponse extends Response {
             } catch (IllegalArgumentException ignored) {
             }
             return html.append("</tbody></table>").toString();
-        } catch (DBException e) {
-            Log.toLog(PlayersPageResponse.class.getClass().getName(), e);
+        } catch (DBOpException e) {
+            Log.toLog(PlayersPageResponse.class, e);
             return new InternalErrorResponse("/players", e).getContent();
         }
     }

Plan/src/main/java/com/djrapitops/plan/utilities/MiscUtils.java

@@ -1,7 +1,6 @@
 package com.djrapitops.plan.utilities;
 
 import com.djrapitops.plan.PlanPlugin;
-import com.djrapitops.plan.api.exceptions.database.DBException;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.settings.Permissions;
 import com.djrapitops.plan.system.settings.Settings;
@@ -14,7 +13,6 @@ import com.djrapitops.plugin.command.ISender;
 
 import java.io.Closeable;
 import java.io.IOException;
-import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.TimeZone;
@@ -87,13 +85,7 @@ public class MiscUtils {
      */
     public static List<String> getMatchingPlayerNames(String search) {
         Database db = Database.getActive();
-        List<String> matches;
-        try {
-            matches = db.search().matchingPlayers(search);
-        } catch (DBException e) {
-            Log.toLog(MiscUtils.class, e);
-            return new ArrayList<>();
-        }
+        List<String> matches = db.search().matchingPlayers(search);
         Collections.sort(matches);
         return matches;
     }

Plan/src/main/java/com/djrapitops/plan/utilities/file/export/HtmlExport.java

@@ -5,7 +5,7 @@
 package com.djrapitops.plan.utilities.file.export;
 
 import com.djrapitops.plan.PlanPlugin;
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.container.UserInfo;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.connection.ConnectionSystem;
@@ -39,22 +39,14 @@ public class HtmlExport extends SpecificExport {
     }
 
     public static void exportServer(UUID serverUUID) {
-        try {
-            Optional<String> serverName = Database.getActive().fetch().getServerName(serverUUID);
-            serverName.ifPresent(s -> RunnableFactory.createNew(new AnalysisExport(serverUUID, s)).runTaskAsynchronously());
-        } catch (DBException e) {
-            Log.toLog(HtmlExport.class.getClass().getName(), e);
-        }
+        Optional<String> serverName = Database.getActive().fetch().getServerName(serverUUID);
+        serverName.ifPresent(s -> RunnableFactory.createNew(new AnalysisExport(serverUUID, s)).runTaskAsynchronously());
     }
 
     public static void exportPlayer(UUID playerUUID) {
-        try {
-            String playerName = Database.getActive().fetch().getPlayerName(playerUUID);
-            if (playerName != null) {
-                RunnableFactory.createNew(new PlayerExport(playerUUID, playerName)).runTaskAsynchronously();
-            }
-        } catch (DBException e) {
-            Log.toLog(HtmlExport.class.getClass().getName(), e);
+        String playerName = Database.getActive().fetch().getPlayerName(playerUUID);
+        if (playerName != null) {
+            RunnableFactory.createNew(new PlayerExport(playerUUID, playerName)).runTaskAsynchronously();
         }
     }
 
@@ -72,7 +64,7 @@ public class HtmlExport extends SpecificExport {
             exportAvailableServerPages();
             exportAvailablePlayers();
             exportPlayersPage();
-        } catch (IOException | DBException e) {
+        } catch (IOException | DBOpException e) {
             Log.toLog(this.getClass(), e);
         } finally {
             try {
@@ -99,13 +91,13 @@ public class HtmlExport extends SpecificExport {
         export(exportFile, lines);
     }
 
-    private void exportAvailablePlayers() throws DBException, IOException {
+    private void exportAvailablePlayers() throws IOException {
         for (Map.Entry<UUID, UserInfo> entry : Database.getActive().fetch().getUsers().entrySet()) {
             exportAvailablePlayerPage(entry.getKey(), entry.getValue().getName());
         }
     }
 
-    private void exportAvailableServerPages() throws IOException, DBException {
+    private void exportAvailableServerPages() throws IOException {
         Map<UUID, String> serverNames = Database.getActive().fetch().getServerNames();
 
         for (Map.Entry<UUID, String> entry : serverNames.entrySet()) {

Plan/src/main/java/com/djrapitops/plan/utilities/html/HtmlStructure.java

@@ -4,7 +4,7 @@
  */
 package com.djrapitops.plan.utilities.html;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.data.container.Session;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plan.system.info.server.Server;
@@ -130,8 +130,8 @@ public class HtmlStructure {
         try {
             playerCount = db.count().getServerPlayerCount(serverUUID);
             playerData = new OnlineActivityGraph(db.fetch().getTPSData(serverUUID)).toHighChartsSeries();
-        } catch (DBException e) {
-            Log.toLog(HtmlStructure.class.getClass().getName(), e);
+        } catch (DBOpException e) {
+            Log.toLog(HtmlStructure.class, e);
         }
 
         return "<div class=\"col-xs-12 col-sm-12 col-md-6 col-lg-6\">" +

Plan/src/main/java/com/djrapitops/plan/utilities/uuid/UUIDUtility.java

@@ -5,8 +5,7 @@
  */
 package com.djrapitops.plan.utilities.uuid;
 
-import com.djrapitops.plan.api.exceptions.database.DBException;
-import com.djrapitops.plan.api.exceptions.database.FatalDBException;
+import com.djrapitops.plan.api.exceptions.database.DBOpException;
 import com.djrapitops.plan.system.cache.DataCache;
 import com.djrapitops.plan.system.database.databases.Database;
 import com.djrapitops.plugin.api.Check;
@@ -58,10 +57,10 @@ public class UUIDUtility {
         }
         try {
             uuid = db.fetch().getUuidOf(playerName);
-        } catch (FatalDBException e) {
-            Log.toLog(UUIDUtility.class, e);
-        } catch (DBException e) {
-            /* Ignored */
+        } catch (DBOpException e) {
+            if (e.isFatal()) {
+                Log.toLog(UUIDUtility.class, e);
+            }
         }
         try {
             if (uuid == null) {

Plan/src/test/java/com/djrapitops/plan/system/database/databases/SQLiteTest.java

@@ -87,7 +87,7 @@ public class SQLiteTest {
     }
 
     @Before
-    public void setUp() throws DBException, SQLException {
+    public void setUp() {
         assertEquals(db, Database.getActive());
         System.out.println("\n-- Clearing Test Database --");
         db.remove().everything();
@@ -120,7 +120,7 @@ public class SQLiteTest {
     }
 
     @Test(timeout = 3000)
-    public void testSaveCommandUse() throws SQLException, DBInitException {
+    public void testSaveCommandUse() throws DBInitException {
         CommandUseTable commandUseTable = db.getCommandUseTable();
         Map<String, Integer> expected = new HashMap<>();
 
@@ -169,7 +169,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testCommandUseTableIDSystem() throws SQLException {
+    public void testCommandUseTableIDSystem() {
         CommandUseTable commandUseTable = db.getCommandUseTable();
         commandUseTable.commandUsed("plan");
 
@@ -220,19 +220,19 @@ public class SQLiteTest {
         assertEquals(expected, tpsTable.getTPSData());
     }
 
-    private void saveUserOne() throws SQLException {
+    private void saveUserOne() {
         saveUserOne(db);
     }
 
-    private void saveUserOne(SQLDB database) throws SQLException {
+    private void saveUserOne(SQLDB database) {
         database.getUsersTable().registerUser(playerUUID, 123456789L, "Test");
     }
 
-    private void saveUserTwo() throws SQLException {
+    private void saveUserTwo() {
         saveUserTwo(db);
     }
 
-    private void saveUserTwo(SQLDB database) throws SQLException {
+    private void saveUserTwo(SQLDB database) {
         database.getUsersTable().registerUser(player2UUID, 123456789L, "Test");
     }
 
@@ -294,7 +294,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testSecurityTable() throws SQLException, DBInitException {
+    public void testSecurityTable() throws DBInitException {
         SecurityTable securityTable = db.getSecurityTable();
         WebUser expected = new WebUser("Test", "RandomGarbageBlah", 0);
         securityTable.addNewUser(expected);
@@ -317,7 +317,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testWorldTable() throws SQLException, DBInitException {
+    public void testWorldTable() throws DBInitException {
         WorldTable worldTable = db.getWorldTable();
         List<String> worlds = Arrays.asList("Test", "Test2", "Test3");
         worldTable.saveWorlds(worlds);
@@ -328,11 +328,11 @@ public class SQLiteTest {
         assertEquals(new HashSet<>(worlds), new HashSet<>(saved));
     }
 
-    private void saveTwoWorlds() throws SQLException {
+    private void saveTwoWorlds() {
         saveTwoWorlds(db);
     }
 
-    private void saveTwoWorlds(SQLDB database) throws SQLException {
+    private void saveTwoWorlds(SQLDB database) {
         database.getWorldTable().saveWorlds(worlds);
     }
 
@@ -429,7 +429,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testUserInfoTableRegisterUnRegistered() throws SQLException, DBInitException {
+    public void testUserInfoTableRegisterUnRegistered() throws DBInitException {
         UserInfoTable userInfoTable = db.getUserInfoTable();
         assertFalse(userInfoTable.isRegistered(playerUUID));
         UsersTable usersTable = db.getUsersTable();
@@ -479,7 +479,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testUserInfoTableUpdateBannedOpped() throws SQLException, DBInitException {
+    public void testUserInfoTableUpdateBannedOpped() throws DBInitException {
         UserInfoTable userInfoTable = db.getUserInfoTable();
         userInfoTable.registerUserInfo(playerUUID, 223456789L);
         assertTrue(userInfoTable.isRegistered(playerUUID));
@@ -544,7 +544,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testRemovalSingleUser() throws SQLException, DBException {
+    public void testRemovalSingleUser() throws SQLException {
         saveUserTwo();
 
         UserInfoTable userInfoTable = db.getUserInfoTable();
@@ -580,7 +580,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testRemovalEverything() throws SQLException, DBException, UnsupportedEncodingException, NoSuchAlgorithmException {
+    public void testRemovalEverything() throws SQLException, UnsupportedEncodingException, NoSuchAlgorithmException {
         UserInfoTable userInfoTable = db.getUserInfoTable();
         UsersTable usersTable = db.getUsersTable();
         SessionsTable sessionsTable = db.getSessionsTable();
@@ -609,7 +609,7 @@ public class SQLiteTest {
         assertTrue(securityTable.getUsers().isEmpty());
     }
 
-    private void saveAllData(SQLDB database) throws SQLException, UnsupportedEncodingException, NoSuchAlgorithmException {
+    private void saveAllData(SQLDB database) throws UnsupportedEncodingException, NoSuchAlgorithmException {
         System.out.println("Saving all possible data to the Database..");
         UserInfoTable userInfoTable = database.getUserInfoTable();
         UsersTable usersTable = database.getUsersTable();
@@ -668,7 +668,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testServerTableBungeeSave() throws SQLException, DBInitException {
+    public void testServerTableBungeeSave() throws DBInitException {
         ServerTable serverTable = db.getServerTable();
 
         Optional<Server> bungeeInfo = serverTable.getBungeeInfo();
@@ -692,7 +692,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testServerTableBungee() throws SQLException, DBInitException {
+    public void testServerTableBungee() throws DBInitException {
         testServerTableBungeeSave();
         ServerTable serverTable = db.getServerTable();
 
@@ -701,7 +701,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testSessionTableNPEWhenNoPlayers() throws SQLException {
+    public void testSessionTableNPEWhenNoPlayers() {
         Map<UUID, Long> lastSeen = db.getSessionsTable().getLastSeenForAllPlayers();
         assertTrue(lastSeen.isEmpty());
     }
@@ -869,7 +869,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testRegisterProcessorRegisterException() throws SQLException {
+    public void testRegisterProcessorRegisterException() {
         assertFalse(db.getUsersTable().isRegistered(playerUUID));
         assertFalse(db.getUserInfoTable().isRegistered(playerUUID));
         System.out.println("\n- Running RegisterProcessors -");
@@ -886,7 +886,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testRegister() throws DBException {
+    public void testRegister() {
         assertFalse(db.check().isPlayerRegistered(playerUUID));
         assertFalse(db.check().isPlayerRegisteredOnThisServer(playerUUID));
         db.save().registerNewUser(playerUUID, 1000L, "name");
@@ -903,7 +903,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testSettingTransfer() throws SQLException {
+    public void testSettingTransfer() {
         String testString = RandomData.randomString(100);
 
         TransferTable transferTable = db.getTransferTable();
@@ -915,7 +915,7 @@ public class SQLiteTest {
     }
 
     @Test
-    public void testGetNetworkGeolocations() throws SQLException {
+    public void testGetNetworkGeolocations() {
         GeoInfoTable geoInfoTable = db.getGeoInfoTable();
         UUID firstUuid = UUID.randomUUID();
         UUID secondUuid = UUID.randomUUID();
@@ -947,72 +947,68 @@ public class SQLiteTest {
         new Table("test", db) {
             @Override
             public void createTable() {
-                try {
-                    execute(
-                            "INSERT INTO " + WorldTable.TABLE_NAME + " (" +
-                                    WorldTable.Col.NAME + ", " +
-                                    WorldTable.Col.SERVER_ID +
-                                    ") VALUES ('Test', '0')"
-                    );
-                    execute(
-                            "INSERT INTO " + SessionsTable.TABLE_NAME + " (" +
-                                    SessionsTable.Col.SESSION_START + ", " +
-                                    SessionsTable.Col.SESSION_END + ", " +
-                                    SessionsTable.Col.AFK_TIME + ", " +
-                                    SessionsTable.Col.DEATHS + ", " +
-                                    SessionsTable.Col.MOB_KILLS + ", " +
-                                    SessionsTable.Col.SERVER_ID + ", " +
-                                    SessionsTable.Col.USER_ID +
-                                    ") VALUES ('0', '0', '0', '0', '0', '1', '1')"
-                    );
-                    execute(
-                            "INSERT INTO " + WorldTimesTable.TABLE_NAME + " (" +
-                                    WorldTimesTable.Col.SERVER_ID + ", " +
-                                    WorldTimesTable.Col.SESSION_ID + ", " +
-                                    WorldTimesTable.Col.USER_ID + ", " +
-                                    WorldTimesTable.Col.WORLD_ID + ", " +
-                                    WorldTimesTable.Col.SURVIVAL + ", " +
-                                    WorldTimesTable.Col.CREATIVE + ", " +
-                                    WorldTimesTable.Col.SPECTATOR + ", " +
-                                    WorldTimesTable.Col.ADVENTURE +
-                                    ") VALUES ('1', '1', '1', '1', '0','0','0','0')"
-                    );
-                    execute(
-                            "INSERT INTO " + ServerTable.TABLE_NAME + " (" +
-                                    ServerTable.Col.SERVER_UUID + ", " +
-                                    ServerTable.Col.SERVER_ID + ", " +
-                                    ServerTable.Col.MAX_PLAYERS + ", " +
-                                    ServerTable.Col.WEBSERVER_ADDRESS + ", " +
-                                    ServerTable.Col.INSTALLED + ", " +
-                                    ServerTable.Col.NAME +
-                                    ") VALUES ('" + UUID.randomUUID() + "', '2', '0', '0', '1', '2')"
-                    );
-                    execute(
-                            "INSERT INTO " + SessionsTable.TABLE_NAME + " (" +
-                                    SessionsTable.Col.SESSION_START + ", " +
-                                    SessionsTable.Col.SESSION_END + ", " +
-                                    SessionsTable.Col.AFK_TIME + ", " +
-                                    SessionsTable.Col.DEATHS + ", " +
-                                    SessionsTable.Col.MOB_KILLS + ", " +
-                                    SessionsTable.Col.SERVER_ID + ", " +
-                                    SessionsTable.Col.USER_ID +
-                                    ") VALUES ('0', '0', '0', '0', '0', '2', '1')"
-                    );
-                    execute(
-                            "INSERT INTO " + WorldTimesTable.TABLE_NAME + " (" +
-                                    WorldTimesTable.Col.SERVER_ID + ", " +
-                                    WorldTimesTable.Col.SESSION_ID + ", " +
-                                    WorldTimesTable.Col.USER_ID + ", " +
-                                    WorldTimesTable.Col.WORLD_ID + ", " +
-                                    WorldTimesTable.Col.SURVIVAL + ", " +
-                                    WorldTimesTable.Col.CREATIVE + ", " +
-                                    WorldTimesTable.Col.SPECTATOR + ", " +
-                                    WorldTimesTable.Col.ADVENTURE +
-                                    ") VALUES ('2', '2', '1', '1', '0','0','0','0')"
-                    );
-                } catch (SQLException e) {
-                    Log.toLog(this.getClass().getName(), e);
-                }
+                execute(
+                        "INSERT INTO " + WorldTable.TABLE_NAME + " (" +
+                                WorldTable.Col.NAME + ", " +
+                                WorldTable.Col.SERVER_ID +
+                                ") VALUES ('Test', '0')"
+                );
+                execute(
+                        "INSERT INTO " + SessionsTable.TABLE_NAME + " (" +
+                                SessionsTable.Col.SESSION_START + ", " +
+                                SessionsTable.Col.SESSION_END + ", " +
+                                SessionsTable.Col.AFK_TIME + ", " +
+                                SessionsTable.Col.DEATHS + ", " +
+                                SessionsTable.Col.MOB_KILLS + ", " +
+                                SessionsTable.Col.SERVER_ID + ", " +
+                                SessionsTable.Col.USER_ID +
+                                ") VALUES ('0', '0', '0', '0', '0', '1', '1')"
+                );
+                execute(
+                        "INSERT INTO " + WorldTimesTable.TABLE_NAME + " (" +
+                                WorldTimesTable.Col.SERVER_ID + ", " +
+                                WorldTimesTable.Col.SESSION_ID + ", " +
+                                WorldTimesTable.Col.USER_ID + ", " +
+                                WorldTimesTable.Col.WORLD_ID + ", " +
+                                WorldTimesTable.Col.SURVIVAL + ", " +
+                                WorldTimesTable.Col.CREATIVE + ", " +
+                                WorldTimesTable.Col.SPECTATOR + ", " +
+                                WorldTimesTable.Col.ADVENTURE +
+                                ") VALUES ('1', '1', '1', '1', '0','0','0','0')"
+                );
+                execute(
+                        "INSERT INTO " + ServerTable.TABLE_NAME + " (" +
+                                ServerTable.Col.SERVER_UUID + ", " +
+                                ServerTable.Col.SERVER_ID + ", " +
+                                ServerTable.Col.MAX_PLAYERS + ", " +
+                                ServerTable.Col.WEBSERVER_ADDRESS + ", " +
+                                ServerTable.Col.INSTALLED + ", " +
+                                ServerTable.Col.NAME +
+                                ") VALUES ('" + UUID.randomUUID() + "', '2', '0', '0', '1', '2')"
+                );
+                execute(
+                        "INSERT INTO " + SessionsTable.TABLE_NAME + " (" +
+                                SessionsTable.Col.SESSION_START + ", " +
+                                SessionsTable.Col.SESSION_END + ", " +
+                                SessionsTable.Col.AFK_TIME + ", " +
+                                SessionsTable.Col.DEATHS + ", " +
+                                SessionsTable.Col.MOB_KILLS + ", " +
+                                SessionsTable.Col.SERVER_ID + ", " +
+                                SessionsTable.Col.USER_ID +
+                                ") VALUES ('0', '0', '0', '0', '0', '2', '1')"
+                );
+                execute(
+                        "INSERT INTO " + WorldTimesTable.TABLE_NAME + " (" +
+                                WorldTimesTable.Col.SERVER_ID + ", " +
+                                WorldTimesTable.Col.SESSION_ID + ", " +
+                                WorldTimesTable.Col.USER_ID + ", " +
+                                WorldTimesTable.Col.WORLD_ID + ", " +
+                                WorldTimesTable.Col.SURVIVAL + ", " +
+                                WorldTimesTable.Col.CREATIVE + ", " +
+                                WorldTimesTable.Col.SPECTATOR + ", " +
+                                WorldTimesTable.Col.ADVENTURE +
+                                ") VALUES ('2', '2', '1', '1', '0','0','0','0')"
+                );
             }
         }.createTable();
 
@@ -1044,6 +1040,7 @@ public class SQLiteTest {
         assertTrue(container.supports(PlayerKeys.UUID));
         assertTrue(container.supports(PlayerKeys.REGISTERED));
         assertTrue(container.supports(PlayerKeys.NAME));
+        assertTrue(container.supports(PlayerKeys.GEO_INFO));
 
         long end = System.nanoTime();
 

Plan/src/test/java/com/djrapitops/plan/utilities/MiscUtilsTest.java

@@ -125,7 +125,7 @@ public class MiscUtilsTest {
     }
 
     @Test
-    public void testGetMatchingNames() throws Exception {
+    public void testGetMatchingNames() {
         String exp1 = "TestName";
         String exp2 = "TestName2";
 
@@ -145,7 +145,7 @@ public class MiscUtilsTest {
     }
 
     @Test
-    public void testGetMatchingNickNames() throws Exception {
+    public void testGetMatchingNickNames() {
         UUID uuid = UUID.randomUUID();
         String userName = RandomData.randomString(10);
         db.getUsersTable().registerUser(uuid, 0L, userName);