2019-02-16 12:59:36 +01:00
|
|
|
/*
|
|
|
|
* This file is part of Player Analytics (Plan).
|
|
|
|
*
|
|
|
|
* Plan is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Lesser General Public License v3 as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Plan is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
|
|
* along with Plan. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*/
|
2019-08-30 22:14:54 +02:00
|
|
|
package com.djrapitops.plan.storage.database.queries.objects;
|
2019-02-16 12:59:36 +01:00
|
|
|
|
2019-08-30 22:14:54 +02:00
|
|
|
import com.djrapitops.plan.delivery.domain.DateObj;
|
|
|
|
import com.djrapitops.plan.gathering.domain.TPS;
|
|
|
|
import com.djrapitops.plan.gathering.domain.builders.TPSBuilder;
|
|
|
|
import com.djrapitops.plan.storage.database.queries.Query;
|
|
|
|
import com.djrapitops.plan.storage.database.queries.QueryStatement;
|
|
|
|
import com.djrapitops.plan.storage.database.sql.tables.ServerTable;
|
2019-12-18 23:09:29 +01:00
|
|
|
import com.djrapitops.plan.utilities.java.Lists;
|
2019-02-16 12:59:36 +01:00
|
|
|
|
|
|
|
import java.sql.PreparedStatement;
|
|
|
|
import java.sql.ResultSet;
|
|
|
|
import java.sql.SQLException;
|
2019-02-16 13:09:01 +01:00
|
|
|
import java.util.*;
|
2021-01-24 16:40:30 +01:00
|
|
|
import java.util.concurrent.TimeUnit;
|
2019-02-16 12:59:36 +01:00
|
|
|
|
2019-12-05 19:22:33 +01:00
|
|
|
import static com.djrapitops.plan.storage.database.sql.building.Sql.*;
|
2019-08-30 22:14:54 +02:00
|
|
|
import static com.djrapitops.plan.storage.database.sql.tables.TPSTable.*;
|
2019-02-16 12:59:36 +01:00
|
|
|
|
|
|
|
/**
|
2019-08-30 22:14:54 +02:00
|
|
|
* Queries for {@link com.djrapitops.plan.gathering.domain.TPS} objects.
|
2019-02-16 12:59:36 +01:00
|
|
|
*
|
|
|
|
* @author Rsl1122
|
|
|
|
*/
|
|
|
|
public class TPSQueries {
|
|
|
|
|
|
|
|
private TPSQueries() {
|
|
|
|
/* Static method class */
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<List<TPS>> fetchTPSDataOfServer(UUID serverUUID) {
|
2021-01-24 16:40:30 +01:00
|
|
|
return db -> {
|
|
|
|
String selectLowestResolution = SELECT +
|
2021-01-30 18:17:59 +01:00
|
|
|
min("t." + DATE) + " as " + DATE + ',' +
|
|
|
|
min("t." + TPS) + " as " + TPS + ',' +
|
|
|
|
max("t." + PLAYERS_ONLINE) + " as " + PLAYERS_ONLINE + ',' +
|
|
|
|
max("t." + RAM_USAGE) + " as " + RAM_USAGE + ',' +
|
|
|
|
max("t." + CPU_USAGE) + " as " + CPU_USAGE + ',' +
|
|
|
|
max("t." + ENTITIES) + " as " + ENTITIES + ',' +
|
|
|
|
max("t." + CHUNKS) + " as " + CHUNKS + ',' +
|
|
|
|
max("t." + FREE_DISK) + " as " + FREE_DISK +
|
2021-01-24 16:40:30 +01:00
|
|
|
FROM + TABLE_NAME + " t" +
|
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
|
|
|
AND + DATE + "<?" +
|
2021-01-30 18:17:59 +01:00
|
|
|
GROUP_BY + floor(DATE + "/?");
|
2021-01-24 16:40:30 +01:00
|
|
|
String selectLowerResolution = SELECT +
|
2021-01-30 18:17:59 +01:00
|
|
|
min("t." + DATE) + " as " + DATE + ',' +
|
|
|
|
min("t." + TPS) + " as " + TPS + ',' +
|
|
|
|
max("t." + PLAYERS_ONLINE) + " as " + PLAYERS_ONLINE + ',' +
|
|
|
|
max("t." + RAM_USAGE) + " as " + RAM_USAGE + ',' +
|
|
|
|
max("t." + CPU_USAGE) + " as " + CPU_USAGE + ',' +
|
|
|
|
max("t." + ENTITIES) + " as " + ENTITIES + ',' +
|
|
|
|
max("t." + CHUNKS) + " as " + CHUNKS + ',' +
|
|
|
|
max("t." + FREE_DISK) + " as " + FREE_DISK +
|
2021-01-24 16:40:30 +01:00
|
|
|
FROM + TABLE_NAME + " t" +
|
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
|
|
|
AND + DATE + ">=?" +
|
|
|
|
AND + DATE + "<?" +
|
2021-01-30 18:17:59 +01:00
|
|
|
GROUP_BY + floor(DATE + "/?");
|
2021-01-24 16:40:30 +01:00
|
|
|
String selectNormalResolution = SELECT +
|
|
|
|
DATE + ',' + TPS + ',' + PLAYERS_ONLINE + ',' +
|
|
|
|
RAM_USAGE + ',' + CPU_USAGE + ',' + ENTITIES + ',' + CHUNKS + ',' + FREE_DISK +
|
|
|
|
FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
|
|
|
AND + DATE + ">=?";
|
2019-02-16 12:59:36 +01:00
|
|
|
|
2021-01-24 16:40:30 +01:00
|
|
|
String sql = selectLowestResolution +
|
|
|
|
UNION + selectLowerResolution +
|
|
|
|
UNION + selectNormalResolution +
|
|
|
|
ORDER_BY + DATE;
|
2019-02-16 12:59:36 +01:00
|
|
|
|
2021-01-24 16:40:30 +01:00
|
|
|
return db.query(new QueryStatement<List<TPS>>(sql, 50000) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
long now = System.currentTimeMillis();
|
|
|
|
long lowestResolution = TimeUnit.MINUTES.toMillis(20);
|
|
|
|
long lowResolution = TimeUnit.MINUTES.toMillis(5);
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, now - TimeUnit.DAYS.toMillis(60));
|
|
|
|
statement.setLong(3, lowestResolution);
|
|
|
|
statement.setString(4, serverUUID.toString());
|
|
|
|
statement.setLong(5, now - TimeUnit.DAYS.toMillis(60));
|
|
|
|
statement.setLong(6, now - TimeUnit.DAYS.toMillis(30));
|
|
|
|
statement.setLong(7, lowResolution);
|
|
|
|
statement.setString(8, serverUUID.toString());
|
|
|
|
statement.setLong(9, now - TimeUnit.DAYS.toMillis(30));
|
|
|
|
}
|
2019-02-16 12:59:36 +01:00
|
|
|
|
2021-01-24 16:40:30 +01:00
|
|
|
@Override
|
|
|
|
public List<TPS> processResults(ResultSet set) throws SQLException {
|
|
|
|
List<TPS> data = new ArrayList<>();
|
|
|
|
while (set.next()) {
|
|
|
|
data.add(extractTPS(set));
|
|
|
|
}
|
|
|
|
return data;
|
2019-02-16 12:59:36 +01:00
|
|
|
}
|
2021-01-24 16:40:30 +01:00
|
|
|
});
|
2019-02-16 12:59:36 +01:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-08-27 15:43:07 +02:00
|
|
|
public static TPS extractTPS(ResultSet set) throws SQLException {
|
|
|
|
return TPSBuilder.get()
|
|
|
|
.date(set.getLong(DATE))
|
|
|
|
.tps(set.getDouble(TPS))
|
|
|
|
.playersOnline(set.getInt(PLAYERS_ONLINE))
|
|
|
|
.usedCPU(set.getDouble(CPU_USAGE))
|
|
|
|
.usedMemory(set.getLong(RAM_USAGE))
|
|
|
|
.entities(set.getInt(ENTITIES))
|
|
|
|
.chunksLoaded(set.getInt(CHUNKS))
|
|
|
|
.freeDiskSpace(set.getLong(FREE_DISK))
|
|
|
|
.toTPS();
|
|
|
|
}
|
|
|
|
|
2019-07-03 11:05:33 +02:00
|
|
|
public static Query<List<TPS>> fetchTPSDataOfServer(long after, long before, UUID serverUUID) {
|
2021-01-25 10:26:30 +01:00
|
|
|
String sql = SELECT + "*" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
|
|
|
AND + DATE + ">=?" +
|
|
|
|
AND + DATE + "<=?" +
|
|
|
|
ORDER_BY + DATE;
|
2019-07-03 11:05:33 +02:00
|
|
|
|
|
|
|
return new QueryStatement<List<TPS>>(sql, 50000) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, after);
|
|
|
|
statement.setLong(3, before);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public List<TPS> processResults(ResultSet set) throws SQLException {
|
|
|
|
List<TPS> data = new ArrayList<>();
|
|
|
|
while (set.next()) {
|
2019-08-27 15:43:07 +02:00
|
|
|
TPS tps = extractTPS(set);
|
2019-07-03 11:05:33 +02:00
|
|
|
data.add(tps);
|
|
|
|
}
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-01-31 09:55:08 +01:00
|
|
|
public static Query<List<DateObj<Integer>>> fetchViewPreviewGraphData(UUID serverUUID) {
|
2021-01-30 18:17:59 +01:00
|
|
|
String sql = SELECT + min(DATE) + " as " + DATE + ',' +
|
|
|
|
max(PLAYERS_ONLINE) + " as " + PLAYERS_ONLINE +
|
2021-01-29 10:58:06 +01:00
|
|
|
FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2021-01-30 18:17:59 +01:00
|
|
|
GROUP_BY + floor(DATE + "/?");
|
2021-01-29 10:58:06 +01:00
|
|
|
|
|
|
|
return new QueryStatement<List<DateObj<Integer>>>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, TimeUnit.MINUTES.toMillis(15));
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public List<DateObj<Integer>> processResults(ResultSet set) throws SQLException {
|
|
|
|
List<DateObj<Integer>> ofServer = new ArrayList<>();
|
|
|
|
while (set.next()) ofServer.add(new DateObj<>(set.getLong(DATE), set.getInt(PLAYERS_ONLINE)));
|
|
|
|
return ofServer;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-08-15 19:27:47 +02:00
|
|
|
public static Query<List<DateObj<Integer>>> fetchPlayersOnlineOfServer(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + ServerTable.SERVER_UUID + ',' + DATE + ',' + PLAYERS_ONLINE +
|
|
|
|
FROM + TABLE_NAME +
|
|
|
|
INNER_JOIN + ServerTable.TABLE_NAME + " on " + ServerTable.TABLE_NAME + '.' + ServerTable.SERVER_ID + '=' + SERVER_ID +
|
|
|
|
WHERE + ServerTable.SERVER_UUID + "=?" +
|
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<List<DateObj<Integer>>>(sql, 1000) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public List<DateObj<Integer>> processResults(ResultSet set) throws SQLException {
|
|
|
|
List<DateObj<Integer>> ofServer = new ArrayList<>();
|
|
|
|
|
|
|
|
while (set.next()) {
|
|
|
|
ofServer.add(new DateObj<>(set.getLong(DATE), set.getInt(PLAYERS_ONLINE)));
|
|
|
|
}
|
|
|
|
|
|
|
|
return ofServer;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-08-27 15:43:07 +02:00
|
|
|
public static Query<Map<UUID, List<TPS>>> fetchTPSDataOfAllServersBut(long after, long before, UUID leaveOut) {
|
|
|
|
String sql = SELECT + '*' +
|
2019-08-15 19:27:47 +02:00
|
|
|
FROM + TABLE_NAME +
|
|
|
|
INNER_JOIN + ServerTable.TABLE_NAME + " on " + ServerTable.TABLE_NAME + '.' + ServerTable.SERVER_ID + '=' + SERVER_ID +
|
|
|
|
WHERE + ServerTable.SERVER_UUID + "!=?" +
|
|
|
|
AND + ServerTable.INSTALLED + "=?" +
|
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
2019-08-27 15:43:07 +02:00
|
|
|
return new QueryStatement<Map<UUID, List<TPS>>>(sql, 1000) {
|
2019-08-15 19:27:47 +02:00
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, leaveOut.toString());
|
|
|
|
statement.setBoolean(2, true);
|
|
|
|
statement.setLong(3, before);
|
|
|
|
statement.setLong(4, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2019-08-27 15:43:07 +02:00
|
|
|
public Map<UUID, List<TPS>> processResults(ResultSet set) throws SQLException {
|
|
|
|
Map<UUID, List<TPS>> byServer = new HashMap<>();
|
2019-08-15 19:27:47 +02:00
|
|
|
while (set.next()) {
|
|
|
|
UUID serverUUID = UUID.fromString(set.getString(ServerTable.SERVER_UUID));
|
2019-12-18 23:09:29 +01:00
|
|
|
List<TPS> ofServer = byServer.computeIfAbsent(serverUUID, Lists::create);
|
2019-08-27 15:43:07 +02:00
|
|
|
ofServer.add(extractTPS(set));
|
2019-08-15 19:27:47 +02:00
|
|
|
}
|
|
|
|
return byServer;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2019-02-16 13:22:25 +01:00
|
|
|
public static Query<Optional<DateObj<Integer>>> fetchPeakPlayerCount(UUID serverUUID, long afterDate) {
|
2019-08-06 21:34:50 +02:00
|
|
|
String subQuery = '(' + SELECT + "MAX(" + PLAYERS_ONLINE + ')' + FROM + TABLE_NAME + WHERE + SERVER_ID + "=" + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2019-02-18 15:48:12 +01:00
|
|
|
AND + DATE + ">= ?)";
|
|
|
|
String sql = SELECT +
|
2019-08-06 21:34:50 +02:00
|
|
|
DATE + ',' + PLAYERS_ONLINE +
|
2019-02-18 15:48:12 +01:00
|
|
|
FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
|
|
|
AND + DATE + ">= ?" +
|
|
|
|
AND + PLAYERS_ONLINE + "=" + subQuery +
|
|
|
|
ORDER_BY + DATE + " DESC LIMIT 1";
|
2019-02-16 13:22:25 +01:00
|
|
|
|
|
|
|
return new QueryStatement<Optional<DateObj<Integer>>>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, afterDate);
|
2019-02-18 15:48:12 +01:00
|
|
|
statement.setString(3, serverUUID.toString());
|
|
|
|
statement.setLong(4, afterDate);
|
2019-02-16 13:22:25 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Optional<DateObj<Integer>> processResults(ResultSet set) throws SQLException {
|
|
|
|
if (set.next()) {
|
|
|
|
return Optional.of(new DateObj<>(
|
|
|
|
set.getLong(DATE),
|
|
|
|
set.getInt(PLAYERS_ONLINE)
|
|
|
|
));
|
|
|
|
}
|
|
|
|
return Optional.empty();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<Optional<DateObj<Integer>>> fetchAllTimePeakPlayerCount(UUID serverUUID) {
|
2019-02-18 15:48:12 +01:00
|
|
|
return fetchPeakPlayerCount(serverUUID, 0);
|
2019-02-16 13:22:25 +01:00
|
|
|
}
|
2019-07-03 11:05:33 +02:00
|
|
|
|
|
|
|
public static Query<Optional<TPS>> fetchLatestTPSEntryForServer(UUID serverUUID) {
|
|
|
|
String sql = SELECT + "*" +
|
|
|
|
FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
|
|
|
ORDER_BY + DATE + " DESC LIMIT 1";
|
|
|
|
|
2019-08-20 20:14:22 +02:00
|
|
|
return new QueryStatement<Optional<TPS>>(sql) {
|
2019-07-03 11:05:33 +02:00
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Optional<TPS> processResults(ResultSet set) throws SQLException {
|
|
|
|
if (set.next()) {
|
|
|
|
return Optional.of(TPSBuilder.get()
|
|
|
|
.date(set.getLong(DATE))
|
|
|
|
.tps(set.getDouble(TPS))
|
|
|
|
.playersOnline(set.getInt(PLAYERS_ONLINE))
|
|
|
|
.usedCPU(set.getDouble(CPU_USAGE))
|
|
|
|
.usedMemory(set.getLong(RAM_USAGE))
|
|
|
|
.entities(set.getInt(ENTITIES))
|
|
|
|
.chunksLoaded(set.getInt(CHUNKS))
|
|
|
|
.freeDiskSpace(set.getLong(FREE_DISK))
|
|
|
|
.toTPS());
|
|
|
|
}
|
|
|
|
return Optional.empty();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2019-09-29 12:00:55 +02:00
|
|
|
|
|
|
|
public static Query<Double> averageTPS(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + "AVG(" + TPS + ") as average" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2020-03-13 09:28:47 +01:00
|
|
|
AND + TPS + ">=0" +
|
2019-09-29 12:00:55 +02:00
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<Double>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Double processResults(ResultSet set) throws SQLException {
|
|
|
|
return set.next() ? set.getDouble("average") : -1.0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<Double> averageCPU(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + "AVG(" + CPU_USAGE + ") as average" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2020-03-13 09:28:47 +01:00
|
|
|
AND + CPU_USAGE + ">=0" +
|
2019-09-29 12:00:55 +02:00
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<Double>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Double processResults(ResultSet set) throws SQLException {
|
|
|
|
return set.next() ? set.getDouble("average") : -1.0;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<Long> averageRAM(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + "AVG(" + RAM_USAGE + ") as average" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2020-03-13 09:28:47 +01:00
|
|
|
AND + RAM_USAGE + ">=0" +
|
2019-09-29 12:00:55 +02:00
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<Long>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Long processResults(ResultSet set) throws SQLException {
|
2019-10-19 11:42:25 +02:00
|
|
|
return set.next() ? (long) set.getDouble("average") : -1L;
|
2019-09-29 12:00:55 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<Long> averageChunks(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + "AVG(" + CHUNKS + ") as average" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2020-03-13 09:28:47 +01:00
|
|
|
AND + CHUNKS + ">=0" +
|
2019-09-29 12:00:55 +02:00
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<Long>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Long processResults(ResultSet set) throws SQLException {
|
2019-10-19 11:42:25 +02:00
|
|
|
return set.next() ? (long) set.getDouble("average") : -1L;
|
2019-09-29 12:00:55 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<Long> averageEntities(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + "AVG(" + ENTITIES + ") as average" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2020-03-13 09:28:47 +01:00
|
|
|
AND + ENTITIES + ">=0" +
|
2019-09-29 12:00:55 +02:00
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<Long>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Long processResults(ResultSet set) throws SQLException {
|
2019-10-19 11:42:25 +02:00
|
|
|
return set.next() ? (long) set.getDouble("average") : -1L;
|
2019-09-29 12:00:55 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<Long> maxFreeDisk(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + "MAX(" + FREE_DISK + ") as free" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2020-03-13 09:28:47 +01:00
|
|
|
AND + FREE_DISK + ">=0" +
|
2019-09-29 12:00:55 +02:00
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<Long>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Long processResults(ResultSet set) throws SQLException {
|
|
|
|
return set.next() ? set.getLong("free") : -1L;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<Long> minFreeDisk(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + "MIN(" + FREE_DISK + ") as free" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2020-03-13 09:28:47 +01:00
|
|
|
AND + FREE_DISK + ">=0" +
|
2019-09-29 12:00:55 +02:00
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<Long>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Long processResults(ResultSet set) throws SQLException {
|
|
|
|
return set.next() ? set.getLong("free") : -1L;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
public static Query<Long> averageFreeDisk(long after, long before, UUID serverUUID) {
|
|
|
|
String sql = SELECT + "AVG(" + FREE_DISK + ") as average" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.STATEMENT_SELECT_SERVER_ID +
|
2020-03-13 09:28:47 +01:00
|
|
|
AND + FREE_DISK + ">=0" +
|
2019-09-29 12:00:55 +02:00
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
|
|
|
return new QueryStatement<Long>(sql) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setLong(2, before);
|
|
|
|
statement.setLong(3, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Long processResults(ResultSet set) throws SQLException {
|
2019-10-19 11:42:25 +02:00
|
|
|
return set.next() ? (long) set.getDouble("average") : -1L;
|
2019-09-29 12:00:55 +02:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2019-02-16 12:59:36 +01:00
|
|
|
}
|