diff --git a/Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionExtractor.java b/Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionExtractor.java index 76c29f06f..4dd2a3fe9 100644 --- a/Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionExtractor.java +++ b/Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionExtractor.java @@ -45,7 +45,6 @@ public final class ExtensionExtractor { private PluginInfo pluginInfo; private List tabInformation; private List invalidMethods; - private MethodAnnotations methodAnnotations; private Map methods; private Collection conditionalMethods; private Collection tabAnnotations; @@ -102,12 +101,9 @@ public final class ExtensionExtractor { * @deprecated No longer used anywhere, no-op. */ @Deprecated - public void extractAnnotationInformation() { - // no-op - } + public void extractAnnotationInformation() {/* no-op */} private void extractMethods() { - methodAnnotations = new MethodAnnotations(); methods = new EnumMap<>(ExtensionMethod.ParameterType.class); methods.put(ExtensionMethod.ParameterType.SERVER_NONE, new ExtensionMethods()); methods.put(ExtensionMethod.ParameterType.PLAYER_STRING, new ExtensionMethods()); @@ -132,55 +128,41 @@ public final class ExtensionExtractor { method.getAnnotation(BooleanProvider.class).ifPresent(annotation -> { validateMethod(method, annotation); methods.get(method.getParameterType()).addBooleanMethod(method); - methodAnnotations.put(method.getMethod(), BooleanProvider.class, annotation); }); method.getAnnotation(NumberProvider.class).ifPresent(annotation -> { validateMethod(method, annotation); methods.get(method.getParameterType()).addNumberMethod(method); - methodAnnotations.put(method.getMethod(), NumberProvider.class, annotation); }); method.getAnnotation(DoubleProvider.class).ifPresent(annotation -> { validateMethod(method, annotation); methods.get(method.getParameterType()).addDoubleMethod(method); - methodAnnotations.put(method.getMethod(), DoubleProvider.class, annotation); }); method.getAnnotation(PercentageProvider.class).ifPresent(annotation -> { validateMethod(method, annotation); methods.get(method.getParameterType()).addPercentageMethod(method); - methodAnnotations.put(method.getMethod(), PercentageProvider.class, annotation); }); method.getAnnotation(StringProvider.class).ifPresent(annotation -> { validateMethod(method, annotation); methods.get(method.getParameterType()).addStringMethod(method); - methodAnnotations.put(method.getMethod(), StringProvider.class, annotation); }); method.getAnnotation(TableProvider.class).ifPresent(annotation -> { validateMethod(method, annotation); methods.get(method.getParameterType()).addTableMethod(method); - methodAnnotations.put(method.getMethod(), TableProvider.class, annotation); }); method.getAnnotation(GroupProvider.class).ifPresent(annotation -> { validateMethod(method, annotation); methods.get(method.getParameterType()).addGroupMethod(method); - methodAnnotations.put(method.getMethod(), GroupProvider.class, annotation); }); method.getAnnotation(DataBuilderProvider.class).ifPresent(annotation -> { validateMethod(method, annotation); methods.get(method.getParameterType()).addDataBuilderMethod(method); - methodAnnotations.put(method.getMethod(), DataBuilderProvider.class, annotation); }); - method.getAnnotation(Conditional.class).ifPresent(annotation -> { - conditionalMethods.add(method.getMethod()); - methodAnnotations.put(method.getMethod(), Conditional.class, annotation); - }); - method.getAnnotation(Tab.class).ifPresent(annotation -> { - tabAnnotations.add(annotation); - methodAnnotations.put(method.getMethod(), Tab.class, annotation); - }); + method.getAnnotation(Conditional.class).ifPresent(annotation -> conditionalMethods.add(method.getMethod())); + method.getAnnotation(Tab.class).ifPresent(tabAnnotations::add); } - if (methodAnnotations.isEmpty()) { + if (methods.values().stream().allMatch(ExtensionMethods::isEmpty)) { throw new IllegalArgumentException(extensionName + " class had no methods annotated with a Provider annotation"); } @@ -440,10 +422,12 @@ public final class ExtensionExtractor { return tabInformation; } + /** + * @deprecated During refactoring MethodAnnotations was removed. Using {@link ExtensionExtractor#getMethods()} instead. + */ @Deprecated public MethodAnnotations getMethodAnnotations() { - if (methodAnnotations == null) extractMethods(); - return methodAnnotations; + return new MethodAnnotations(); } public Map getMethods() { @@ -455,4 +439,10 @@ public final class ExtensionExtractor { if (invalidMethods == null) extractInvalidMethods(); return invalidMethods; } + + // Visible for testing + Collection getConditionalMethods() { + if (conditionalMethods == null) extractMethods(); + return conditionalMethods; + } } diff --git a/Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionMethods.java b/Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionMethods.java index cfba74ba9..3cd0a5e20 100644 --- a/Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionMethods.java +++ b/Plan/api/src/main/java/com/djrapitops/plan/extension/extractor/ExtensionMethods.java @@ -142,4 +142,15 @@ public class ExtensionMethods { ", dataBuilderProviders=" + dataBuilderProviders + '}'; } + + public boolean isEmpty() { + return booleanProviders.isEmpty() + && numberProviders.isEmpty() + && doubleProviders.isEmpty() + && percentageProviders.isEmpty() + && stringProviders.isEmpty() + && tableProviders.isEmpty() + && groupProviders.isEmpty() + && dataBuilderProviders.isEmpty(); + } } diff --git a/Plan/api/src/test/java/com/djrapitops/plan/extension/extractor/ExtensionExtractorTest.java b/Plan/api/src/test/java/com/djrapitops/plan/extension/extractor/ExtensionExtractorTest.java index 860004788..f37ab2d49 100644 --- a/Plan/api/src/test/java/com/djrapitops/plan/extension/extractor/ExtensionExtractorTest.java +++ b/Plan/api/src/test/java/com/djrapitops/plan/extension/extractor/ExtensionExtractorTest.java @@ -265,7 +265,7 @@ class ExtensionExtractorTest { } ExtensionExtractor underTest = new ExtensionExtractor(new Extension()); - assertEquals("Extension.method did not have any associated Provider for Conditional.", assertThrows(IllegalArgumentException.class, underTest::validateAnnotations).getMessage()); + assertEquals("Extension class had no methods annotated with a Provider annotation", assertThrows(IllegalArgumentException.class, underTest::validateAnnotations).getMessage()); } @Test @@ -489,8 +489,13 @@ class ExtensionExtractorTest { String expected = Stream.of(extension.getClass().getMethod("method").getAnnotation(Conditional.class)) .map(Conditional::value).findFirst().orElseThrow(AssertionError::new); - String result = underTest.getMethodAnnotations().getAnnotations(Conditional.class).stream() - .map(Conditional::value).findFirst().orElseThrow(AssertionError::new); + String result = underTest.getConditionalMethods().stream() + .map(method -> new ExtensionMethod(extension, method)) + .map(extensionMethod -> extensionMethod.getAnnotation(Conditional.class)) + .filter(Optional::isPresent) + .map(Optional::get) + .map(Conditional::value) + .findFirst().orElseThrow(AssertionError::new); assertEquals(expected, result); } diff --git a/Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/mutators/TimeSegmentsMutator.java b/Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/mutators/TimeSegmentsMutator.java index 248ca2c29..1cbce52a6 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/mutators/TimeSegmentsMutator.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/delivery/domain/mutators/TimeSegmentsMutator.java @@ -27,7 +27,7 @@ import java.util.concurrent.TimeUnit; public class TimeSegmentsMutator { - List> segments; + private final List> segments; public TimeSegmentsMutator(List> segments) { this.segments = segments; diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/Database.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/Database.java index 2c93b987c..c339ca4ad 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/Database.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/Database.java @@ -66,7 +66,7 @@ public interface Database { @Override public Optional processResults(ResultSet set) throws SQLException { - return set.next() ? Optional.of(rowExtractor.extract(set)) : Optional.empty(); + return set.next() ? Optional.ofNullable(rowExtractor.extract(set)) : Optional.empty(); } }); } @@ -80,7 +80,7 @@ public interface Database { } default , T> C queryCollection(String sql, RowExtractor rowExtractor, Supplier collectionConstructor, Object... parameters) { - return query(new QueryStatement(sql) { + return query(new QueryStatement(sql, 1000) { @Override public void prepare(PreparedStatement statement) throws SQLException { QueryParameterSetter.setParameters(statement, parameters); @@ -102,7 +102,7 @@ public interface Database { } default , K, V> M queryMap(String sql, MapRowExtractor rowExtractor, Supplier mapConstructor, Object... parameters) { - return query(new QueryStatement(sql) { + return query(new QueryStatement(sql, 100) { @Override public void prepare(PreparedStatement statement) throws SQLException { QueryParameterSetter.setParameters(statement, parameters); diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/RowExtractors.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/RowExtractors.java new file mode 100644 index 000000000..628d6d24c --- /dev/null +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/RowExtractors.java @@ -0,0 +1,52 @@ +/* + * 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 . + */ +package com.djrapitops.plan.storage.database.queries; + +import com.djrapitops.plan.identification.ServerUUID; + +import java.util.UUID; + +public class RowExtractors { + private RowExtractors() {} + + public static RowExtractor getInt(String columnName) { + return set -> { + int value = set.getInt(columnName); + return set.wasNull() ? null : value; + }; + } + + public static RowExtractor getLong(String columnName) { + return set -> { + long value = set.getLong(columnName); + return set.wasNull() ? null : value; + }; + } + + public static RowExtractor getString(String columnName) { + return set -> set.getString(columnName); + } + + public static RowExtractor getUUID(String columnName) { + return set -> UUID.fromString(set.getString(columnName)); + } + + public static RowExtractor getServerUUID(String columnName) { + return set -> ServerUUID.fromString(set.getString(columnName)); + } + +} diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/PlayerCountQueries.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/PlayerCountQueries.java index fc7285d5d..e62bfdf21 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/PlayerCountQueries.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/PlayerCountQueries.java @@ -439,17 +439,7 @@ public class PlayerCountQueries { String sql = SELECT + "COUNT(1) as " + PLAYER_COUNT + FROM + UserInfoTable.TABLE_NAME + WHERE + UserInfoTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID + AND + UserInfoTable.OP + "=?"; - return new QueryStatement(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, serverUUID.toString()); - statement.setBoolean(2, true); - } - - @Override - public Integer processResults(ResultSet set) throws SQLException { - return set.next() ? set.getInt(PLAYER_COUNT) : 0; - } - }; + return db -> db.queryOptional(sql, set -> set.getInt(PLAYER_COUNT), serverUUID, true) + .orElse(0); } } \ No newline at end of file diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/TopListQueries.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/TopListQueries.java index 5ee240cb2..c2841a3a6 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/TopListQueries.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/analysis/TopListQueries.java @@ -18,14 +18,10 @@ package com.djrapitops.plan.storage.database.queries.analysis; import com.djrapitops.plan.identification.ServerUUID; 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; import com.djrapitops.plan.storage.database.sql.tables.SessionsTable; import com.djrapitops.plan.storage.database.sql.tables.UsersTable; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.SQLException; import java.util.Optional; import static com.djrapitops.plan.storage.database.sql.building.Sql.*; @@ -49,26 +45,8 @@ public class TopListQueries { LIMIT + "10" + OFFSET + "?"; - return new QueryStatement>>(sql, 10) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, serverUUID.toString()); - statement.setLong(2, after); - statement.setLong(3, before); - statement.setInt(4, n - 1); - } - - @Override - public Optional> processResults(ResultSet set) throws SQLException { - if (set.next()) { - return Optional.of( - new TopListEntry<>(set.getString(UsersTable.USER_NAME), set.getLong("playtime")) - ); - } - return Optional.empty(); - } - }; - + return db -> db.queryOptional(sql, set -> new TopListEntry<>(set.getString(UsersTable.USER_NAME), set.getLong("playtime")), + serverUUID, after, before, n - 1); } public static Query>> fetchNthTop10ActivePlaytimePlayerOn(ServerUUID serverUUID, int n, long after, long before) { @@ -84,25 +62,8 @@ public class TopListQueries { LIMIT + "10" + OFFSET + "?"; - return new QueryStatement>>(sql, 10) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, serverUUID.toString()); - statement.setLong(2, after); - statement.setLong(3, before); - statement.setInt(4, n - 1); - } - - @Override - public Optional> processResults(ResultSet set) throws SQLException { - if (set.next()) { - return Optional.of( - new TopListEntry<>(set.getString(UsersTable.USER_NAME), set.getLong("active_playtime")) - ); - } - return Optional.empty(); - } - }; + return db -> db.queryOptional(sql, set -> new TopListEntry<>(set.getString(UsersTable.USER_NAME), set.getLong("active_playtime")), + serverUUID, after, before, n - 1); } public static class TopListEntry { diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/BaseUserQueries.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/BaseUserQueries.java index 71df9ca69..871371235 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/BaseUserQueries.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/BaseUserQueries.java @@ -19,16 +19,17 @@ package com.djrapitops.plan.storage.database.queries.objects; import com.djrapitops.plan.gathering.domain.BaseUser; import com.djrapitops.plan.gathering.domain.UserInfo; import com.djrapitops.plan.storage.database.queries.Query; -import com.djrapitops.plan.storage.database.queries.QueryAllStatement; -import com.djrapitops.plan.storage.database.queries.QueryStatement; +import com.djrapitops.plan.storage.database.queries.RowExtractors; import com.djrapitops.plan.storage.database.sql.building.Select; import com.djrapitops.plan.storage.database.sql.tables.UsersTable; import org.apache.commons.text.TextStringBuilder; -import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; -import java.util.*; +import java.util.Collection; +import java.util.Optional; +import java.util.Set; +import java.util.UUID; import static com.djrapitops.plan.storage.database.sql.building.Sql.*; @@ -53,25 +54,16 @@ public class BaseUserQueries { public static Query> fetchAllBaseUsers() { String sql = Select.all(UsersTable.TABLE_NAME).toString(); - return new QueryAllStatement>(sql, 20000) { - @Override - public Collection processResults(ResultSet set) throws SQLException { - return extractBaseUsers(set); - } - }; + return db -> db.queryList(sql, BaseUserQueries::extractBaseUser); } - private static Collection extractBaseUsers(ResultSet set) throws SQLException { - Collection users = new HashSet<>(); - while (set.next()) { - UUID playerUUID = UUID.fromString(set.getString(UsersTable.USER_UUID)); - String name = set.getString(UsersTable.USER_NAME); - long registered = set.getLong(UsersTable.REGISTERED); - int kicked = set.getInt(UsersTable.TIMES_KICKED); + private static BaseUser extractBaseUser(ResultSet set) throws SQLException { + UUID playerUUID = UUID.fromString(set.getString(UsersTable.USER_UUID)); + String name = set.getString(UsersTable.USER_NAME); + long registered = set.getLong(UsersTable.REGISTERED); + int kicked = set.getInt(UsersTable.TIMES_KICKED); - users.add(new BaseUser(playerUUID, name, registered, kicked)); - } - return users; + return new BaseUser(playerUUID, name, registered, kicked); } /** @@ -85,25 +77,7 @@ public class BaseUserQueries { public static Query> fetchBaseUserOfPlayer(UUID playerUUID) { String sql = Select.all(UsersTable.TABLE_NAME).where(UsersTable.USER_UUID + "=?").toString(); - return new QueryStatement>(sql, 20000) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, playerUUID.toString()); - } - - @Override - public Optional processResults(ResultSet set) throws SQLException { - if (set.next()) { - UUID playerUUID = UUID.fromString(set.getString(UsersTable.USER_UUID)); - String name = set.getString(UsersTable.USER_NAME); - long registered = set.getLong(UsersTable.REGISTERED); - int kicked = set.getInt(UsersTable.TIMES_KICKED); - - return Optional.of(new BaseUser(playerUUID, name, registered, kicked)); - } - return Optional.empty(); - } - }; + return db -> db.queryOptional(sql, BaseUserQueries::extractBaseUser, playerUUID); } public static Query> userIdsOfRegisteredBetween(long after, long before) { @@ -111,55 +85,23 @@ public class BaseUserQueries { FROM + UsersTable.TABLE_NAME + WHERE + UsersTable.REGISTERED + ">=?" + AND + UsersTable.REGISTERED + "<=?"; - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setLong(1, after); - statement.setLong(2, before); - } - @Override - public Set processResults(ResultSet set) throws SQLException { - Set userIds = new HashSet<>(); - while (set.next()) { - userIds.add(set.getInt(UsersTable.ID)); - } - return userIds; - } - }; + return db -> db.querySet(sql, RowExtractors.getInt(UsersTable.ID), after, before); } public static Query> minimumRegisterDate() { String sql = SELECT + min(UsersTable.REGISTERED) + " as min" + FROM + UsersTable.TABLE_NAME; - return new QueryAllStatement>(sql) { - @Override - public Optional processResults(ResultSet set) throws SQLException { - if (set.next()) { - long min = set.getLong("min"); - if (!set.wasNull()) return Optional.of(min); - } - return Optional.empty(); - } - }; + return db -> db.queryOptional(sql, RowExtractors.getLong("min")); } - public static Query fetchUserId(UUID playerUUID) { + // Visible for testing + public static Query> fetchUserId(UUID playerUUID) { String sql = Select.from(UsersTable.TABLE_NAME, UsersTable.ID) .where(UsersTable.USER_UUID + "=?") .toString(); - return new QueryStatement(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, playerUUID.toString()); - } - - @Override - public Integer processResults(ResultSet set) throws SQLException { - return set.next() ? set.getInt(UsersTable.ID) : -1; - } - }; + return db -> db.queryOptional(sql, RowExtractors.getInt(UsersTable.ID), playerUUID); } public static Query> fetchExistingUUIDs(Set outOfPlayerUUIDs) { @@ -167,15 +109,6 @@ public class BaseUserQueries { FROM + UsersTable.TABLE_NAME + WHERE + UsersTable.USER_UUID + " IN ('" + new TextStringBuilder().appendWithSeparators(outOfPlayerUUIDs, "','").build() + "')"; - return new QueryAllStatement>(sql) { - @Override - public Set processResults(ResultSet set) throws SQLException { - Set uuids = new HashSet<>(); - while (set.next()) { - uuids.add(UUID.fromString(set.getString(UsersTable.USER_UUID))); - } - return uuids; - } - }; + return db -> db.querySet(sql, RowExtractors.getUUID(UsersTable.USER_UUID)); } } \ No newline at end of file diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/GeoInfoQueries.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/GeoInfoQueries.java index 93b857498..ffaf181fd 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/GeoInfoQueries.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/GeoInfoQueries.java @@ -20,7 +20,7 @@ import com.djrapitops.plan.gathering.domain.GeoInfo; import com.djrapitops.plan.identification.ServerUUID; import com.djrapitops.plan.storage.database.queries.Query; import com.djrapitops.plan.storage.database.queries.QueryAllStatement; -import com.djrapitops.plan.storage.database.queries.QueryStatement; +import com.djrapitops.plan.storage.database.queries.RowExtractors; import com.djrapitops.plan.storage.database.sql.tables.GeoInfoTable; import com.djrapitops.plan.storage.database.sql.tables.ServerTable; import com.djrapitops.plan.storage.database.sql.tables.UserInfoTable; @@ -28,7 +28,6 @@ import com.djrapitops.plan.storage.database.sql.tables.UsersTable; import com.djrapitops.plan.utilities.java.Lists; import org.apache.commons.text.TextStringBuilder; -import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.*; @@ -59,7 +58,7 @@ public class GeoInfoQueries { FROM + GeoInfoTable.TABLE_NAME + " g" + INNER_JOIN + UsersTable.TABLE_NAME + " u on g.user_id=u.id"; - return new QueryAllStatement>>(sql, 50000) { + return new QueryAllStatement>>(sql, 10000) { @Override public Map> processResults(ResultSet set) throws SQLException { return extractGeoInformation(set); @@ -93,23 +92,13 @@ public class GeoInfoQueries { WHERE + GeoInfoTable.USER_ID + "=" + UsersTable.SELECT_USER_ID + GROUP_BY + GeoInfoTable.GEOLOCATION; - return new QueryStatement>(sql, 100) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, playerUUID.toString()); - } + return db -> db.queryList(sql, GeoInfoQueries::extractGeoInfo, playerUUID); + } - @Override - public List processResults(ResultSet set) throws SQLException { - List geoInfo = new ArrayList<>(); - while (set.next()) { - String geolocation = set.getString(GeoInfoTable.GEOLOCATION); - long lastUsed = set.getLong(GeoInfoTable.LAST_USED); - geoInfo.add(new GeoInfo(geolocation, lastUsed)); - } - return geoInfo; - } - }; + private static GeoInfo extractGeoInfo(ResultSet set) throws SQLException { + String geolocation = set.getString(GeoInfoTable.GEOLOCATION); + long lastUsed = set.getLong(GeoInfoTable.LAST_USED); + return new GeoInfo(geolocation, lastUsed); } public static Query> networkGeolocationCounts() { @@ -124,16 +113,14 @@ public class GeoInfoQueries { WHERE + "b." + GeoInfoTable.LAST_USED + IS_NULL + GROUP_BY + "a." + GeoInfoTable.GEOLOCATION; - return new QueryAllStatement>(sql) { - @Override - public Map processResults(ResultSet set) throws SQLException { - Map geolocationCounts = new HashMap<>(); - while (set.next()) { - geolocationCounts.put(set.getString(GeoInfoTable.GEOLOCATION), set.getInt("c")); - } - return geolocationCounts; - } - }; + return db -> db.queryMap(sql, GeoInfoQueries::extractGeolocationCounts); + } + + private static void extractGeolocationCounts(ResultSet set, Map geolocationCounts) throws SQLException { + geolocationCounts.put( + set.getString(GeoInfoTable.GEOLOCATION), + set.getInt("c") + ); } public static Query> networkGeolocationCounts(Collection userIds) { @@ -151,16 +138,7 @@ public class GeoInfoQueries { new TextStringBuilder().appendWithSeparators(userIds, ",").build() + ")" + GROUP_BY + "a." + GeoInfoTable.GEOLOCATION; - return new QueryAllStatement>(sql) { - @Override - public Map processResults(ResultSet set) throws SQLException { - Map geolocationCounts = new HashMap<>(); - while (set.next()) { - geolocationCounts.put(set.getString(GeoInfoTable.GEOLOCATION), set.getInt("c")); - } - return geolocationCounts; - } - }; + return db -> db.queryMap(sql, GeoInfoQueries::extractGeolocationCounts); } public static Query> serverGeolocationCounts(ServerUUID serverUUID) { @@ -178,34 +156,14 @@ public class GeoInfoQueries { AND + "ui." + UserInfoTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID + GROUP_BY + "a." + GeoInfoTable.GEOLOCATION; - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, serverUUID.toString()); - } - - @Override - public Map processResults(ResultSet set) throws SQLException { - Map geolocationCounts = new HashMap<>(); - while (set.next()) { - geolocationCounts.put(set.getString(GeoInfoTable.GEOLOCATION), set.getInt("c")); - } - return geolocationCounts; - } - }; + return db -> db.queryMap(sql, GeoInfoQueries::extractGeolocationCounts, serverUUID); } public static Query> uniqueGeolocations() { String sql = SELECT + GeoInfoTable.GEOLOCATION + FROM + GeoInfoTable.TABLE_NAME + ORDER_BY + GeoInfoTable.GEOLOCATION + " ASC"; - return new QueryAllStatement>(sql) { - @Override - public List processResults(ResultSet set) throws SQLException { - List geolocations = new ArrayList<>(); - while (set.next()) geolocations.add(set.getString(GeoInfoTable.GEOLOCATION)); - return geolocations; - } - }; + + return db -> db.queryList(sql, RowExtractors.getString(GeoInfoTable.GEOLOCATION)); } public static Query> userIdsOfPlayersWithGeolocations(List selected) { @@ -216,13 +174,6 @@ public class GeoInfoQueries { " IN ('" + new TextStringBuilder().appendWithSeparators(selected, "','") + "')"; - return new QueryAllStatement>(sql) { - @Override - public Set processResults(ResultSet set) throws SQLException { - Set geolocations = new HashSet<>(); - while (set.next()) geolocations.add(set.getInt(UsersTable.ID)); - return geolocations; - } - }; + return db -> db.querySet(sql, RowExtractors.getInt(UsersTable.ID)); } } \ No newline at end of file diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/JoinAddressQueries.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/JoinAddressQueries.java index e46e3017f..9f467a973 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/JoinAddressQueries.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/JoinAddressQueries.java @@ -20,12 +20,12 @@ import com.djrapitops.plan.identification.ServerUUID; import com.djrapitops.plan.storage.database.queries.Query; import com.djrapitops.plan.storage.database.queries.QueryAllStatement; import com.djrapitops.plan.storage.database.queries.QueryStatement; +import com.djrapitops.plan.storage.database.queries.RowExtractors; import com.djrapitops.plan.storage.database.sql.tables.JoinAddressTable; import com.djrapitops.plan.storage.database.sql.tables.ServerTable; import com.djrapitops.plan.storage.database.sql.tables.SessionsTable; import org.apache.commons.text.TextStringBuilder; -import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.*; @@ -50,16 +50,11 @@ public class JoinAddressQueries { GROUP_BY + JoinAddressTable.JOIN_ADDRESS + ORDER_BY + JoinAddressTable.JOIN_ADDRESS + " ASC"; - return new QueryAllStatement>(selectLatestJoinAddresses, 100) { - @Override - public Map processResults(ResultSet set) throws SQLException { - Map joinAddresses = new TreeMap<>(); - while (set.next()) { - joinAddresses.put(set.getString(JoinAddressTable.JOIN_ADDRESS), set.getInt("total")); - } - return joinAddresses; - } - }; + return db -> db.queryMap(selectLatestJoinAddresses, JoinAddressQueries::extractJoinAddressCounts, TreeMap::new); + } + + private static void extractJoinAddressCounts(ResultSet set, Map joinAddresses) throws SQLException { + joinAddresses.put(set.getString(JoinAddressTable.JOIN_ADDRESS), set.getInt("total")); } public static Query> latestJoinAddresses(ServerUUID serverUUID) { @@ -76,27 +71,15 @@ public class JoinAddressQueries { GROUP_BY + JoinAddressTable.JOIN_ADDRESS + ORDER_BY + JoinAddressTable.JOIN_ADDRESS + " ASC"; - return new QueryStatement>(selectLatestJoinAddresses, 100) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, serverUUID.toString()); - } - @Override - public Map processResults(ResultSet set) throws SQLException { - Map joinAddresses = new TreeMap<>(); - while (set.next()) { - joinAddresses.put(set.getString(JoinAddressTable.JOIN_ADDRESS), set.getInt("total")); - } - return joinAddresses; - } - }; + return db -> db.queryMap(selectLatestJoinAddresses, JoinAddressQueries::extractJoinAddressCounts, TreeMap::new, serverUUID); } public static QueryStatement> allJoinAddresses() { String sql = SELECT + JoinAddressTable.JOIN_ADDRESS + FROM + JoinAddressTable.TABLE_NAME + ORDER_BY + JoinAddressTable.JOIN_ADDRESS + " ASC"; + return new QueryAllStatement>(sql, 100) { @Override public List processResults(ResultSet set) throws SQLException { @@ -125,18 +108,8 @@ public class JoinAddressQueries { new TextStringBuilder().appendWithSeparators(joinAddresses.stream().map(item -> '?').iterator(), ",") + ')'; // Don't append addresses directly, SQL injection hazard - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - for (int i = 0; i < joinAddresses.size(); i++) { - statement.setString(i + 1, joinAddresses.get(i).toLowerCase()); - } - } - - @Override - public Set processResults(ResultSet set) throws SQLException { - return UserInfoQueries.extractUserIds(set, SessionsTable.USER_ID); - } - }; + return db -> db.querySet(sql, RowExtractors.getInt(SessionsTable.USER_ID), joinAddresses + .stream().map(String::toLowerCase) + .toArray()); } } diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/KillQueries.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/KillQueries.java index 8109a141e..8a00085f0 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/KillQueries.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/KillQueries.java @@ -22,6 +22,7 @@ import com.djrapitops.plan.identification.Server; import com.djrapitops.plan.identification.ServerUUID; import com.djrapitops.plan.storage.database.queries.Query; import com.djrapitops.plan.storage.database.queries.QueryStatement; +import com.djrapitops.plan.storage.database.queries.RowExtractors; import com.djrapitops.plan.storage.database.sql.tables.KillsTable; import com.djrapitops.plan.storage.database.sql.tables.ServerTable; import com.djrapitops.plan.storage.database.sql.tables.SessionsTable; @@ -179,19 +180,9 @@ public class KillQueries { WHERE + KillsTable.SERVER_UUID + "=?" + AND + KillsTable.DATE + ">=?" + AND + KillsTable.DATE + "<=?"; - return new QueryStatement(sql) { - @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; - } - }; + return db -> db.queryOptional(sql, RowExtractors.getLong("count"), serverUUID, after, before) + .orElse(0L); } public static Query averageKDR(long after, long before, ServerUUID serverUUID) { @@ -246,19 +237,10 @@ public class KillQueries { WHERE + SessionsTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID + AND + SessionsTable.SESSION_END + ">=?" + AND + SessionsTable.SESSION_START + "<=?"; - return new QueryStatement(sql) { - @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; - } - }; + + return db -> db.queryOptional(sql, RowExtractors.getLong("count"), serverUUID, after, before) + .orElse(0L); } public static Query deathCount(long after, long before, ServerUUID serverUUID) { @@ -267,19 +249,8 @@ public class KillQueries { WHERE + SessionsTable.SERVER_ID + "=" + ServerTable.SELECT_SERVER_ID + AND + SessionsTable.SESSION_END + ">=?" + AND + SessionsTable.SESSION_START + "<=?"; - return new QueryStatement(sql) { - @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; - } - }; + return db -> db.queryOptional(sql, RowExtractors.getLong("count"), serverUUID, after, before) + .orElse(0L); } public static Query> topWeaponsOfServer(long after, long before, ServerUUID serverUUID, int limit) { @@ -293,22 +264,7 @@ public class KillQueries { FROM + '(' + innerSQL + ") q1" + ORDER_BY + "kills DESC LIMIT ?"; - return new QueryStatement>(sql, limit) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, serverUUID.toString()); - statement.setLong(2, after); - statement.setLong(3, before); - statement.setInt(4, limit); - } - - @Override - public List processResults(ResultSet set) throws SQLException { - List weapons = new ArrayList<>(); - while (set.next()) weapons.add(set.getString(KillsTable.WEAPON)); - return weapons; - } - }; + return db -> db.queryList(sql, RowExtractors.getString(KillsTable.WEAPON), serverUUID, after, before, limit); } public static Query> topWeaponsOfPlayer(long after, long before, UUID playerUUID, int limit) { @@ -322,21 +278,6 @@ public class KillQueries { FROM + '(' + innerSQL + ") q1" + ORDER_BY + "kills DESC LIMIT ?"; - return new QueryStatement>(sql, limit) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, playerUUID.toString()); - statement.setLong(2, after); - statement.setLong(3, before); - statement.setInt(4, limit); - } - - @Override - public List processResults(ResultSet set) throws SQLException { - List weapons = new ArrayList<>(); - while (set.next()) weapons.add(set.getString(KillsTable.WEAPON)); - return weapons; - } - }; + return db -> db.queryList(sql, RowExtractors.getString(KillsTable.WEAPON), playerUUID, after, before, limit); } } \ No newline at end of file diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/NicknameQueries.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/NicknameQueries.java index b4a1dd497..c3788d4a6 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/NicknameQueries.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/NicknameQueries.java @@ -20,12 +20,10 @@ import com.djrapitops.plan.delivery.domain.Nickname; import com.djrapitops.plan.identification.ServerUUID; import com.djrapitops.plan.storage.database.queries.Query; import com.djrapitops.plan.storage.database.queries.QueryAllStatement; -import com.djrapitops.plan.storage.database.queries.QueryStatement; import com.djrapitops.plan.storage.database.sql.tables.NicknamesTable; import com.djrapitops.plan.utilities.java.Lists; import com.djrapitops.plan.utilities.java.Maps; -import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.*; @@ -84,32 +82,24 @@ public class NicknameQueries { AND + NicknamesTable.SERVER_UUID + "=?" + GROUP_BY + NicknamesTable.USER_UUID; String sql = SELECT + - NicknamesTable.LAST_USED + ',' + NicknamesTable.NICKNAME + + NicknamesTable.LAST_USED + ',' + + NicknamesTable.NICKNAME + ',' + + NicknamesTable.SERVER_UUID + FROM + NicknamesTable.TABLE_NAME + WHERE + NicknamesTable.USER_UUID + "=?" + AND + NicknamesTable.SERVER_UUID + "=?" + AND + NicknamesTable.LAST_USED + "=(" + subQuery + ')'; - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, playerUUID.toString()); - statement.setString(2, serverUUID.toString()); - statement.setString(3, playerUUID.toString()); - statement.setString(4, serverUUID.toString()); - } - @Override - public Optional processResults(ResultSet set) throws SQLException { - if (set.next()) { - return Optional.of(new Nickname( - set.getString(NicknamesTable.NICKNAME), - set.getLong(NicknamesTable.LAST_USED), - serverUUID - )); - } - return Optional.empty(); - } - }; + return db -> db.queryOptional(sql, NicknameQueries::extractNickname, + playerUUID, serverUUID, playerUUID, serverUUID); + } + + private static Nickname extractNickname(ResultSet set) throws SQLException { + return new Nickname( + set.getString(NicknamesTable.NICKNAME), + set.getLong(NicknamesTable.LAST_USED), + ServerUUID.fromString(set.getString(NicknamesTable.SERVER_UUID)) + ); } public static Query> fetchNicknameDataOfPlayer(UUID playerUUID) { @@ -120,24 +110,7 @@ public class NicknameQueries { FROM + NicknamesTable.TABLE_NAME + WHERE + NicknamesTable.USER_UUID + "=?"; - return new QueryStatement>(sql, 5000) { - - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, playerUUID.toString()); - } - - @Override - public List processResults(ResultSet set) throws SQLException { - List nicknames = new ArrayList<>(); - while (set.next()) { - ServerUUID serverUUID = ServerUUID.fromString(set.getString(NicknamesTable.SERVER_UUID)); - String nickname = set.getString(NicknamesTable.NICKNAME); - nicknames.add(new Nickname(nickname, set.getLong(NicknamesTable.LAST_USED), serverUUID)); - } - return nicknames; - } - }; + return db -> db.queryList(sql, NicknameQueries::extractNickname, playerUUID); } } \ No newline at end of file diff --git a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/WebUserQueries.java b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/WebUserQueries.java index 4a412c6fa..307101d27 100644 --- a/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/WebUserQueries.java +++ b/Plan/common/src/main/java/com/djrapitops/plan/storage/database/queries/objects/WebUserQueries.java @@ -19,17 +19,16 @@ package com.djrapitops.plan.storage.database.queries.objects; import com.djrapitops.plan.delivery.domain.WebUser; import com.djrapitops.plan.delivery.domain.auth.User; import com.djrapitops.plan.storage.database.queries.Query; -import com.djrapitops.plan.storage.database.queries.QueryAllStatement; -import com.djrapitops.plan.storage.database.queries.QueryStatement; import com.djrapitops.plan.storage.database.sql.tables.CookieTable; import com.djrapitops.plan.storage.database.sql.tables.SecurityTable; import com.djrapitops.plan.storage.database.sql.tables.UsersTable; -import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; -import java.sql.Types; -import java.util.*; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.UUID; import static com.djrapitops.plan.storage.database.sql.building.Sql.*; @@ -47,129 +46,36 @@ public class WebUserQueries { public static Query> fetchUser(String username) { String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME + LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID + - WHERE + SecurityTable.USERNAME + "=? LIMIT 1"; - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, username); - } + WHERE + SecurityTable.USERNAME + "=?" + LIMIT + "1"; - @Override - public Optional processResults(ResultSet set) throws SQLException { - if (set.next()) { - String linkedTo = set.getString(UsersTable.USER_NAME); - UUID linkedToUUID = linkedTo != null ? UUID.fromString(set.getString(SecurityTable.LINKED_TO)) : null; - String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH); - int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL); - List permissions = WebUser.getPermissionsForLevel(permissionLevel); - return Optional.of(new User(username, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions)); - } - return Optional.empty(); - } - }; + return db -> db.queryOptional(sql, WebUserQueries::extractUser, username); } public static Query> fetchUserLinkedTo(String playerName) { String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME + LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID + - WHERE + UsersTable.USER_NAME + "=? LIMIT 1"; - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, playerName); - } - - @Override - public Optional processResults(ResultSet set) throws SQLException { - if (set.next()) { - String linkedTo = set.getString(UsersTable.USER_NAME); - UUID linkedToUUID = linkedTo != null ? UUID.fromString(set.getString(SecurityTable.LINKED_TO)) : null; - String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH); - int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL); - List permissions = WebUser.getPermissionsForLevel(permissionLevel); - return Optional.of(new User(playerName, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions)); - } - return Optional.empty(); - } - }; + WHERE + UsersTable.USER_NAME + "=?" + LIMIT + "1"; + return db -> db.queryOptional(sql, WebUserQueries::extractUser, playerName); } public static Query> fetchUser(UUID linkedToUUID) { String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME + LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID + - WHERE + SecurityTable.LINKED_TO + "=? LIMIT 1"; - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - if (linkedToUUID == null) { - statement.setNull(1, Types.VARCHAR); - } else { - statement.setString(1, linkedToUUID.toString()); - } - } - - @Override - public Optional processResults(ResultSet set) throws SQLException { - if (set.next()) { - String username = set.getString(SecurityTable.USERNAME); - String linkedTo = set.getString(UsersTable.USER_NAME); - String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH); - int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL); - List permissions = WebUser.getPermissionsForLevel(permissionLevel); - return Optional.of(new User(username, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions)); - } - return Optional.empty(); - } - }; + WHERE + SecurityTable.LINKED_TO + "=?" + LIMIT + "1"; + return db -> db.queryOptional(sql, WebUserQueries::extractUser, linkedToUUID); } public static Query> fetchAllUsers() { String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME + LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID; - return new QueryAllStatement>(sql) { - - @Override - public List processResults(ResultSet set) throws SQLException { - List users = new ArrayList<>(); - while (set.next()) { - String username = set.getString(SecurityTable.USERNAME); - String linkedTo = set.getString(UsersTable.USER_NAME); - UUID linkedToUUID = linkedTo != null ? UUID.fromString(set.getString(SecurityTable.LINKED_TO)) : null; - String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH); - int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL); - List permissions = WebUser.getPermissionsForLevel(permissionLevel); - users.add(new User(username, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions)); - } - return users; - } - }; + return db -> db.queryList(sql, WebUserQueries::extractUser); } public static Query> matchUsers(String partOfUsername) { String sql = SELECT + '*' + FROM + SecurityTable.TABLE_NAME + LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID + WHERE + "LOWER(" + SecurityTable.USERNAME + ") LIKE LOWER(?)"; - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setString(1, '%' + partOfUsername + '%'); - } - - @Override - public List processResults(ResultSet set) throws SQLException { - List users = new ArrayList<>(); - while (set.next()) { - String username = set.getString(SecurityTable.USERNAME); - String linkedTo = set.getString(UsersTable.USER_NAME); - UUID linkedToUUID = linkedTo != null ? UUID.fromString(set.getString(SecurityTable.LINKED_TO)) : null; - String passwordHash = set.getString(SecurityTable.SALT_PASSWORD_HASH); - int permissionLevel = set.getInt(SecurityTable.PERMISSION_LEVEL); - List permissions = WebUser.getPermissionsForLevel(permissionLevel); - users.add(new User(username, linkedTo != null ? linkedTo : "console", linkedToUUID, passwordHash, permissionLevel, permissions)); - } - return users; - } - }; + return db -> db.queryList(sql, WebUserQueries::extractUser, '%' + partOfUsername + '%'); } public static Query> fetchActiveCookies() { @@ -178,23 +84,8 @@ public class WebUserQueries { LEFT_JOIN + UsersTable.TABLE_NAME + " on " + SecurityTable.LINKED_TO + "=" + UsersTable.USER_UUID + WHERE + CookieTable.EXPIRES + ">?"; - return new QueryStatement>(sql) { - @Override - public void prepare(PreparedStatement statement) throws SQLException { - statement.setLong(1, System.currentTimeMillis()); - } - - @Override - public Map processResults(ResultSet set) throws SQLException { - Map usersByCookie = new HashMap<>(); - while (set.next()) { - String cookie = set.getString(CookieTable.COOKIE); - User user = extractUser(set); - usersByCookie.put(cookie, user); - } - return usersByCookie; - } - }; + return db -> db.queryMap(sql, (set, byCookie) -> byCookie.put(set.getString(CookieTable.COOKIE), extractUser(set)), + System.currentTimeMillis()); } private static User extractUser(ResultSet set) throws SQLException { @@ -208,13 +99,7 @@ public class WebUserQueries { } public static Query> getCookieExpiryTimes() { - return new QueryAllStatement>(SELECT + CookieTable.COOKIE + ',' + CookieTable.EXPIRES + FROM + CookieTable.TABLE_NAME) { - @Override - public Map processResults(ResultSet set) throws SQLException { - HashMap expiryTimes = new HashMap<>(); - while (set.next()) expiryTimes.put(set.getString(CookieTable.COOKIE), set.getLong(CookieTable.EXPIRES)); - return expiryTimes; - } - }; + String sql = SELECT + CookieTable.COOKIE + ',' + CookieTable.EXPIRES + FROM + CookieTable.TABLE_NAME; + return db -> db.queryMap(sql, (set, expiryTimes) -> expiryTimes.put(set.getString(CookieTable.COOKIE), set.getLong(CookieTable.EXPIRES))); } } \ No newline at end of file diff --git a/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/GeolocationQueriesTest.java b/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/GeolocationQueriesTest.java index e8a4a57e9..9d6f73a17 100644 --- a/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/GeolocationQueriesTest.java +++ b/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/GeolocationQueriesTest.java @@ -206,7 +206,7 @@ public interface GeolocationQueriesTest extends DatabaseTestPreparer { save(playerUUID, geoInfo); } - Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID))); + Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)).orElseThrow(AssertionError::new)); Set result = db().query(GeoInfoQueries.userIdsOfPlayersWithGeolocations( Collections.singletonList(savedData.get(0).getGeolocation())) ); diff --git a/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/JoinAddressQueriesTest.java b/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/JoinAddressQueriesTest.java index 246c975c3..f7abbd8d3 100644 --- a/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/JoinAddressQueriesTest.java +++ b/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/JoinAddressQueriesTest.java @@ -71,7 +71,7 @@ public interface JoinAddressQueriesTest extends DatabaseTestPreparer { session.getExtraData().remove(JoinAddress.class); db().executeTransaction(new StoreSessionTransaction(session)); - Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID))); + Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)).orElseThrow(AssertionError::new)); Set result = db().query(JoinAddressQueries.userIdsOfPlayersWithJoinAddresses(List.of(JoinAddressTable.DEFAULT_VALUE_FOR_LOOKUP))); assertEquals(expected, result); @@ -190,7 +190,7 @@ public interface JoinAddressQueriesTest extends DatabaseTestPreparer { default void joinAddressFilterUUIDsAreFetched() { latestJoinAddressIsUpdatedUponSecondSession(); - Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID))); + Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)).orElseThrow(AssertionError::new)); Set result = db().query(JoinAddressQueries.userIdsOfPlayersWithJoinAddresses( List.of(TestConstants.GET_PLAYER_HOSTNAME.get().toLowerCase())) ); @@ -201,7 +201,7 @@ public interface JoinAddressQueriesTest extends DatabaseTestPreparer { default void joinAddressFilterUUIDsAreFetchedWhenUnknown() { joinAddressCanBeUnknown(); - Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID))); + Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(playerUUID)).orElseThrow(AssertionError::new)); Set result = db().query(JoinAddressQueries.userIdsOfPlayersWithJoinAddresses( List.of(JoinAddressTable.DEFAULT_VALUE_FOR_LOOKUP)) ); diff --git a/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/UserInfoQueriesTest.java b/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/UserInfoQueriesTest.java index 624d0665e..fb7b752fe 100644 --- a/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/UserInfoQueriesTest.java +++ b/Plan/common/src/test/java/com/djrapitops/plan/storage/database/queries/UserInfoQueriesTest.java @@ -202,7 +202,7 @@ public interface UserInfoQueriesTest extends DatabaseTestPreparer { } }).get(); - Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(player2UUID))); + Set expected = Set.of(db().query(BaseUserQueries.fetchUserId(player2UUID)).orElseThrow(AssertionError::new)); Set result = db().query(BaseUserQueries.userIdsOfRegisteredBetween(2500L, 7500L)); assertEquals(expected, result); }