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;
|
2021-03-12 17:03:00 +01:00
|
|
|
import com.djrapitops.plan.identification.ServerUUID;
|
2019-08-30 22:14:54 +02:00
|
|
|
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;
|
2021-03-22 06:13:27 +01:00
|
|
|
import java.sql.Types;
|
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
|
|
|
*
|
2021-02-13 14:16:03 +01:00
|
|
|
* @author AuroraLS3
|
2019-02-16 12:59:36 +01:00
|
|
|
*/
|
|
|
|
public class TPSQueries {
|
|
|
|
|
|
|
|
private TPSQueries() {
|
|
|
|
/* Static method class */
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<List<TPS>> fetchTPSDataOfServerInResolution(long after, long before, long resolution, ServerUUID serverUUID) {
|
2021-01-24 16:40:30 +01:00
|
|
|
return db -> {
|
2021-02-03 18:38:53 +01:00
|
|
|
String sql = 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" +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
|
2021-01-24 16:40:30 +01:00
|
|
|
AND + DATE + ">=?" +
|
|
|
|
AND + DATE + "<?" +
|
2021-02-03 18:38:53 +01:00
|
|
|
GROUP_BY + floor(DATE + "/?") +
|
2021-01-24 16:40:30 +01:00
|
|
|
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 {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
2021-02-03 18:38:53 +01:00
|
|
|
statement.setLong(2, after);
|
|
|
|
statement.setLong(3, before);
|
|
|
|
statement.setLong(4, resolution);
|
2021-01-24 16:40:30 +01:00
|
|
|
}
|
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();
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<List<TPS>> fetchTPSDataOfServer(long after, long before, ServerUUID serverUUID) {
|
2021-01-25 10:26:30 +01:00
|
|
|
String sql = SELECT + "*" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
|
2021-01-25 10:26:30 +01:00
|
|
|
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-03-12 17:03:00 +01:00
|
|
|
public static Query<List<DateObj<Integer>>> fetchViewPreviewGraphData(ServerUUID 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 +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<List<DateObj<Integer>>> fetchPlayersOnlineOfServer(long after, long before, ServerUUID serverUUID) {
|
2019-08-15 19:27:47 +02:00
|
|
|
String sql = SELECT + ServerTable.SERVER_UUID + ',' + DATE + ',' + PLAYERS_ONLINE +
|
|
|
|
FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
INNER_JOIN + ServerTable.TABLE_NAME + " on " + ServerTable.TABLE_NAME + '.' + ServerTable.ID + '=' + SERVER_ID +
|
2019-08-15 19:27:47 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2022-04-09 19:52:29 +02:00
|
|
|
public static Query<Map<Integer, List<TPS>>> fetchTPSDataOfAllServersBut(long after, long before, ServerUUID leaveOut) {
|
|
|
|
String sql = SELECT + DATE + ',' + TPS + ',' + PLAYERS_ONLINE + ',' + SERVER_ID +
|
2019-08-15 19:27:47 +02:00
|
|
|
FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
INNER_JOIN + ServerTable.TABLE_NAME + " on " + ServerTable.TABLE_NAME + '.' + ServerTable.ID + '=' + SERVER_ID +
|
2019-08-15 19:27:47 +02:00
|
|
|
WHERE + ServerTable.SERVER_UUID + "!=?" +
|
|
|
|
AND + ServerTable.INSTALLED + "=?" +
|
|
|
|
AND + DATE + "<?" +
|
|
|
|
AND + DATE + ">?";
|
2022-04-09 19:52:29 +02:00
|
|
|
return new QueryStatement<Map<Integer, List<TPS>>>(sql, 5000) {
|
2019-08-15 19:27:47 +02:00
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
2021-03-22 06:13:27 +01:00
|
|
|
if (leaveOut != null) {
|
|
|
|
statement.setString(1, leaveOut.toString());
|
|
|
|
} else {
|
|
|
|
statement.setNull(1, Types.VARCHAR);
|
|
|
|
}
|
2019-08-15 19:27:47 +02:00
|
|
|
statement.setBoolean(2, true);
|
|
|
|
statement.setLong(3, before);
|
|
|
|
statement.setLong(4, after);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
2022-04-09 19:52:29 +02:00
|
|
|
public Map<Integer, List<TPS>> processResults(ResultSet set) throws SQLException {
|
|
|
|
Map<Integer, List<TPS>> byServer = new HashMap<>();
|
2019-08-15 19:27:47 +02:00
|
|
|
while (set.next()) {
|
2022-04-09 19:52:29 +02:00
|
|
|
Integer serverUID = set.getInt(SERVER_ID);
|
|
|
|
List<TPS> ofServer = byServer.computeIfAbsent(serverUID, Lists::create);
|
|
|
|
ofServer.add(TPSBuilder.get()
|
|
|
|
.date(set.getLong(DATE))
|
|
|
|
.tps(set.getDouble(TPS))
|
|
|
|
.playersOnline(set.getInt(PLAYERS_ONLINE))
|
|
|
|
.toTPS());
|
2019-08-15 19:27:47 +02:00
|
|
|
}
|
|
|
|
return byServer;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Optional<DateObj<Integer>>> fetchPeakPlayerCount(ServerUUID serverUUID, long afterDate) {
|
2022-04-09 19:52:29 +02:00
|
|
|
String subQuery = '(' + SELECT + "MAX(" + PLAYERS_ONLINE + ')' + FROM + TABLE_NAME + WHERE + SERVER_ID + "=" + ServerTable.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 +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID +
|
2019-02-18 15:48:12 +01:00
|
|
|
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();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Optional<DateObj<Integer>>> fetchAllTimePeakPlayerCount(ServerUUID 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
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Optional<TPS>> fetchLatestTPSEntryForServer(ServerUUID serverUUID) {
|
2019-07-03 11:05:33 +02:00
|
|
|
String sql = SELECT + "*" +
|
|
|
|
FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.SELECT_SERVER_ID +
|
2019-07-03 11:05:33 +02:00
|
|
|
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
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Double> averageTPS(long after, long before, ServerUUID serverUUID) {
|
2019-09-29 12:00:55 +02:00
|
|
|
String sql = SELECT + "AVG(" + TPS + ") as average" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Double> averageCPU(long after, long before, ServerUUID serverUUID) {
|
2019-09-29 12:00:55 +02:00
|
|
|
String sql = SELECT + "AVG(" + CPU_USAGE + ") as average" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Long> averageRAM(long after, long before, ServerUUID serverUUID) {
|
2019-09-29 12:00:55 +02:00
|
|
|
String sql = SELECT + "AVG(" + RAM_USAGE + ") as average" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.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
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Long> averageChunks(long after, long before, ServerUUID serverUUID) {
|
2019-09-29 12:00:55 +02:00
|
|
|
String sql = SELECT + "AVG(" + CHUNKS + ") as average" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.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
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Long> averageEntities(long after, long before, ServerUUID serverUUID) {
|
2019-09-29 12:00:55 +02:00
|
|
|
String sql = SELECT + "AVG(" + ENTITIES + ") as average" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.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
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Long> maxFreeDisk(long after, long before, ServerUUID serverUUID) {
|
2019-09-29 12:00:55 +02:00
|
|
|
String sql = SELECT + "MAX(" + FREE_DISK + ") as free" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Long> minFreeDisk(long after, long before, ServerUUID serverUUID) {
|
2019-09-29 12:00:55 +02:00
|
|
|
String sql = SELECT + "MIN(" + FREE_DISK + ") as free" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.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;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-03-12 17:03:00 +01:00
|
|
|
public static Query<Long> averageFreeDisk(long after, long before, ServerUUID serverUUID) {
|
2019-09-29 12:00:55 +02:00
|
|
|
String sql = SELECT + "AVG(" + FREE_DISK + ") as average" + FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.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
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2021-07-17 11:19:33 +02:00
|
|
|
|
|
|
|
public static Query<Map<Integer, List<TPS>>> fetchTPSDataOfServers(long after, long before, Collection<ServerUUID> serverUUIDs) {
|
|
|
|
String sql = SELECT + "*" + FROM + TABLE_NAME +
|
|
|
|
WHERE + SERVER_ID + " IN " + ServerTable.selectServerIds(serverUUIDs) +
|
|
|
|
AND + DATE + ">=?" +
|
|
|
|
AND + DATE + "<=?" +
|
|
|
|
ORDER_BY + DATE;
|
|
|
|
return new QueryStatement<Map<Integer, List<TPS>>>(sql, 50000) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setLong(1, after);
|
|
|
|
statement.setLong(2, before);
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Map<Integer, List<TPS>> processResults(ResultSet set) throws SQLException {
|
|
|
|
Map<Integer, List<TPS>> data = new HashMap<>();
|
|
|
|
while (set.next()) {
|
|
|
|
int serverId = set.getInt(SERVER_ID);
|
|
|
|
data.computeIfAbsent(serverId, Lists::create)
|
|
|
|
.add(extractTPS(set));
|
|
|
|
}
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2021-07-18 09:43:38 +02:00
|
|
|
|
|
|
|
public static Query<Optional<Long>> fetchLatestServerStartTime(ServerUUID serverUUID, long dataGapThreshold) {
|
|
|
|
String selectPreviousRowNumber = SELECT +
|
|
|
|
"-1+ROW_NUMBER() over (ORDER BY " + DATE + ") AS previous_rn, " +
|
|
|
|
DATE + " AS d1" +
|
|
|
|
FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.SELECT_SERVER_ID +
|
2021-09-18 20:16:23 +02:00
|
|
|
ORDER_BY + "d1 DESC";
|
2021-07-18 09:43:38 +02:00
|
|
|
String selectRowNumber = SELECT +
|
|
|
|
"ROW_NUMBER() over (ORDER BY " + DATE + ") AS rn, " +
|
|
|
|
DATE + " AS previous_date" +
|
|
|
|
FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.SELECT_SERVER_ID +
|
2021-09-18 20:16:23 +02:00
|
|
|
ORDER_BY + "previous_date DESC";
|
2021-07-18 09:43:38 +02:00
|
|
|
String selectFirstEntryDate = SELECT + "MIN(" + DATE + ") as start_time" +
|
|
|
|
FROM + TABLE_NAME +
|
2022-04-09 19:52:29 +02:00
|
|
|
WHERE + SERVER_ID + '=' + ServerTable.SELECT_SERVER_ID;
|
2021-07-18 09:43:38 +02:00
|
|
|
// Finds the start time since difference between d1 and previous date is a gap,
|
|
|
|
// so d1 is always first entry after a gap in the data. MAX finds the latest.
|
|
|
|
// Union ensures if there are no gaps to use the first date recorded.
|
|
|
|
String selectStartTime = SELECT +
|
|
|
|
"MAX(d1) AS start_time" +
|
|
|
|
FROM + "(" + selectPreviousRowNumber + ") t1" +
|
|
|
|
INNER_JOIN +
|
|
|
|
"(" + selectRowNumber + ") t2 ON t1.previous_rn=t2.rn" +
|
|
|
|
WHERE + "d1 - previous_date > ?" +
|
|
|
|
UNION + selectFirstEntryDate;
|
|
|
|
|
|
|
|
return new QueryStatement<Optional<Long>>(selectStartTime) {
|
|
|
|
@Override
|
|
|
|
public void prepare(PreparedStatement statement) throws SQLException {
|
|
|
|
statement.setString(1, serverUUID.toString());
|
|
|
|
statement.setString(2, serverUUID.toString());
|
|
|
|
statement.setLong(3, dataGapThreshold);
|
|
|
|
statement.setString(4, serverUUID.toString());
|
|
|
|
}
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public Optional<Long> processResults(ResultSet set) throws SQLException {
|
|
|
|
long startTime = 0;
|
|
|
|
while (set.next()) {
|
|
|
|
long gotStartTime = set.getLong("start_time");
|
|
|
|
if (!set.wasNull()) {
|
|
|
|
startTime = Math.max(startTime, gotStartTime);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return startTime != 0 ? Optional.of(startTime) : Optional.empty();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
2019-02-16 12:59:36 +01:00
|
|
|
}
|