2019-02-10 15:41:13 +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-10 15:41:13 +01:00
2019-08-30 22:14:54 +02:00
import com.djrapitops.plan.delivery.domain.DateHolder ;
2021-03-12 17:03:00 +01:00
import com.djrapitops.plan.delivery.domain.PlayerName ;
2021-07-18 17:07:45 +02:00
import com.djrapitops.plan.delivery.domain.ServerIdentifier ;
2021-03-12 17:03:00 +01:00
import com.djrapitops.plan.delivery.domain.ServerName ;
2019-08-30 22:14:54 +02:00
import com.djrapitops.plan.delivery.domain.mutators.SessionsMutator ;
2021-03-12 17:03:00 +01:00
import com.djrapitops.plan.gathering.domain.* ;
2022-05-20 18:31:46 +02:00
import com.djrapitops.plan.gathering.domain.event.JoinAddress ;
2021-01-29 10:01:08 +01:00
import com.djrapitops.plan.identification.Server ;
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.QueryAllStatement ;
import com.djrapitops.plan.storage.database.queries.QueryStatement ;
2019-12-05 19:22:33 +01:00
import com.djrapitops.plan.storage.database.sql.building.Sql ;
2019-08-30 22:14:54 +02:00
import com.djrapitops.plan.storage.database.sql.tables.* ;
2019-02-13 19:32:17 +01:00
import com.djrapitops.plan.utilities.comparators.DateHolderRecentComparator ;
2019-12-18 23:09:29 +01:00
import com.djrapitops.plan.utilities.java.Maps ;
2021-01-19 10:43:30 +01:00
import org.apache.commons.text.TextStringBuilder ;
2019-02-10 15:41:13 +01:00
2019-02-13 19:32:17 +01:00
import java.sql.PreparedStatement ;
2019-02-10 15:41:13 +01:00
import java.sql.ResultSet ;
import java.sql.SQLException ;
import java.util.* ;
import java.util.stream.Collectors ;
2019-12-05 19:22:33 +01:00
import static com.djrapitops.plan.storage.database.sql.building.Sql.* ;
2019-02-14 21:27:24 +01:00
2019-02-10 15:41:13 +01:00
/ * *
2021-03-12 17:03:00 +01:00
* Queries for { @link FinishedSession } objects .
2019-02-10 15:41:13 +01:00
*
2021-02-13 14:16:03 +01:00
* @author AuroraLS3
2019-02-10 15:41:13 +01:00
* /
public class SessionQueries {
private SessionQueries ( ) {
/* Static method class */
}
2019-08-06 21:34:50 +02:00
private static final String SELECT_SESSIONS_STATEMENT = SELECT +
2019-07-27 10:56:19 +02:00
" s. " + SessionsTable . ID + ',' +
" u. " + UsersTable . USER_NAME + " as name, " +
2022-04-09 19:52:29 +02:00
" u. " + UsersTable . USER_UUID + ',' +
2019-08-23 10:31:01 +02:00
" u_info. " + UserInfoTable . REGISTERED + " as registered, " +
2019-07-27 10:56:19 +02:00
" server. " + ServerTable . NAME + " as server_name, " +
2022-04-09 19:52:29 +02:00
" server. " + ServerTable . ID + " as server_id, " +
" server. " + ServerTable . SERVER_UUID + " as server_uuid, " +
2019-08-06 21:34:50 +02:00
SessionsTable . SESSION_START + ',' +
SessionsTable . SESSION_END + ',' +
SessionsTable . MOB_KILLS + ',' +
SessionsTable . DEATHS + ',' +
SessionsTable . AFK_TIME + ',' +
WorldTimesTable . SURVIVAL + ',' +
WorldTimesTable . CREATIVE + ',' +
WorldTimesTable . ADVENTURE + ',' +
WorldTimesTable . SPECTATOR + ',' +
WorldTable . NAME + ',' +
2022-05-20 18:31:46 +02:00
" j. " + JoinAddressTable . JOIN_ADDRESS + " as join_address, " +
2020-11-19 15:50:15 +01:00
KillsTable . KILLER_UUID + ',' +
2019-08-06 21:34:50 +02:00
KillsTable . VICTIM_UUID + ',' +
2019-07-27 10:56:19 +02:00
" v. " + UsersTable . USER_NAME + " as victim_name, " +
2022-11-13 14:49:32 +01:00
" v. " + UsersTable . REGISTERED + " as victim_ " + UsersTable . REGISTERED + " , " +
2021-07-18 17:07:45 +02:00
" k. " + UsersTable . USER_NAME + " as killer_name, " +
2019-08-06 21:34:50 +02:00
KillsTable . DATE + ',' +
2019-02-13 19:32:17 +01:00
KillsTable . WEAPON +
2019-07-27 10:56:19 +02:00
FROM + SessionsTable . TABLE_NAME + " s " +
2022-05-20 18:31:46 +02:00
INNER_JOIN + JoinAddressTable . TABLE_NAME + " j on s. " + SessionsTable . JOIN_ADDRESS_ID + " =j. " + JoinAddressTable . ID +
2022-04-09 19:52:29 +02:00
INNER_JOIN + UsersTable . TABLE_NAME + " u on u. " + UsersTable . ID + " =s. " + SessionsTable . USER_ID +
INNER_JOIN + ServerTable . TABLE_NAME + " server on server. " + ServerTable . ID + " =s. " + SessionsTable . SERVER_ID +
LEFT_JOIN + UserInfoTable . TABLE_NAME + " u_info on (u_info. " + UserInfoTable . USER_ID + " =s. " + SessionsTable . USER_ID + AND + " u_info. " + UserInfoTable . SERVER_ID + " =s. " + SessionsTable . SERVER_ID + ')' +
2019-07-27 10:56:19 +02:00
LEFT_JOIN + KillsTable . TABLE_NAME + " ON " + " s. " + SessionsTable . ID + '=' + KillsTable . TABLE_NAME + '.' + KillsTable . SESSION_ID +
LEFT_JOIN + UsersTable . TABLE_NAME + " v on v. " + UsersTable . USER_UUID + '=' + KillsTable . VICTIM_UUID +
2021-07-18 17:07:45 +02:00
LEFT_JOIN + UsersTable . TABLE_NAME + " k on k. " + UsersTable . USER_UUID + '=' + KillsTable . KILLER_UUID +
2019-07-27 10:56:19 +02:00
INNER_JOIN + WorldTimesTable . TABLE_NAME + " ON s. " + SessionsTable . ID + '=' + WorldTimesTable . TABLE_NAME + '.' + WorldTimesTable . SESSION_ID +
INNER_JOIN + WorldTable . TABLE_NAME + " ON " + WorldTimesTable . TABLE_NAME + '.' + WorldTimesTable . WORLD_ID + '=' + WorldTable . TABLE_NAME + '.' + WorldTable . ID ;
2019-02-13 19:32:17 +01:00
2019-08-06 21:34:50 +02:00
private static final String ORDER_BY_SESSION_START_DESC = ORDER_BY + SessionsTable . SESSION_START + " DESC " ;
2019-02-14 21:27:24 +01:00
2019-02-10 15:41:13 +01:00
/ * *
* Query the database for Session data with kill , death or world data .
*
* @return List of sessions
* /
2021-03-12 17:03:00 +01:00
public static Query < List < FinishedSession > > fetchAllSessions ( ) {
2019-02-14 21:27:24 +01:00
String sql = SELECT_SESSIONS_STATEMENT +
ORDER_BY_SESSION_START_DESC ;
2022-06-18 10:31:53 +02:00
return new QueryAllStatement < > ( sql , 50000 ) {
2019-02-13 19:32:17 +01:00
@Override
2021-03-12 17:03:00 +01:00
public List < FinishedSession > processResults ( ResultSet set ) throws SQLException {
2019-02-13 19:32:17 +01:00
return extractDataFromSessionSelectStatement ( set ) ;
}
} ;
}
/ * *
* Query the database for Session data of a player with kill and world data .
*
* @param playerUUID UUID of the Player .
* @return Map : Server UUID - List of sessions on the server .
* /
2021-03-12 17:03:00 +01:00
public static Query < Map < ServerUUID , List < FinishedSession > > > fetchSessionsOfPlayer ( UUID playerUUID ) {
2019-02-14 21:27:24 +01:00
String sql = SELECT_SESSIONS_STATEMENT +
2022-04-09 19:52:29 +02:00
WHERE + " s. " + SessionsTable . USER_ID + " = " + UsersTable . SELECT_USER_ID +
2019-02-14 21:27:24 +01:00
ORDER_BY_SESSION_START_DESC ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql , 1000 ) {
2019-02-13 19:32:17 +01:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , playerUUID . toString ( ) ) ;
}
@Override
2021-03-12 17:03:00 +01:00
public Map < ServerUUID , List < FinishedSession > > processResults ( ResultSet set ) throws SQLException {
List < FinishedSession > sessions = extractDataFromSessionSelectStatement ( set ) ;
2019-02-13 19:32:17 +01:00
return SessionsMutator . sortByServers ( sessions ) ;
}
} ;
}
2021-03-12 17:03:00 +01:00
private static List < FinishedSession > extractDataFromSessionSelectStatement ( ResultSet set ) throws SQLException {
2019-02-13 19:32:17 +01:00
// Server UUID - Player UUID - Session Start - Session
2021-03-12 17:03:00 +01:00
Map < ServerUUID , Map < UUID , SortedMap < Long , FinishedSession > > > byServer = new HashMap < > ( ) ;
2019-02-13 19:32:17 +01:00
// Utilities
String [ ] gms = GMTimes . getGMKeyArray ( ) ;
2020-03-11 22:10:17 +01:00
Comparator < DateHolder > mostRecentFirst = new DateHolderRecentComparator ( ) ;
2019-02-14 21:27:24 +01:00
Comparator < Long > longRecentComparator = ( one , two ) - > Long . compare ( two , one ) ; // Descending order, most recent first.
2019-02-13 19:32:17 +01:00
while ( set . next ( ) ) {
2022-04-09 19:52:29 +02:00
ServerUUID serverUUID = ServerUUID . fromString ( set . getString ( " server_uuid " ) ) ;
2021-03-12 17:03:00 +01:00
Map < UUID , SortedMap < Long , FinishedSession > > serverSessions = byServer . computeIfAbsent ( serverUUID , Maps : : create ) ;
2019-02-13 19:32:17 +01:00
2022-04-09 19:52:29 +02:00
UUID playerUUID = UUID . fromString ( set . getString ( UsersTable . USER_UUID ) ) ;
2021-03-12 17:03:00 +01:00
SortedMap < Long , FinishedSession > playerSessions = serverSessions . computeIfAbsent ( playerUUID , key - > new TreeMap < > ( longRecentComparator ) ) ;
2019-02-13 19:32:17 +01:00
long sessionStart = set . getLong ( SessionsTable . SESSION_START ) ;
// id, uuid, serverUUID, sessionStart, sessionEnd, mobKills, deaths, afkTime
2021-03-12 17:03:00 +01:00
FinishedSession session = playerSessions . getOrDefault ( sessionStart , new FinishedSession (
2019-02-13 19:32:17 +01:00
playerUUID ,
serverUUID ,
sessionStart ,
set . getLong ( SessionsTable . SESSION_END ) ,
2021-03-12 17:03:00 +01:00
set . getLong ( SessionsTable . AFK_TIME ) ,
new DataMap ( )
2019-02-13 19:32:17 +01:00
) ) ;
2021-03-12 17:03:00 +01:00
DataMap extraData = session . getExtraData ( ) ;
extraData . put ( FinishedSession . Id . class , new FinishedSession . Id ( set . getInt ( SessionsTable . ID ) ) ) ;
extraData . put ( MobKillCounter . class , new MobKillCounter ( set . getInt ( SessionsTable . MOB_KILLS ) ) ) ;
extraData . put ( DeathCounter . class , new DeathCounter ( set . getInt ( SessionsTable . DEATHS ) ) ) ;
2022-05-20 18:31:46 +02:00
extraData . put ( JoinAddress . class , new JoinAddress ( set . getString ( " join_address " ) ) ) ;
2021-03-12 17:03:00 +01:00
Optional < WorldTimes > existingWorldTimes = extraData . get ( WorldTimes . class ) ;
Optional < PlayerKills > existingPlayerKills = extraData . get ( PlayerKills . class ) ;
WorldTimes worldTimes = existingWorldTimes . orElseGet ( WorldTimes : : new ) ;
2019-02-13 19:32:17 +01:00
String worldName = set . getString ( WorldTable . NAME ) ;
if ( ! worldTimes . contains ( worldName ) ) {
Map < String , Long > gmMap = new HashMap < > ( ) ;
gmMap . put ( gms [ 0 ] , set . getLong ( WorldTimesTable . SURVIVAL ) ) ;
gmMap . put ( gms [ 1 ] , set . getLong ( WorldTimesTable . CREATIVE ) ) ;
gmMap . put ( gms [ 2 ] , set . getLong ( WorldTimesTable . ADVENTURE ) ) ;
gmMap . put ( gms [ 3 ] , set . getLong ( WorldTimesTable . SPECTATOR ) ) ;
GMTimes gmTimes = new GMTimes ( gmMap ) ;
worldTimes . setGMTimesForWorld ( worldName , gmTimes ) ;
}
2022-06-18 10:31:53 +02:00
if ( existingWorldTimes . isEmpty ( ) ) extraData . put ( WorldTimes . class , worldTimes ) ;
2021-03-12 17:03:00 +01:00
2021-07-18 17:07:45 +02:00
ServerName serverName = new ServerName (
Server . getIdentifiableName (
set . getString ( " server_name " ) ,
2023-04-09 09:10:28 +02:00
set . getInt ( " server_id " ) ,
false
2021-07-18 17:07:45 +02:00
) ) ;
extraData . put ( ServerName . class , serverName ) ;
2021-03-12 17:03:00 +01:00
PlayerKills playerKills = existingPlayerKills . orElseGet ( PlayerKills : : new ) ;
2019-02-13 19:32:17 +01:00
String victimName = set . getString ( " victim_name " ) ;
if ( victimName ! = null ) {
2021-07-18 17:07:45 +02:00
PlayerKill . Killer killer = new PlayerKill . Killer (
UUID . fromString ( set . getString ( KillsTable . KILLER_UUID ) ) ,
set . getString ( " killer_name " )
) ;
PlayerKill . Victim victim = new PlayerKill . Victim (
UUID . fromString ( set . getString ( KillsTable . VICTIM_UUID ) ) ,
2022-11-13 14:49:32 +01:00
victimName ,
set . getLong ( " victim_ " + UsersTable . REGISTERED )
2021-07-18 17:07:45 +02:00
) ;
ServerIdentifier serverIdentifier = new ServerIdentifier ( serverUUID , serverName ) ;
2019-02-13 19:32:17 +01:00
String weapon = set . getString ( KillsTable . WEAPON ) ;
2021-07-18 17:07:45 +02:00
long date = set . getLong ( KillsTable . DATE ) ;
PlayerKill newKill = new PlayerKill ( killer , victim , serverIdentifier , weapon , date ) ;
2021-03-12 17:03:00 +01:00
2020-03-11 22:10:17 +01:00
if ( ! playerKills . contains ( newKill ) ) {
playerKills . add ( newKill ) ;
}
2019-02-13 19:32:17 +01:00
}
2022-06-18 10:31:53 +02:00
if ( existingPlayerKills . isEmpty ( ) ) extraData . put ( PlayerKills . class , playerKills ) ;
2019-02-13 19:32:17 +01:00
2021-03-12 17:03:00 +01:00
extraData . put ( PlayerName . class , new PlayerName ( set . getString ( " name " ) ) ) ;
2019-07-27 10:56:19 +02:00
2019-08-14 15:33:56 +02:00
session . setAsFirstSessionIfMatches ( set . getLong ( " registered " ) ) ;
2019-02-13 19:32:17 +01:00
playerSessions . put ( sessionStart , session ) ;
}
2021-03-12 17:03:00 +01:00
return byServer . values ( ) . stream ( )
2019-02-10 15:41:13 +01:00
. map ( Map : : values )
. flatMap ( Collection : : stream )
2019-02-14 21:27:24 +01:00
. map ( SortedMap : : values )
2019-02-10 15:41:13 +01:00
. flatMap ( Collection : : stream )
2020-03-11 22:10:17 +01:00
. sorted ( mostRecentFirst ) // Disorder arises
2019-02-10 15:41:13 +01:00
. collect ( Collectors . toList ( ) ) ;
}
2019-07-04 11:45:00 +02:00
2021-03-12 17:03:00 +01:00
public static Query < List < FinishedSession > > fetchServerSessionsWithoutKillOrWorldData ( long after , long before , ServerUUID serverUUID ) {
2019-07-04 11:45:00 +02:00
String sql = SELECT +
2022-04-09 19:52:29 +02:00
SessionsTable . TABLE_NAME + '.' + SessionsTable . ID + ',' +
UsersTable . USER_UUID + ',' +
2019-07-27 10:56:19 +02:00
SessionsTable . SESSION_START + ',' +
SessionsTable . SESSION_END + ',' +
SessionsTable . DEATHS + ',' +
SessionsTable . MOB_KILLS + ',' +
2019-07-04 11:45:00 +02:00
SessionsTable . AFK_TIME +
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
INNER_JOIN + UsersTable . TABLE_NAME + " u on u. " + UsersTable . ID + '=' + SessionsTable . TABLE_NAME + '.' + SessionsTable . USER_ID +
WHERE + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-07-04 11:45:00 +02:00
AND + SessionsTable . SESSION_START + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql , 1000 ) {
2019-07-04 11:45:00 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , serverUUID . toString ( ) ) ;
statement . setLong ( 2 , after ) ;
statement . setLong ( 3 , before ) ;
}
@Override
2021-03-12 17:03:00 +01:00
public List < FinishedSession > processResults ( ResultSet set ) throws SQLException {
List < FinishedSession > sessions = new ArrayList < > ( ) ;
2019-07-04 11:45:00 +02:00
while ( set . next ( ) ) {
2022-04-09 19:52:29 +02:00
UUID uuid = UUID . fromString ( set . getString ( UsersTable . USER_UUID ) ) ;
2019-07-04 11:45:00 +02:00
long start = set . getLong ( SessionsTable . SESSION_START ) ;
long end = set . getLong ( SessionsTable . SESSION_END ) ;
int deaths = set . getInt ( SessionsTable . DEATHS ) ;
int mobKills = set . getInt ( SessionsTable . MOB_KILLS ) ;
int id = set . getInt ( SessionsTable . ID ) ;
long timeAFK = set . getLong ( SessionsTable . AFK_TIME ) ;
2021-03-12 17:03:00 +01:00
DataMap extraData = new DataMap ( ) ;
extraData . put ( FinishedSession . Id . class , new FinishedSession . Id ( id ) ) ;
extraData . put ( DeathCounter . class , new DeathCounter ( deaths ) ) ;
extraData . put ( MobKillCounter . class , new MobKillCounter ( mobKills ) ) ;
2019-07-04 11:45:00 +02:00
2021-03-12 17:03:00 +01:00
sessions . add ( new FinishedSession ( uuid , serverUUID , start , end , timeAFK , extraData ) ) ;
2019-07-04 11:45:00 +02:00
}
return sessions ;
}
} ;
}
2019-07-06 15:41:17 +02:00
2021-03-12 17:03:00 +01:00
private static Query < Long > fetchLatestSessionStartLimitForServer ( ServerUUID serverUUID , int limit ) {
2019-07-27 10:56:19 +02:00
String sql = SELECT + SessionsTable . SESSION_START + FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
WHERE + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-07-27 10:56:19 +02:00
ORDER_BY_SESSION_START_DESC + " LIMIT ? " ;
2019-07-06 15:41:17 +02:00
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql , limit ) {
2019-07-06 15:41:17 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , serverUUID . toString ( ) ) ;
statement . setInt ( 2 , limit ) ;
}
@Override
2019-07-27 10:56:19 +02:00
public Long processResults ( ResultSet set ) throws SQLException {
Long last = null ;
while ( set . next ( ) ) {
last = set . getLong ( SessionsTable . SESSION_START ) ;
}
return last ;
2019-07-06 15:41:17 +02:00
}
} ;
}
2019-07-07 08:27:45 +02:00
2019-08-21 14:16:21 +02:00
private static Query < Long > fetchLatestSessionStartLimit ( int limit ) {
String sql = SELECT + SessionsTable . SESSION_START + FROM + SessionsTable . TABLE_NAME +
ORDER_BY_SESSION_START_DESC + " LIMIT ? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql , limit ) {
2019-08-21 14:16:21 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setInt ( 1 , limit ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
Long last = null ;
while ( set . next ( ) ) {
last = set . getLong ( SessionsTable . SESSION_START ) ;
}
return last ;
}
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < List < FinishedSession > > fetchLatestSessionsOfServer ( ServerUUID serverUUID , int limit ) {
2019-07-27 10:56:19 +02:00
String sql = SELECT_SESSIONS_STATEMENT +
2022-04-09 19:52:29 +02:00
WHERE + " s. " + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-07-27 10:56:19 +02:00
AND + " s. " + SessionsTable . SESSION_START + " >=? " +
ORDER_BY_SESSION_START_DESC ;
return db - > {
Long start = db . query ( fetchLatestSessionStartLimitForServer ( serverUUID , limit ) ) ;
2021-03-12 17:03:00 +01:00
return db . query ( new QueryStatement < List < FinishedSession > > ( sql ) {
2019-07-27 10:56:19 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , serverUUID . toString ( ) ) ;
statement . setLong ( 2 , start ! = null ? start : 0L ) ;
}
@Override
2021-03-12 17:03:00 +01:00
public List < FinishedSession > processResults ( ResultSet set ) throws SQLException {
2019-07-27 10:56:19 +02:00
return extractDataFromSessionSelectStatement ( set ) ;
}
} ) ;
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < List < FinishedSession > > fetchLatestSessions ( int limit ) {
2019-08-23 14:23:01 +02:00
String sql = SELECT_SESSIONS_STATEMENT
// Fix for "First Session" icons in the Most recent sessions on network page
2022-04-09 19:52:29 +02:00
. replace ( LEFT_JOIN + UserInfoTable . TABLE_NAME + " u_info on (u_info. " + UserInfoTable . USER_ID + " =s. " + SessionsTable . USER_ID + AND + " u_info. " + UserInfoTable . SERVER_ID + " =s. " + SessionsTable . SERVER_ID + ')' , " " )
2019-08-23 14:23:01 +02:00
. replace ( " u_info " , " u " ) +
2019-08-21 14:16:21 +02:00
WHERE + " s. " + SessionsTable . SESSION_START + " >=? " +
ORDER_BY_SESSION_START_DESC ;
return db - > {
Long start = db . query ( fetchLatestSessionStartLimit ( limit ) ) ;
2021-03-12 17:03:00 +01:00
return db . query ( new QueryStatement < List < FinishedSession > > ( sql ) {
2019-08-21 14:16:21 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , start ! = null ? start : 0L ) ;
}
@Override
2021-03-12 17:03:00 +01:00
public List < FinishedSession > processResults ( ResultSet set ) throws SQLException {
2019-08-21 14:16:21 +02:00
return extractDataFromSessionSelectStatement ( set ) ;
}
} ) ;
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < Long > sessionCount ( long after , long before , ServerUUID serverUUID ) {
2019-07-07 08:27:45 +02:00
String sql = SELECT + " COUNT(1) as count " +
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
WHERE + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-07-07 08:27:45 +02:00
AND + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-07-07 08:27:45 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , serverUUID . toString ( ) ) ;
statement . setLong ( 2 , after ) ;
statement . setLong ( 3 , before ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " count " ) : 0L ;
}
} ;
}
2019-08-16 21:07:29 +02:00
public static Query < Long > sessionCount ( long after , long before ) {
String sql = SELECT + " COUNT(1) as count " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-08-16 21:07:29 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , after ) ;
statement . setLong ( 2 , before ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " count " ) : 0L ;
}
} ;
}
2019-09-23 17:38:32 +02:00
/ * *
* Query session count for each day within range on a server .
*
* @param after After epoch ms
* @param before Before epoch ms
* @param timeZoneOffset Offset in ms to determine start of day .
* @param serverUUID UUID of the Plan server .
* @return Map - Epoch ms ( Start of day at 0 AM , no offset ) : Session count of that day
* /
2021-03-12 17:03:00 +01:00
public static Query < NavigableMap < Long , Integer > > sessionCountPerDay ( long after , long before , long timeZoneOffset , ServerUUID serverUUID ) {
2019-08-14 07:35:22 +02:00
return database - > {
Sql sql = database . getSql ( ) ;
String selectSessionsPerDay = SELECT +
sql . dateToEpochSecond ( sql . dateToDayStamp ( sql . epochSecondToDate ( '(' + SessionsTable . SESSION_START + " +?)/1000 " ) ) ) +
" *1000 as date, " +
" COUNT(1) as session_count " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
2022-04-09 19:52:29 +02:00
AND + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-08-14 07:35:22 +02:00
GROUP_BY + " date " ;
return database . query ( new QueryStatement < NavigableMap < Long , Integer > > ( selectSessionsPerDay , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , timeZoneOffset ) ;
statement . setLong ( 2 , before ) ;
statement . setLong ( 3 , after ) ;
statement . setString ( 4 , serverUUID . toString ( ) ) ;
}
@Override
public NavigableMap < Long , Integer > processResults ( ResultSet set ) throws SQLException {
NavigableMap < Long , Integer > uniquePerDay = new TreeMap < > ( ) ;
while ( set . next ( ) ) {
uniquePerDay . put ( set . getLong ( " date " ) , set . getInt ( " session_count " ) ) ;
}
return uniquePerDay ;
}
} ) ;
} ;
}
2023-09-30 16:10:18 +02:00
/ * *
* Query session count for each day within range across the whole network .
*
* @param after After epoch ms
* @param before Before epoch ms
* @param timeZoneOffset Offset in ms to determine start of day .
* @return Map - Epoch ms ( Start of day at 0 AM , no offset ) : Session count of that day
* /
public static Query < NavigableMap < Long , Integer > > sessionCountPerDay ( long after , long before , long timeZoneOffset ) {
return database - > {
Sql sql = database . getSql ( ) ;
String selectSessionsPerDay = SELECT +
sql . dateToEpochSecond ( sql . dateToDayStamp ( sql . epochSecondToDate ( '(' + SessionsTable . SESSION_START + " +?)/1000 " ) ) ) +
" *1000 as date, " +
" COUNT(1) as session_count " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
GROUP_BY + " date " ;
return database . query ( new QueryStatement < NavigableMap < Long , Integer > > ( selectSessionsPerDay , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , timeZoneOffset ) ;
statement . setLong ( 2 , before ) ;
statement . setLong ( 3 , after ) ;
}
@Override
public NavigableMap < Long , Integer > processResults ( ResultSet set ) throws SQLException {
NavigableMap < Long , Integer > uniquePerDay = new TreeMap < > ( ) ;
while ( set . next ( ) ) {
uniquePerDay . put ( set . getLong ( " date " ) , set . getInt ( " session_count " ) ) ;
}
return uniquePerDay ;
}
} ) ;
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < Long > playtime ( long after , long before , ServerUUID serverUUID ) {
2019-07-07 08:27:45 +02:00
String sql = SELECT + " SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime " +
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
WHERE + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-07-07 08:27:45 +02:00
AND + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-07-07 08:27:45 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , serverUUID . toString ( ) ) ;
statement . setLong ( 2 , after ) ;
statement . setLong ( 3 , before ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " playtime " ) : 0L ;
}
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < Map < ServerUUID , Long > > playtimeOfPlayer ( long after , long before , UUID playerUUID ) {
2022-04-09 19:52:29 +02:00
String sql = SELECT + ServerTable . SERVER_UUID + " ,SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime " +
2019-08-25 17:56:09 +02:00
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
INNER_JOIN + ServerTable . TABLE_NAME + " se on se. " + ServerTable . ID + '=' + SessionsTable . TABLE_NAME + '.' + SessionsTable . SERVER_ID +
WHERE + SessionsTable . USER_ID + " = " + UsersTable . SELECT_USER_ID +
2019-08-25 17:56:09 +02:00
AND + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " +
2022-04-09 19:52:29 +02:00
GROUP_BY + SessionsTable . SERVER_ID ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-08-25 17:56:09 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , playerUUID . toString ( ) ) ;
statement . setLong ( 2 , after ) ;
statement . setLong ( 3 , before ) ;
}
@Override
2021-03-12 17:03:00 +01:00
public Map < ServerUUID , Long > processResults ( ResultSet set ) throws SQLException {
Map < ServerUUID , Long > playtimeOfPlayer = new HashMap < > ( ) ;
2019-08-25 17:56:09 +02:00
while ( set . next ( ) ) {
2022-04-09 19:52:29 +02:00
playtimeOfPlayer . put ( ServerUUID . fromString ( set . getString ( ServerTable . SERVER_UUID ) ) , set . getLong ( " playtime " ) ) ;
2019-08-25 17:56:09 +02:00
}
return playtimeOfPlayer ;
}
} ;
}
2019-08-16 21:07:29 +02:00
public static Query < Long > playtime ( long after , long before ) {
String sql = SELECT + " SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-08-16 21:07:29 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , after ) ;
statement . setLong ( 2 , before ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " playtime " ) : 0L ;
}
} ;
}
2019-09-23 17:38:32 +02:00
/ * *
* Query playtime for each day within range on a server .
*
* @param after After epoch ms
* @param before Before epoch ms
* @param timeZoneOffset Offset in ms to determine start of day .
* @param serverUUID UUID of the Plan server .
* @return Map - Epoch ms ( Start of day at 0 AM , no offset ) : Playtime of that day
* /
2021-03-12 17:03:00 +01:00
public static Query < NavigableMap < Long , Long > > playtimePerDay ( long after , long before , long timeZoneOffset , ServerUUID serverUUID ) {
2019-08-14 07:35:22 +02:00
return database - > {
Sql sql = database . getSql ( ) ;
String selectPlaytimePerDay = SELECT +
sql . dateToEpochSecond ( sql . dateToDayStamp ( sql . epochSecondToDate ( '(' + SessionsTable . SESSION_START + " +?)/1000 " ) ) ) +
" *1000 as date, " +
" SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
2022-04-09 19:52:29 +02:00
AND + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-08-14 07:35:22 +02:00
GROUP_BY + " date " ;
return database . query ( new QueryStatement < NavigableMap < Long , Long > > ( selectPlaytimePerDay , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , timeZoneOffset ) ;
statement . setLong ( 2 , before ) ;
statement . setLong ( 3 , after ) ;
statement . setString ( 4 , serverUUID . toString ( ) ) ;
}
@Override
public NavigableMap < Long , Long > processResults ( ResultSet set ) throws SQLException {
NavigableMap < Long , Long > uniquePerDay = new TreeMap < > ( ) ;
while ( set . next ( ) ) {
uniquePerDay . put ( set . getLong ( " date " ) , set . getLong ( " playtime " ) ) ;
}
return uniquePerDay ;
}
} ) ;
} ;
}
2023-09-30 16:10:18 +02:00
/ * *
* Query playtime for each day within range across the whole network .
*
* @param after After epoch ms
* @param before Before epoch ms
* @param timeZoneOffset Offset in ms to determine start of day .
* @return Map - Epoch ms ( Start of day at 0 AM , no offset ) : Playtime of that day
* /
public static Query < NavigableMap < Long , Long > > playtimePerDay ( long after , long before , long timeZoneOffset ) {
return database - > {
Sql sql = database . getSql ( ) ;
String selectPlaytimePerDay = SELECT +
sql . dateToEpochSecond ( sql . dateToDayStamp ( sql . epochSecondToDate ( '(' + SessionsTable . SESSION_START + " +?)/1000 " ) ) ) +
" *1000 as date, " +
" SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
GROUP_BY + " date " ;
return database . query ( new QueryStatement < NavigableMap < Long , Long > > ( selectPlaytimePerDay , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , timeZoneOffset ) ;
statement . setLong ( 2 , before ) ;
statement . setLong ( 3 , after ) ;
}
@Override
public NavigableMap < Long , Long > processResults ( ResultSet set ) throws SQLException {
NavigableMap < Long , Long > uniquePerDay = new TreeMap < > ( ) ;
while ( set . next ( ) ) {
uniquePerDay . put ( set . getLong ( " date " ) , set . getLong ( " playtime " ) ) ;
}
return uniquePerDay ;
}
} ) ;
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < Long > averagePlaytimePerDay ( long after , long before , long timeZoneOffset , ServerUUID serverUUID ) {
2019-08-14 07:35:22 +02:00
return database - > {
Sql sql = database . getSql ( ) ;
String selectPlaytimePerDay = SELECT +
sql . dateToEpochSecond ( sql . dateToDayStamp ( sql . epochSecondToDate ( '(' + SessionsTable . SESSION_START + " +?)/1000 " ) ) ) +
" *1000 as date, " +
" SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
2022-04-09 19:52:29 +02:00
AND + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-08-14 07:35:22 +02:00
GROUP_BY + " date " ;
String selectAverage = SELECT + " AVG(playtime) as average " + FROM + '(' + selectPlaytimePerDay + " ) q1 " ;
return database . query ( new QueryStatement < Long > ( selectAverage , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , timeZoneOffset ) ;
statement . setLong ( 2 , before ) ;
statement . setLong ( 3 , after ) ;
statement . setString ( 4 , serverUUID . toString ( ) ) ;
}
2019-08-14 18:01:48 +02:00
@Override
public Long processResults ( ResultSet set ) throws SQLException {
2019-10-19 11:42:25 +02:00
return set . next ( ) ? ( long ) set . getDouble ( " average " ) : 0 ;
2019-08-14 18:01:48 +02:00
}
} ) ;
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < Long > averagePlaytimePerPlayer ( long after , long before , ServerUUID serverUUID ) {
2019-08-14 18:01:48 +02:00
return database - > {
String selectPlaytimePerPlayer = SELECT +
2022-04-09 19:52:29 +02:00
SessionsTable . USER_ID + " , " +
2019-08-14 18:01:48 +02:00
" SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
2022-04-09 19:52:29 +02:00
AND + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
GROUP_BY + SessionsTable . USER_ID ;
2019-08-14 18:01:48 +02:00
String selectAverage = SELECT + " AVG(playtime) as average " + FROM + '(' + selectPlaytimePerPlayer + " ) q1 " ;
return database . query ( new QueryStatement < Long > ( selectAverage , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , before ) ;
statement . setLong ( 2 , after ) ;
statement . setString ( 3 , serverUUID . toString ( ) ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
2019-10-19 11:42:25 +02:00
return set . next ( ) ? ( long ) set . getDouble ( " average " ) : 0 ;
2019-08-14 18:01:48 +02:00
}
} ) ;
} ;
}
2019-08-15 13:24:30 +02:00
/ * *
* Fetch average playtime per ALL players .
*
* @param after After epoch ms
* @param before Before epoch ms
* @return Average ms played / player , calculated with grouped sums from sessions table .
* /
public static Query < Long > averagePlaytimePerPlayer ( long after , long before ) {
return database - > {
String selectPlaytimePerPlayer = SELECT +
2022-04-09 19:52:29 +02:00
SessionsTable . USER_ID + " , " +
2019-08-15 13:24:30 +02:00
" SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
2022-04-09 19:52:29 +02:00
GROUP_BY + SessionsTable . USER_ID ;
2019-08-15 13:24:30 +02:00
String selectAverage = SELECT + " AVG(playtime) as average " + FROM + '(' + selectPlaytimePerPlayer + " ) q1 " ;
return database . query ( new QueryStatement < Long > ( selectAverage , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , before ) ;
statement . setLong ( 2 , after ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
2019-10-19 11:42:25 +02:00
return set . next ( ) ? ( long ) set . getDouble ( " average " ) : 0 ;
2019-08-15 13:24:30 +02:00
}
} ) ;
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < Long > averageAfkPerPlayer ( long after , long before , ServerUUID serverUUID ) {
2019-08-14 18:01:48 +02:00
return database - > {
String selectAfkPerPlayer = SELECT +
2022-04-09 19:52:29 +02:00
SessionsTable . USER_ID + " , " +
2019-08-14 18:01:48 +02:00
" SUM( " + SessionsTable . AFK_TIME + " ) as afk " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
2022-04-09 19:52:29 +02:00
AND + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
GROUP_BY + SessionsTable . USER_ID ;
2019-08-14 18:01:48 +02:00
String selectAverage = SELECT + " AVG(afk) as average " + FROM + '(' + selectAfkPerPlayer + " ) q1 " ;
return database . query ( new QueryStatement < Long > ( selectAverage , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , before ) ;
statement . setLong ( 2 , after ) ;
statement . setString ( 3 , serverUUID . toString ( ) ) ;
}
2019-08-15 13:24:30 +02:00
@Override
public Long processResults ( ResultSet set ) throws SQLException {
2019-10-19 11:42:25 +02:00
return set . next ( ) ? ( long ) set . getDouble ( " average " ) : 0 ;
2019-08-15 13:24:30 +02:00
}
} ) ;
} ;
}
/ * *
* Fetch average Afk per ALL players .
*
* @param after After epoch ms
* @param before Before epoch ms
* @return Average ms afk / player , calculated with grouped sums from sessions table .
* /
public static Query < Long > averageAfkPerPlayer ( long after , long before ) {
return database - > {
String selectAfkPerPlayer = SELECT +
2022-04-09 19:52:29 +02:00
SessionsTable . USER_ID + " , " +
2019-08-15 13:24:30 +02:00
" SUM( " + SessionsTable . AFK_TIME + " ) as afk " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " <=? " +
AND + SessionsTable . SESSION_START + " >=? " +
2022-04-09 19:52:29 +02:00
GROUP_BY + SessionsTable . USER_ID ;
2019-08-15 13:24:30 +02:00
String selectAverage = SELECT + " AVG(afk) as average " + FROM + '(' + selectAfkPerPlayer + " ) q1 " ;
return database . query ( new QueryStatement < Long > ( selectAverage , 100 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , before ) ;
statement . setLong ( 2 , after ) ;
}
2019-08-14 07:35:22 +02:00
@Override
public Long processResults ( ResultSet set ) throws SQLException {
2019-10-19 11:42:25 +02:00
return set . next ( ) ? ( long ) set . getDouble ( " average " ) : 0 ;
2019-08-14 07:35:22 +02:00
}
} ) ;
} ;
}
2021-03-12 17:03:00 +01:00
public static Query < Long > afkTime ( long after , long before , ServerUUID serverUUID ) {
2019-07-07 08:27:45 +02:00
String sql = SELECT + " SUM( " + SessionsTable . AFK_TIME + " ) as afk_time " +
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
WHERE + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-07-07 08:27:45 +02:00
AND + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-07-07 08:27:45 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , serverUUID . toString ( ) ) ;
statement . setLong ( 2 , after ) ;
statement . setLong ( 3 , before ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " afk_time " ) : 0L ;
}
} ;
}
2019-08-21 15:26:40 +02:00
2019-08-23 15:59:24 +02:00
public static Query < Long > afkTime ( long after , long before ) {
String sql = SELECT + " SUM( " + SessionsTable . AFK_TIME + " ) as afk_time " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-08-23 15:59:24 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , after ) ;
statement . setLong ( 2 , before ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " afk_time " ) : 0L ;
}
} ;
}
2019-08-21 15:26:40 +02:00
public static Query < Map < String , Long > > playtimePerServer ( long after , long before ) {
String sql = SELECT +
" SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime, " +
2022-04-09 19:52:29 +02:00
" s. " + ServerTable . ID + ',' +
2021-02-02 13:01:16 +01:00
" s. " + ServerTable . NAME +
2019-08-21 15:26:40 +02:00
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
INNER_JOIN + ServerTable . TABLE_NAME + " s on s. " + ServerTable . ID + '=' + SessionsTable . TABLE_NAME + '.' + SessionsTable . SERVER_ID +
2019-08-21 15:26:40 +02:00
WHERE + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " +
2022-09-25 09:30:13 +02:00
GROUP_BY + " s. " + ServerTable . ID + " ,s. " + ServerTable . NAME ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql , 100 ) {
2019-08-21 15:26:40 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , after ) ;
statement . setLong ( 2 , before ) ;
}
@Override
public Map < String , Long > processResults ( ResultSet set ) throws SQLException {
Map < String , Long > playtimePerServer = new HashMap < > ( ) ;
while ( set . next ( ) ) {
2021-01-29 10:01:08 +01:00
String name = Server . getIdentifiableName (
set . getString ( ServerTable . NAME ) ,
2023-04-09 09:10:28 +02:00
set . getInt ( ServerTable . ID ) ,
false
2021-01-29 10:01:08 +01:00
) ;
playtimePerServer . put ( name , set . getLong ( " playtime " ) ) ;
2019-08-21 15:26:40 +02:00
}
return playtimePerServer ;
}
} ;
}
2019-08-25 17:56:09 +02:00
2023-01-22 09:18:14 +01:00
public static Query < Long > lastSeen ( UUID playerUUID ) {
String sql = SELECT + " MAX( " + SessionsTable . SESSION_END + " ) as last_seen " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . USER_ID + " = " + UsersTable . SELECT_USER_ID ;
return db - > db . queryOptional ( sql , set - > set . getLong ( " last_seen " ) , playerUUID )
. orElse ( 0L ) ;
}
2021-03-12 17:03:00 +01:00
public static Query < Long > lastSeen ( UUID playerUUID , ServerUUID serverUUID ) {
2019-08-25 17:56:09 +02:00
String sql = SELECT + " MAX( " + SessionsTable . SESSION_END + " ) as last_seen " +
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
WHERE + SessionsTable . USER_ID + " = " + UsersTable . SELECT_USER_ID +
AND + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-08-25 17:56:09 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , playerUUID . toString ( ) ) ;
statement . setString ( 2 , serverUUID . toString ( ) ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " last_seen " ) : 0 ;
}
} ;
}
2019-09-29 12:00:55 +02:00
2021-03-12 17:03:00 +01:00
public static Query < Long > activePlaytime ( long after , long before , ServerUUID serverUUID ) {
2019-09-29 12:00:55 +02:00
String sql = SELECT + " SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + '-' + SessionsTable . AFK_TIME +
" ) as playtime " +
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
WHERE + SessionsTable . SERVER_ID + " = " + ServerTable . SELECT_SERVER_ID +
2019-09-29 12:00:55 +02:00
AND + SessionsTable . SESSION_END + " >=? " +
AND + SessionsTable . SESSION_START + " <=? " ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2019-09-29 12:00:55 +02:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setString ( 1 , serverUUID . toString ( ) ) ;
statement . setLong ( 2 , after ) ;
statement . setLong ( 3 , before ) ;
}
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " playtime " ) : 0L ;
}
} ;
}
2020-03-24 11:03:39 +01:00
2022-04-09 19:52:29 +02:00
public static Query < Set < Integer > > userIdsOfPlayedBetween ( long after , long before , List < ServerUUID > serverUUIDs ) {
String selectServerIds = SELECT + ServerTable . ID +
FROM + ServerTable . TABLE_NAME +
WHERE + ServerTable . SERVER_UUID + " IN (' " + new TextStringBuilder ( ) . appendWithSeparators ( serverUUIDs , " ',' " ) + " ') " ;
String sql = SELECT + DISTINCT + " u. " + UsersTable . ID +
2020-03-24 11:03:39 +01:00
FROM + SessionsTable . TABLE_NAME +
2022-04-09 19:52:29 +02:00
INNER_JOIN + UsersTable . TABLE_NAME + " u on u. " + UsersTable . ID + '=' + SessionsTable . USER_ID +
2020-03-24 11:03:39 +01:00
WHERE + SessionsTable . SESSION_END + " >=? " +
2021-10-09 12:17:12 +02:00
AND + SessionsTable . SESSION_START + " <=? " +
2022-04-09 19:52:29 +02:00
( serverUUIDs . isEmpty ( ) ? " " : AND + SessionsTable . SERVER_ID + " IN ( " + selectServerIds + " ) " ) ;
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( sql ) {
2020-03-24 11:03:39 +01:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , after ) ;
statement . setLong ( 2 , before ) ;
}
@Override
2022-04-09 19:52:29 +02:00
public Set < Integer > processResults ( ResultSet set ) throws SQLException {
Set < Integer > userIds = new HashSet < > ( ) ;
2020-03-24 11:03:39 +01:00
while ( set . next ( ) ) {
2022-04-09 19:52:29 +02:00
userIds . add ( set . getInt ( UsersTable . ID ) ) ;
2020-03-24 11:03:39 +01:00
}
2022-04-09 19:52:29 +02:00
return userIds ;
2020-03-24 11:03:39 +01:00
}
} ;
}
2021-01-19 10:43:30 +01:00
2023-10-10 15:50:40 +02:00
public static Query < List < FinishedSession > > fetchQuerySessions ( Set < Integer > userIds , List < ServerUUID > serverUUIDs , long after , long before ) {
String uuidsInSet = " IN ( " + new TextStringBuilder ( ) . appendWithSeparators ( userIds , " , " ) + " ) " ;
String selectServerIds = SELECT + ServerTable . ID +
FROM + ServerTable . TABLE_NAME +
WHERE + ServerTable . SERVER_UUID + " IN (' " + new TextStringBuilder ( ) . appendWithSeparators ( serverUUIDs , " ',' " ) + " ') " ;
String sql = SELECT_SESSIONS_STATEMENT +
WHERE + SessionsTable . SESSION_START + " >? " +
AND + SessionsTable . SESSION_END + " <? " +
AND + " s. " + SessionsTable . USER_ID + uuidsInSet +
( serverUUIDs . isEmpty ( ) ? " " : AND + " s. " + SessionsTable . SERVER_ID + " IN ( " + selectServerIds + " ) " ) +
ORDER_BY_SESSION_START_DESC ;
return new QueryStatement < > ( sql , 2000 ) {
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , after ) ;
statement . setLong ( 2 , before ) ;
}
@Override
public List < FinishedSession > processResults ( ResultSet set ) throws SQLException {
return extractDataFromSessionSelectStatement ( set ) ;
}
} ;
}
2022-04-09 19:52:29 +02:00
public static Query < Map < String , Long > > summaryOfPlayers ( Set < Integer > userIds , List < ServerUUID > serverUUIDs , long after , long before ) {
String uuidsInSet = " IN ( " + new TextStringBuilder ( ) . appendWithSeparators ( userIds , " , " ) + " ) " ;
String selectServerIds = SELECT + ServerTable . ID +
FROM + ServerTable . TABLE_NAME +
WHERE + ServerTable . SERVER_UUID + " IN (' " + new TextStringBuilder ( ) . appendWithSeparators ( serverUUIDs , " ',' " ) + " ') " ;
2021-01-19 10:43:30 +01:00
String selectAggregates = SELECT +
" SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + " ) as playtime, " +
" SUM( " + SessionsTable . SESSION_END + '-' + SessionsTable . SESSION_START + '-' + SessionsTable . AFK_TIME + " ) as active_playtime, " +
" COUNT(1) as session_count " +
FROM + SessionsTable . TABLE_NAME +
WHERE + SessionsTable . SESSION_START + " >? " +
AND + SessionsTable . SESSION_END + " <? " +
2022-04-09 19:52:29 +02:00
AND + SessionsTable . USER_ID + uuidsInSet +
( serverUUIDs . isEmpty ( ) ? " " : AND + SessionsTable . SERVER_ID + " IN ( " + selectServerIds + " ) " ) ;
2021-01-19 10:43:30 +01:00
2022-06-18 10:31:53 +02:00
return new QueryStatement < > ( selectAggregates ) {
2021-01-19 10:43:30 +01:00
@Override
public void prepare ( PreparedStatement statement ) throws SQLException {
statement . setLong ( 1 , after ) ;
statement . setLong ( 2 , before ) ;
}
@Override
public Map < String , Long > processResults ( ResultSet set ) throws SQLException {
2021-01-26 13:04:21 +01:00
if ( set . next ( ) ) {
2021-02-03 20:21:09 +01:00
long sessionCount = set . getLong ( " session_count " ) ;
2021-02-03 18:46:00 +01:00
long playtime = set . getLong ( " playtime " ) ;
long activePlaytime = set . getLong ( " active_playtime " ) ;
2022-04-09 19:52:29 +02:00
int playerCount = userIds . size ( ) ;
2021-01-26 13:04:21 +01:00
return Maps . builder ( String . class , Long . class )
. put ( " total_playtime " , playtime )
2021-02-03 18:46:00 +01:00
. put ( " average_playtime " , playerCount ! = 0 ? playtime / playerCount : - 1L )
. put ( " total_afk_playtime " , playtime - activePlaytime )
2021-02-12 12:11:57 +01:00
. put ( " average_afk_playtime " , playerCount ! = 0 ? ( playtime - activePlaytime ) / playerCount : - 1L )
2021-02-03 18:46:00 +01:00
. put ( " total_active_playtime " , activePlaytime )
. put ( " average_active_playtime " , playerCount ! = 0 ? activePlaytime / playerCount : - 1L )
2021-01-26 13:04:21 +01:00
. put ( " total_sessions " , sessionCount )
2021-02-03 18:46:00 +01:00
. put ( " average_sessions " , playerCount ! = 0 ? sessionCount / playerCount : - 1L )
2021-01-26 13:04:21 +01:00
. put ( " average_session_length " , sessionCount ! = 0 ? playtime / sessionCount : - 1L )
. build ( ) ;
} else {
return Collections . emptyMap ( ) ;
}
2021-01-19 10:43:30 +01:00
}
} ;
}
2021-01-29 10:58:06 +01:00
public static Query < Long > earliestSessionStart ( ) {
String sql = SELECT + " MIN( " + SessionsTable . SESSION_START + " ) as m " +
FROM + SessionsTable . TABLE_NAME ;
2022-06-18 10:31:53 +02:00
return new QueryAllStatement < > ( sql ) {
2021-01-29 10:58:06 +01:00
@Override
public Long processResults ( ResultSet set ) throws SQLException {
return set . next ( ) ? set . getLong ( " m " ) : - 1L ;
}
} ;
}
2019-02-10 15:41:13 +01:00
}