From 9d7b031ffabbb614422c5cdf8972687f63124cd2 Mon Sep 17 00:00:00 2001 From: D3v1s0m Date: Sun, 15 Oct 2023 18:54:06 +0530 Subject: [PATCH] Added SQLite Storage --- .../lol/pyr/znpcsplus/config/MainConfig.java | 2 +- .../lol/pyr/znpcsplus/database/Database.java | 16 + .../lol/pyr/znpcsplus/database/SQLite.java | 100 ++++++ .../pyr/znpcsplus/npc/NpcRegistryImpl.java | 8 +- .../pyr/znpcsplus/storage/NpcStorageType.java | 12 + .../storage/sqlite/SQLiteStorage.java | 317 ++++++++++++++++++ 6 files changed, 453 insertions(+), 2 deletions(-) create mode 100644 plugin/src/main/java/lol/pyr/znpcsplus/database/Database.java create mode 100644 plugin/src/main/java/lol/pyr/znpcsplus/database/SQLite.java create mode 100644 plugin/src/main/java/lol/pyr/znpcsplus/storage/sqlite/SQLiteStorage.java diff --git a/plugin/src/main/java/lol/pyr/znpcsplus/config/MainConfig.java b/plugin/src/main/java/lol/pyr/znpcsplus/config/MainConfig.java index 5699da0..1b19a22 100644 --- a/plugin/src/main/java/lol/pyr/znpcsplus/config/MainConfig.java +++ b/plugin/src/main/java/lol/pyr/znpcsplus/config/MainConfig.java @@ -28,7 +28,7 @@ public interface MainConfig { boolean debugEnabled(); @ConfKey("storage-type") - @ConfComments("The storage type to use. Available storage types: YAML") + @ConfComments("The storage type to use. Available storage types: YAML, SQLITE") @DefaultString("YAML") NpcStorageType storageType(); diff --git a/plugin/src/main/java/lol/pyr/znpcsplus/database/Database.java b/plugin/src/main/java/lol/pyr/znpcsplus/database/Database.java new file mode 100644 index 0000000..7e50526 --- /dev/null +++ b/plugin/src/main/java/lol/pyr/znpcsplus/database/Database.java @@ -0,0 +1,16 @@ +package lol.pyr.znpcsplus.database; + +import java.sql.Connection; +import java.util.logging.Logger; + +public abstract class Database { + Logger logger; + Connection connection; + public Database(Logger logger){ + this.logger = logger; + } + + public abstract Connection getSQLConnection(); + + public abstract void load(); +} diff --git a/plugin/src/main/java/lol/pyr/znpcsplus/database/SQLite.java b/plugin/src/main/java/lol/pyr/znpcsplus/database/SQLite.java new file mode 100644 index 0000000..7c4fa64 --- /dev/null +++ b/plugin/src/main/java/lol/pyr/znpcsplus/database/SQLite.java @@ -0,0 +1,100 @@ +package lol.pyr.znpcsplus.database; + +import java.io.File; +import java.io.IOException; +import java.sql.*; +import java.util.logging.Level; +import java.util.logging.Logger; + + +public class SQLite extends Database{ + File dbFile; + public SQLite(File file, Logger logger){ + super(logger); + dbFile = file; + } + + public Connection getSQLConnection() { + if (!dbFile.exists()){ + try { + dbFile.createNewFile(); + } catch (IOException e) { + logger.log(Level.SEVERE, "File write error: "+dbFile.getName()); + } + } + try { + if(connection!=null&&!connection.isClosed()){ + return connection; + } + Class.forName("org.sqlite.JDBC"); + connection = DriverManager.getConnection("jdbc:sqlite:" + dbFile.getAbsolutePath()); + return connection; + } catch (SQLException ex) { + logger.log(Level.SEVERE,"SQLite exception on initialize", ex); + } catch (ClassNotFoundException ex) { + logger.log(Level.SEVERE, "SQLite JDBC library not found", ex); + } + return null; + } + + public void load() { + connection = getSQLConnection(); + } + + public boolean tableExists(String tableName) { + try { + Statement s = connection.createStatement(); + s.executeQuery("SELECT * FROM " + tableName + ";"); + s.close(); + return true; + } catch (SQLException e) { + return false; + } + } + + public boolean columnExists(String tableName, String columnName) { + try { + Statement s = connection.createStatement(); + s.executeQuery("SELECT " + columnName + " FROM " + tableName + ";"); + s.close(); + return true; + } catch (SQLException e) { + return false; + } + } + + public boolean addColumn(String tableName, String columnName, String type) { + if (columnExists(tableName, columnName)) return false; + try { + Statement s = connection.createStatement(); + s.executeQuery("ALTER TABLE " + tableName + " ADD COLUMN " + columnName + " " + type + ";"); + s.close(); + } catch (SQLException e) { + return false; + } + return true; + } + + public ResultSet executeQuery(String query) { + try { + Statement s = connection.createStatement(); + ResultSet rs = s.executeQuery(query); + s.close(); + return rs; + } catch (SQLException e) { + return null; + } + } + + public int executeUpdate(String query) { + try { + Statement s = connection.createStatement(); + int rowCount = s.executeUpdate(query); + s.close(); + return rowCount; + } catch (SQLException e) { + e.printStackTrace(); + return -1; + } + } +} diff --git a/plugin/src/main/java/lol/pyr/znpcsplus/npc/NpcRegistryImpl.java b/plugin/src/main/java/lol/pyr/znpcsplus/npc/NpcRegistryImpl.java index e0f34ce..04083e0 100644 --- a/plugin/src/main/java/lol/pyr/znpcsplus/npc/NpcRegistryImpl.java +++ b/plugin/src/main/java/lol/pyr/znpcsplus/npc/NpcRegistryImpl.java @@ -10,15 +10,17 @@ import lol.pyr.znpcsplus.interaction.ActionRegistry; import lol.pyr.znpcsplus.packets.PacketFactory; import lol.pyr.znpcsplus.scheduling.TaskScheduler; import lol.pyr.znpcsplus.storage.NpcStorage; +import lol.pyr.znpcsplus.storage.NpcStorageType; import lol.pyr.znpcsplus.util.NpcLocation; import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; +import org.bukkit.Bukkit; import org.bukkit.World; import java.util.*; import java.util.stream.Collectors; public class NpcRegistryImpl implements NpcRegistry { - private final NpcStorage storage; + private NpcStorage storage; private final PacketFactory packetFactory; private final ConfigManager configManager; private final LegacyComponentSerializer textSerializer; @@ -32,6 +34,10 @@ public class NpcRegistryImpl implements NpcRegistry { this.textSerializer = textSerializer; this.propertyRegistry = propertyRegistry; storage = configManager.getConfig().storageType().create(configManager, plugin, packetFactory, actionRegistry, typeRegistry, propertyRegistry, textSerializer); + if (storage == null) { + Bukkit.getLogger().warning("Failed to initialize storage, falling back to YAML"); + storage = NpcStorageType.YAML.create(configManager, plugin, packetFactory, actionRegistry, typeRegistry, propertyRegistry, textSerializer); + } this.packetFactory = packetFactory; this.configManager = configManager; diff --git a/plugin/src/main/java/lol/pyr/znpcsplus/storage/NpcStorageType.java b/plugin/src/main/java/lol/pyr/znpcsplus/storage/NpcStorageType.java index 91ff9b7..341767d 100644 --- a/plugin/src/main/java/lol/pyr/znpcsplus/storage/NpcStorageType.java +++ b/plugin/src/main/java/lol/pyr/znpcsplus/storage/NpcStorageType.java @@ -6,6 +6,7 @@ import lol.pyr.znpcsplus.entity.EntityPropertyRegistryImpl; import lol.pyr.znpcsplus.interaction.ActionRegistry; import lol.pyr.znpcsplus.npc.NpcTypeRegistryImpl; import lol.pyr.znpcsplus.packets.PacketFactory; +import lol.pyr.znpcsplus.storage.sqlite.SQLiteStorage; import lol.pyr.znpcsplus.storage.yaml.YamlStorage; import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; @@ -17,6 +18,17 @@ public enum NpcStorageType { public NpcStorage create(ConfigManager configManager, ZNpcsPlus plugin, PacketFactory packetFactory, ActionRegistry actionRegistry, NpcTypeRegistryImpl typeRegistry, EntityPropertyRegistryImpl propertyRegistry, LegacyComponentSerializer textSerializer) { return new YamlStorage(packetFactory, configManager, actionRegistry, typeRegistry, propertyRegistry, textSerializer, new File(plugin.getDataFolder(), "data")); } + }, + SQLITE { + @Override + public NpcStorage create(ConfigManager configManager, ZNpcsPlus plugin, PacketFactory packetFactory, ActionRegistry actionRegistry, NpcTypeRegistryImpl typeRegistry, EntityPropertyRegistryImpl propertyRegistry, LegacyComponentSerializer textSerializer) { + try { + return new SQLiteStorage(packetFactory, configManager, actionRegistry, typeRegistry, propertyRegistry, textSerializer, new File(plugin.getDataFolder(), "znpcsplus.sqlite")); + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } }; public abstract NpcStorage create(ConfigManager configManager, ZNpcsPlus plugin, PacketFactory packetFactory, ActionRegistry actionRegistry, NpcTypeRegistryImpl typeRegistry, EntityPropertyRegistryImpl propertyRegistry, LegacyComponentSerializer textSerializer); diff --git a/plugin/src/main/java/lol/pyr/znpcsplus/storage/sqlite/SQLiteStorage.java b/plugin/src/main/java/lol/pyr/znpcsplus/storage/sqlite/SQLiteStorage.java new file mode 100644 index 0000000..3e193a9 --- /dev/null +++ b/plugin/src/main/java/lol/pyr/znpcsplus/storage/sqlite/SQLiteStorage.java @@ -0,0 +1,317 @@ +package lol.pyr.znpcsplus.storage.sqlite; + +import lol.pyr.znpcsplus.api.entity.EntityProperty; +import lol.pyr.znpcsplus.config.ConfigManager; +import lol.pyr.znpcsplus.database.SQLite; +import lol.pyr.znpcsplus.entity.EntityPropertyImpl; +import lol.pyr.znpcsplus.entity.EntityPropertyRegistryImpl; +import lol.pyr.znpcsplus.entity.PropertySerializer; +import lol.pyr.znpcsplus.hologram.HologramImpl; +import lol.pyr.znpcsplus.interaction.ActionRegistry; +import lol.pyr.znpcsplus.npc.NpcEntryImpl; +import lol.pyr.znpcsplus.npc.NpcImpl; +import lol.pyr.znpcsplus.npc.NpcTypeRegistryImpl; +import lol.pyr.znpcsplus.packets.PacketFactory; +import lol.pyr.znpcsplus.storage.NpcStorage; +import lol.pyr.znpcsplus.util.NpcLocation; +import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer; + +import java.io.File; +import java.math.BigDecimal; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.*; +import java.util.logging.Level; +import java.util.logging.Logger; +import java.util.stream.Collectors; + +public class SQLiteStorage implements NpcStorage { + private final static Logger logger = Logger.getLogger("SQLiteStorage"); + + private final PacketFactory packetFactory; + private final ConfigManager configManager; + private final ActionRegistry actionRegistry; + private final NpcTypeRegistryImpl typeRegistry; + private final EntityPropertyRegistryImpl propertyRegistry; + private final LegacyComponentSerializer textSerializer; + private final SQLite database; + + private final String TABLE_NPCS; + private final String TABLE_NPCS_PROPERTIES; + private final String TABLE_NPCS_HOLOGRAMS; + private final String TABLE_NPCS_ACTIONS; + + public SQLiteStorage(PacketFactory packetFactory, ConfigManager configManager, ActionRegistry actionRegistry, NpcTypeRegistryImpl typeRegistry, EntityPropertyRegistryImpl propertyRegistry, LegacyComponentSerializer textSerializer, File file) { + this.packetFactory = packetFactory; + this.configManager = configManager; + this.actionRegistry = actionRegistry; + this.typeRegistry = typeRegistry; + this.propertyRegistry = propertyRegistry; + this.textSerializer = textSerializer; + this.database = new SQLite(file, logger); + database.load(); + if (database.getSQLConnection() == null) { + throw new RuntimeException("Failed to initialize SQLite Storage."); + } + TABLE_NPCS = "npcs"; + TABLE_NPCS_PROPERTIES = "npcs_properties"; + TABLE_NPCS_HOLOGRAMS = "npcs_holograms"; + TABLE_NPCS_ACTIONS = "npcs_actions"; + validateTables(); + } + + private void validateTables() { + if (!database.tableExists(TABLE_NPCS)) { + logger.log(java.util.logging.Level.INFO, "Creating table " + TABLE_NPCS + "..."); + createNpcsTable(); + } + if (!database.tableExists(TABLE_NPCS_PROPERTIES)) { + logger.log(java.util.logging.Level.INFO, "Creating table " + TABLE_NPCS_PROPERTIES + "..."); + createNpcsPropertiesTable(); + } + if (!database.tableExists(TABLE_NPCS_HOLOGRAMS)) { + logger.log(java.util.logging.Level.INFO, "Creating table " + TABLE_NPCS_HOLOGRAMS + "..."); + createNpcsHologramsTable(); + } + if (!database.tableExists(TABLE_NPCS_ACTIONS)) { + logger.log(java.util.logging.Level.INFO, "Creating table " + TABLE_NPCS_ACTIONS + "..."); + createNpcsActionsTable(); + } + updateTables(); + } + + private void createNpcsTable() { + if (database.executeUpdate("CREATE TABLE " + TABLE_NPCS + " " + + "(id TEXT PRIMARY KEY, isProcessed BOOLEAN, allowCommands BOOLEAN, enabled BOOLEAN, " + + "uuid TEXT, world TEXT, x REAL, y REAL, z REAL, yaw REAL, pitch REAL, type TEXT, hologramOffset REAL, hologramRefreshDelay INTEGER)") != -1) { + logger.log(java.util.logging.Level.INFO, "Table " + TABLE_NPCS + " created."); + } else { + logger.log(java.util.logging.Level.SEVERE, "Failed to create table " + TABLE_NPCS + "."); + } + } + + private void createNpcsPropertiesTable() { + if (database.executeUpdate("CREATE TABLE " + TABLE_NPCS_PROPERTIES + " " + + "(npc_id TEXT, property TEXT, value TEXT, PRIMARY KEY (npc_id, property))") != -1) { + logger.log(java.util.logging.Level.INFO, "Table " + TABLE_NPCS_PROPERTIES + " created."); + } else { + logger.log(java.util.logging.Level.SEVERE, "Failed to create table " + TABLE_NPCS_PROPERTIES + "."); + } + } + + private void createNpcsHologramsTable() { + if (database.executeUpdate("CREATE TABLE " + TABLE_NPCS_HOLOGRAMS + " " + + "(npc_id TEXT, line INTEGER, text TEXT, PRIMARY KEY (npc_id, line))") != -1) { + logger.log(java.util.logging.Level.INFO, "Table " + TABLE_NPCS_HOLOGRAMS + " created."); + } else { + logger.log(java.util.logging.Level.SEVERE, "Failed to create table " + TABLE_NPCS_HOLOGRAMS + "."); + } + } + + private void createNpcsActionsTable() { + if (database.executeUpdate("CREATE TABLE " + TABLE_NPCS_ACTIONS + " " + + "(npc_id TEXT, action_id INTEGER, action_data TEXT, PRIMARY KEY (npc_id, action_id))") != -1) { + logger.log(java.util.logging.Level.INFO, "Table " + TABLE_NPCS_ACTIONS + " created."); + } else { + logger.log(java.util.logging.Level.SEVERE, "Failed to create table " + TABLE_NPCS_ACTIONS + "."); + } + } + + private void updateTables() { + // Any table updates go here + } + + @Override + public Collection loadNpcs() { + Map npcMap = new HashMap<>(); + try { + PreparedStatement st = database.getSQLConnection().prepareStatement("SELECT * FROM " + TABLE_NPCS); + ResultSet rs = st.executeQuery(); + while (rs.next()) { + NpcImpl npc = new NpcImpl(UUID.fromString(rs.getString("uuid")), propertyRegistry, configManager, packetFactory, textSerializer, + rs.getString("world"), typeRegistry.getByName(rs.getString("type")), + new NpcLocation(rs.getDouble("x"), rs.getDouble("y"), rs.getDouble("z"), rs.getFloat("yaw"), rs.getFloat("pitch"))); + + if (!rs.getBoolean("enabled")) npc.setEnabled(false); + + npc.getHologram().setOffset(rs.getDouble("hologramOffset")); + if (rs.getBigDecimal("hologramRefreshDelay") != null) npc.getHologram().setRefreshDelay(rs.getBigDecimal("hologramRefreshDelay").longValue()); + + NpcEntryImpl entry = new NpcEntryImpl(rs.getString("id"), npc); + entry.setProcessed(rs.getBoolean("isProcessed")); + entry.setAllowCommandModification(rs.getBoolean("allowCommands")); + entry.setSave(true); + npcMap.put(rs.getString("id"), entry); + } + } catch (SQLException e) { + e.printStackTrace(); + } + + try { + PreparedStatement st = database.getSQLConnection().prepareStatement("SELECT * FROM " + TABLE_NPCS_PROPERTIES); + ResultSet rs = st.executeQuery(); + while (rs.next()) { + NpcEntryImpl entry = npcMap.get(rs.getString("npc_id")); + String key = rs.getString("property"); + if (entry != null) { + EntityPropertyImpl property = propertyRegistry.getByName(key); + if (property == null) { + logger.log(Level.WARNING, "Unknown property '" + key + "' for npc '" + rs.getString("npc_id") + "'. skipping ..."); + continue; + } + PropertySerializer serializer = propertyRegistry.getSerializer(property.getType()); + if (serializer == null) { + logger.log(Level.WARNING, "Unknown serializer for property '" + key + "' for npc '" + rs.getString("npc_id") + "'. skipping ..."); + continue; + } + Object value = serializer.deserialize(rs.getString("value")); + if (value == null) { + logger.log(Level.WARNING, "Failed to deserialize property '" + key + "' for npc '" + rs.getString("npc_id") + "'. Resetting to default ..."); + value = property.getDefaultValue(); + } + entry.getNpc().UNSAFE_setProperty(property, value); + npcMap.put(rs.getString("npc_id"), entry); + } + } + } catch (SQLException e) { + e.printStackTrace(); + } + + try { + PreparedStatement st = database.getSQLConnection().prepareStatement("SELECT * FROM " + TABLE_NPCS_HOLOGRAMS + " ORDER BY line ASC"); + ResultSet rs = st.executeQuery(); + + while (rs.next()) { + NpcEntryImpl entry = npcMap.get(rs.getString("npc_id")); + if (entry != null) { + entry.getNpc().getHologram().insertLine(rs.getInt("line"), rs.getString("text")); + } + npcMap.put(rs.getString("npc_id"), entry); + } + } catch (SQLException e) { + throw new RuntimeException(e); + } + + try { + PreparedStatement st = database.getSQLConnection().prepareStatement("SELECT * FROM " + TABLE_NPCS_ACTIONS + " ORDER BY action_id ASC"); + ResultSet rs = st.executeQuery(); + + while (rs.next()) { + NpcEntryImpl entry = npcMap.get(rs.getString("npc_id")); + if (entry != null) { + entry.getNpc().addAction(actionRegistry.deserialize(rs.getString("action_data"))); + } + npcMap.put(rs.getString("npc_id"), entry); + } + } catch (SQLException e) { + throw new RuntimeException(e); + } + return npcMap.values().stream().filter(Objects::nonNull).collect(Collectors.toList()); + } + + @Override + public void saveNpcs(Collection npcs) { + long start = System.currentTimeMillis(); + for (NpcEntryImpl entry : npcs) try { + PreparedStatement ps; + ps = database.getSQLConnection().prepareStatement("REPLACE INTO " + TABLE_NPCS + " (id, isProcessed, allowCommands, enabled, uuid, world, x, y, z, yaw, pitch, type, hologramOffset, hologramRefreshDelay) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)"); + ps.setString(1, entry.getId()); + ps.setBoolean(2, entry.isProcessed()); + ps.setBoolean(3, entry.isAllowCommandModification()); + NpcImpl npc = entry.getNpc(); + ps.setBoolean(4, npc.isEnabled()); + ps.setString(5, npc.getUuid().toString()); + ps.setString(6, npc.getWorldName()); + ps.setDouble(7, npc.getLocation().getX()); + ps.setDouble(8, npc.getLocation().getY()); + ps.setDouble(9, npc.getLocation().getZ()); + ps.setFloat(10, npc.getLocation().getYaw()); + ps.setFloat(11, npc.getLocation().getPitch()); + ps.setString(12, npc.getType().getName()); + HologramImpl hologram = npc.getHologram(); + ps.setDouble(13, hologram.getOffset()); + if(hologram.getRefreshDelay() != -1) ps.setBigDecimal(14, new BigDecimal(hologram.getRefreshDelay())); + ps.executeUpdate(); + + ps = database.getSQLConnection().prepareStatement("DELETE FROM " + TABLE_NPCS_PROPERTIES + " WHERE npc_id = ?"); + ps.setString(1, entry.getId()); + ps.executeUpdate(); + + for (EntityProperty property : npc.getAllProperties()) try { + PropertySerializer serializer = propertyRegistry.getSerializer(((EntityPropertyImpl) property).getType()); + if (serializer == null) { + logger.log(Level.WARNING, "Unknown serializer for property '" + property.getName() + "' for npc '" + entry.getId() + "'. skipping ..."); + continue; + } + ps = database.getSQLConnection().prepareStatement("REPLACE INTO " + TABLE_NPCS_PROPERTIES + " (npc_id, property, value) VALUES(?,?,?)"); + ps.setString(1, entry.getId()); + ps.setString(2, property.getName()); + ps.setString(3, serializer.UNSAFE_serialize(npc.getProperty(property))); + ps.executeUpdate(); + } catch (Exception exception) { + logger.severe("Failed to serialize property " + property.getName() + " for npc with id " + entry.getId()); + exception.printStackTrace(); + } + + ps = database.getSQLConnection().prepareStatement("DELETE FROM " + TABLE_NPCS_HOLOGRAMS + " WHERE npc_id = ? AND line > ?"); + ps.setString(1, entry.getId()); + ps.setInt(2, hologram.getLines().size() - 1); + ps.executeUpdate(); + + for (int i = 0; i < hologram.getLines().size(); i++) { + ps = database.getSQLConnection().prepareStatement("REPLACE INTO " + TABLE_NPCS_HOLOGRAMS + " (npc_id, line, text) VALUES(?,?,?)"); + ps.setString(1, entry.getId()); + ps.setInt(2, i); + ps.setString(3, hologram.getLine(i)); + ps.executeUpdate(); + } + + ps = database.getSQLConnection().prepareStatement("DELETE FROM " + TABLE_NPCS_ACTIONS + " WHERE npc_id = ? AND action_id > ?"); + ps.setString(1, entry.getId()); + ps.setInt(2, npc.getActions().size() - 1); + ps.executeUpdate(); + + for (int i = 0; i < npc.getActions().size(); i++) { + ps = database.getSQLConnection().prepareStatement("REPLACE INTO " + TABLE_NPCS_ACTIONS + " (npc_id, action_id, action_data) VALUES(?,?,?)"); + ps.setString(1, entry.getId()); + ps.setInt(2, i); + String action = actionRegistry.serialize(npc.getActions().get(i)); + if (action == null) continue; + ps.setString(3, action); + ps.executeUpdate(); + } + } catch (SQLException exception) { + logger.severe("Failed to save npc with id " + entry.getId()); + exception.printStackTrace(); + } + if (configManager.getConfig().debugEnabled()) { + logger.info("Saved " + npcs.size() + " npcs in " + (System.currentTimeMillis() - start) + "ms"); + } + } + + @Override + public void deleteNpc(NpcEntryImpl entry) { + try { + PreparedStatement ps; + ps = database.getSQLConnection().prepareStatement("DELETE FROM " + TABLE_NPCS + " WHERE id = ?"); + ps.setString(1, entry.getId()); + ps.executeUpdate(); + + ps = database.getSQLConnection().prepareStatement("DELETE FROM " + TABLE_NPCS_PROPERTIES + " WHERE npc_id = ?"); + ps.setString(1, entry.getId()); + ps.executeUpdate(); + + ps = database.getSQLConnection().prepareStatement("DELETE FROM " + TABLE_NPCS_HOLOGRAMS + " WHERE npc_id = ?"); + ps.setString(1, entry.getId()); + ps.executeUpdate(); + + ps = database.getSQLConnection().prepareStatement("DELETE FROM " + TABLE_NPCS_ACTIONS + " WHERE npc_id = ?"); + ps.setString(1, entry.getId()); + ps.executeUpdate(); + } catch (SQLException exception) { + logger.severe("Failed to delete npc with id " + entry.getId()); + exception.printStackTrace(); + } + } +}