private String getRenameTableSQL(String from, String to) { switch (dbType) { case SQLITE: return "ALTER TABLE " + from + " RENAME TO " + to; case MYSQL: return "RENAME TABLE " + from + " TO " + to; case H2: return "ALTER TABLE " + from + " RENAME TO " + to; default: throw new IllegalArgumentException("DBType: " + dbType.getName() + " does not have rename table sql"); } }
public Database getActiveDatabaseByName(String dbName) { for (Database database : getDatabases()) { String dbConfigName = database.getType().getConfigName(); if (Verify.equalsIgnoreCase(dbName, dbConfigName)) { return database; } } throw new IllegalArgumentException(locale.getString(PluginLang.ENABLE_FAIL_WRONG_DB, dbName)); }
/** * Constructor. * * @param name Name of the table in the db. * @param db Database to use. */ public Table(String name, SQLDB db) { this.tableName = name; this.db = db; this.supportsMySQLQueries = db != null && db.getType().supportsMySQLQueries(); }
/** * Checks if the name of a {@code DBType} corresponds to {@code name}.<p> * This method is case-insensitive. * * @param name the name of the {@code DBType} * @return if the {@code DBType} exists * @see DBType#getForName(String) */ public static boolean exists(String name) { for (DBType dbType : DBType.values()) { if (dbType.getName().equalsIgnoreCase(name)) { return true; } } return false; } }
@Override public void onCommand(Sender sender, String commandLabel, String[] args) { Verify.isTrue(args.length >= 2, () -> new IllegalArgumentException(locale.getString(CommandLang.FAIL_REQ_ARGS, 2, Arrays.toString(this.getArguments())))); String backupDbName = args[0]; String dbName = args[1].toLowerCase(); boolean isCorrectDB = DBType.exists(dbName); Verify.isTrue(isCorrectDB, () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_INCORRECT_DB, dbName))); try { Database database = dbSystem.getActiveDatabaseByName(dbName); Verify.isFalse(backupDbName.contains("database") && database instanceof SQLiteDB, () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_SAME_DB))); database.init(); if (!Verify.contains("-a", args)) { sender.sendMessage(locale.getString(ManageLang.CONFIRMATION, locale.getString(ManageLang.CONFIRM_OVERWRITE, database.getType().getName()))); return; } runRestoreTask(backupDbName, sender, database); } catch (Exception e) { sender.sendMessage(locale.getString(ManageLang.PROGRESS_FAIL, e.getMessage())); } }
boolean isCorrectDB = DBType.exists(dbName); Verify.isTrue(isCorrectDB, () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_INCORRECT_DB, dbName))); Verify.isFalse(dbName.equals(dbSystem.getDatabase().getType().getConfigName()), () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_SAME_DB)));
@Override public void onCommand(Sender sender, String commandLabel, String[] args) { try { Verify.isTrue(args.length >= 1, () -> new IllegalArgumentException(locale.getString(CommandLang.FAIL_REQ_ONE_ARG, Arrays.toString(this.getArguments())))); String dbName = args[0].toLowerCase(); boolean isCorrectDB = DBType.exists(dbName); Verify.isTrue(isCorrectDB, () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_INCORRECT_DB, dbName))); Database database = dbSystem.getActiveDatabaseByName(dbName); database.init(); runBackupTask(sender, args, database); } catch (DBInitException e) { sender.sendMessage(locale.getString(ManageLang.PROGRESS_FAIL, e.getMessage())); } }
/** * Gets an {@code Optional<DBType>} which matches {@code name}.<p> * This method is case-insensitive.<p> * The {@code Optional<DBType>} is empty when no {@code DBType} is found. * * @param name the name of the {@code DBType} * @return an {@code Optional<DBType>} */ public static Optional<DBType> getForName(String name) { for (DBType dbType : DBType.values()) { if (dbType.getName().equalsIgnoreCase(name)) { return Optional.of(dbType); } } return Optional.empty(); }
@Override public void onCommand(Sender sender, String commandLabel, String[] args) { Verify.isTrue(args.length >= 2, () -> new IllegalArgumentException(locale.getString(CommandLang.FAIL_REQ_ARGS, 2, Arrays.toString(this.getArguments())))); String fromDB = args[0].toLowerCase(); boolean isCorrectDB = DBType.exists(fromDB); Verify.isTrue(isCorrectDB, () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_INCORRECT_DB, fromDB))); String toDB = args[1].toLowerCase(); isCorrectDB = DBType.exists(toDB); Verify.isTrue(isCorrectDB, () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_INCORRECT_DB, toDB))); Verify.isFalse(fromDB.equalsIgnoreCase(toDB), () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_SAME_DB))); if (!Verify.contains("-a", args)) { sender.sendMessage(locale.getString(ManageLang.CONFIRMATION, locale.getString(ManageLang.CONFIRM_OVERWRITE, toDB))); return; } try { final Database fromDatabase = dbSystem.getActiveDatabaseByName(fromDB); final Database toDatabase = dbSystem.getActiveDatabaseByName(toDB); fromDatabase.init(); toDatabase.init(); runMoveTask(fromDatabase, toDatabase, sender); } catch (Exception e) { sender.sendMessage(locale.getString(ManageLang.PROGRESS_FAIL, e.getMessage())); } }
@Override public int hashCode() { return Objects.hash(getType().getName()); }
@Test public void testH2GetConfigName() { assertEquals("h2", db.getType().getConfigName()); }
protected void addColumn(String tableName, String columnInfo) { db.execute("ALTER TABLE " + tableName + " ADD " + (dbType.supportsMySQLQueries() ? "" : "COLUMN ") + columnInfo); }
@Override public void onCommand(Sender sender, String commandLabel, String[] args) { Verify.isTrue(args.length >= 1, () -> new IllegalArgumentException(locale.getString(CommandLang.FAIL_REQ_ONE_ARG, Arrays.toString(this.getArguments())))); String dbName = args[0].toLowerCase(); boolean isCorrectDB = DBType.exists(dbName); Verify.isTrue(isCorrectDB, () -> new IllegalArgumentException(locale.getString(ManageLang.FAIL_INCORRECT_DB, dbName))); if (!Verify.contains("-a", args)) { sender.sendMessage(locale.getString(ManageLang.CONFIRMATION, locale.getString(ManageLang.CONFIRM_REMOVAL, dbName))); return; } try { Database database = dbSystem.getActiveDatabaseByName(dbName); database.init(); runClearTask(sender, database); } catch (DBInitException e) { sender.sendMessage(locale.getString(ManageLang.PROGRESS_FAIL, e.getMessage())); } }
private void appendServerInformation(StringBuilder content) { ServerProperties serverProperties = serverInfo.getServerProperties(); content.append("<pre>### Server Information<br>") .append("**Plan Version:** ${version}<br>"); content.append("**Server:** "); content.append(serverProperties.getName()) .append(" ").append(serverProperties.getImplVersion()) .append(" (").append(serverProperties.getVersion()); content.append(")<br>"); content.append("**Database:** ").append(database.getType().getName()); content.append("<br><br>"); Properties properties = System.getProperties(); String osName = properties.getProperty("os.name"); String osVersion = properties.getProperty("os.version"); String osArch = properties.getProperty("os.arch"); String javaVendor = properties.getProperty("java.vendor"); String javaVersion = properties.getProperty("java.version"); String javaVMVendor = properties.getProperty("java.vm.vendor"); String javaVMName = properties.getProperty("java.vm.name"); String javaVMVersion = properties.getProperty("java.vm.version"); content.append("**Operating SubSystem:** ").append(osName).append(" (").append(osArch) .append(") version ").append(osVersion).append("<br>"); content.append("**Java Version:** ").append(javaVersion).append(", ").append(javaVendor).append("<br>"); content.append("**Java VM Version:** ").append(javaVMName).append(" version ").append(javaVMVersion) .append(", ").append(javaVMVendor).append("<br>"); content.append("</pre>"); }
@Test public void testSQLiteGetConfigName() { assertEquals("sqlite", db.getType().getConfigName()); }
protected boolean hasTable(String tableName) { boolean secondParameter; String sql; if (dbType == DBType.H2) { sql = "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME=?"; secondParameter = false; } else if (dbType.supportsMySQLQueries()) { sql = "SELECT * FROM information_schema.TABLES WHERE table_name=? AND TABLE_SCHEMA=? LIMIT 1"; secondParameter = true; } else { sql = "SELECT tbl_name FROM sqlite_master WHERE tbl_name=?"; secondParameter = false; } return query(new QueryStatement<Boolean>(sql) { @Override public void prepare(PreparedStatement statement) throws SQLException { statement.setString(1, tableName); if (secondParameter) { statement.setString(2, db.getConfig().get(DatabaseSettings.MYSQL_DATABASE)); } } @Override public Boolean processResults(ResultSet set) throws SQLException { return set.next(); } }); }
private void registerConfigSettingGraphs() { String serverType = "Sponge"; String databaseType = database.getType().getName(); addStringSettingPie("server_type", serverType); addStringSettingPie("database_type", databaseType); }
private void runMoveTask(final Database fromDatabase, final Database toDatabase, Sender sender) { processing.submitCritical(() -> { try { sender.sendMessage(locale.getString(ManageLang.PROGRESS_START)); fromDatabase.backup().backup(toDatabase); sender.sendMessage(locale.getString(ManageLang.PROGRESS_SUCCESS)); boolean movingToCurrentDB = toDatabase.getType() == dbSystem.getDatabase().getType(); if (movingToCurrentDB) { sender.sendMessage(locale.getString(ManageLang.HOTSWAP_REMINDER, toDatabase.getType().getConfigName())); } } catch (Exception e) { errorHandler.log(L.ERROR, this.getClass(), e); sender.sendMessage(locale.getString(ManageLang.PROGRESS_FAIL, e.getMessage())); } }); } }
protected boolean hasColumn(String tableName, String columnName) { if (dbType.supportsMySQLQueries()) { String query;
@Override public void enable() throws EnableException { try { db.init(); db.scheduleClean(20L); logger.info(locale.getString(PluginLang.ENABLED_DATABASE, db.getType().getName())); } catch (DBInitException e) { Throwable cause = e.getCause(); String message = cause == null ? e.getMessage() : cause.getMessage(); throw new EnableException(db.getType().getName() + " init failure: " + message, cause); } }