Added type mappings between Skript and SQL

src/main/java/com/btk5h/skriptdb/SkriptValueWrapper.java

@@ -0,0 +1,202 @@
+package com.btk5h.skriptdb;
+
+import static java.sql.Types.*;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.IntStream;
+
+import ch.njol.skript.util.Date;
+import ch.njol.skript.util.Time;
+
+public class SkriptValueWrapper {
+	
+	private static final Map<Class<?>, SkriptValueWrapper> wrappersBySkript = new HashMap<>();
+	private static final Map<Integer, SkriptValueWrapper> wrappersBySql = new HashMap<>();
+	
+	
+	public static final SkriptValueWrapper FALLBACK = register(Object.class, Function.identity(), ResultSet::getObject);
+	public static final SkriptValueWrapper TEXT_VALUE = register(String.class, SkriptValueWrapper::asString, SkriptValueWrapper::getString, CHAR, VARCHAR, LONGVARCHAR, CLOB);
+	public static final SkriptValueWrapper BOOLEAN_VALUE = register(Boolean.class, SkriptValueWrapper::asBoolean, ResultSet::getBoolean, BOOLEAN);
+	public static final SkriptValueWrapper LONG_VALUE = register(Long.class, x -> x, SkriptValueWrapper::getLong, BIT, TINYINT, SMALLINT, INTEGER, BIGINT);
+	public static final SkriptValueWrapper DOUBLE_VALUE = register(Double.class, x -> x, SkriptValueWrapper::getDouble, FLOAT, REAL, DOUBLE, NUMERIC, DECIMAL);
+	public static final SkriptValueWrapper DATE_VALUE = register(String.class, SkriptValueWrapper::noParser, SkriptValueWrapper::getString, DATE);
+	public static final SkriptValueWrapper TIME_VALUE = register(Time.class, SkriptValueWrapper::asTime, SkriptValueWrapper::getTime, TIME);
+	public static final SkriptValueWrapper TIMESTAMP_VALUE = register(Date.class, SkriptValueWrapper::asTimestamp, SkriptValueWrapper::getTimestamp, TIMESTAMP);
+	public static final SkriptValueWrapper BINARY_VALUE = register(String.class, SkriptValueWrapper::noParser, SkriptValueWrapper::getBinary, TIMESTAMP);
+	
+	
+	
+	private final Class<?> skriptType;
+	private final Function<Object, Object> skToSqlMapper;
+	private final ResultFetcher<Object> sqlToSkMapper;
+	private final int[] validSqlTypes;
+	
+	
+	@SuppressWarnings("unchecked")
+	private <T> SkriptValueWrapper(Class<T> skriptType, Function<T, Object> skToSql, ResultFetcher<? super T> sqlToSk, int... validSqlTypes) {
+		this.skriptType = skriptType;
+		this.skToSqlMapper = (Function<Object, Object>) skToSql;
+		this.sqlToSkMapper = (ResultFetcher<Object>) sqlToSk;
+		this.validSqlTypes = IntStream.of(validSqlTypes)
+				.sorted()
+				.toArray();
+	}
+	
+	
+	public Object asSql(Object obj) {
+		return this.skToSqlMapper.apply(obj);
+	}
+	
+	
+	public boolean isSkApplicable(Class<?> type) {
+		return this.skriptType.isAssignableFrom(type);
+	}
+	
+	
+	public boolean isSqlApplicable(int sqlType) {
+		return Arrays.binarySearch(this.validSqlTypes, sqlType) >= 0;
+	}
+	
+	
+	public Object asSkript(ResultSet rs, int column) throws SQLException {
+		return this.sqlToSkMapper.fetch(rs, column);
+	}
+	
+	
+	public static SkriptValueWrapper getBySQLType(int type) {
+		return wrappersBySql.getOrDefault(type, FALLBACK);
+	}
+	
+	
+	public static SkriptValueWrapper getBySkriptType(Class<?> type) {
+		return wrappersBySkript.getOrDefault(type, FALLBACK);
+	}
+	
+	
+	public static SkriptValueWrapper getBySQLLType(int type) {
+		return switch (type) {
+			//case CHAR, VARCHAR, LONGVARCHAR, CLOB -> null; // string
+			//case BOOLEAN -> null; // boolean
+			//case BIT, TINYINT, SMALLINT, INTEGER, BIGINT -> null; // long
+			//case FLOAT, REAL, DOUBLE, NUMERIC, DECIMAL -> null; // double
+			//case DATE -> null; // string
+			//case TIME -> null; // time
+			//case TIMESTAMP -> null; // Date
+			//case BINARY, VARBINARY, LONGVARBINARY, BLOB -> null; // hex String
+			//case NULL, OTHER, JAVA_OBJECT, DISTINCT, STRUCT, ARRAY -> null; // just whatever it gives to me
+			default -> null;
+		};
+	}
+	
+	
+	private static <T> SkriptValueWrapper register(Class<T> skriptType, Function<T, Object> skToSql, ResultFetcher<? super T> sqlToSk, int... validSqlTypes) {
+		SkriptValueWrapper wrapper = new SkriptValueWrapper(skriptType, skToSql, sqlToSk, validSqlTypes);
+		wrappersBySkript.putIfAbsent(skriptType, wrapper);
+		for (int i : validSqlTypes) {
+			wrappersBySql.putIfAbsent(i, wrapper);
+		}
+		return wrapper;
+	}
+	
+	
+	private static String getString(ResultSet rs, int column) throws SQLException {
+		return rs.getString(column);
+	}
+	
+	private static String asString(Object obj) {
+		return obj != null ? String.valueOf(obj) : null;
+	}
+	
+	
+	private static Long getLong(ResultSet rs, int column) throws SQLException {
+		var val = rs.getLong(column);
+		if (!rs.wasNull()) {
+			return val;
+		}
+		return null;
+	}
+	
+	
+	private static Double getDouble(ResultSet rs, int column) throws SQLException {
+		var val = rs.getDouble(column);
+		if (!rs.wasNull()) {
+			return val;
+		}
+		return null;
+	}
+	
+	
+	private static final int TICKS_PER_HOUR = 1000;
+	private static final double TICKS_PER_MINUTE = 1000. / 60;
+	private static final int HOUR_ZERO = 6 * TICKS_PER_HOUR;
+	
+	private static Time getTime(ResultSet rs, int column) throws SQLException {
+		var time = rs.getTime(column);
+		if (time != null) {
+			var local = time.toLocalTime();
+			var minutes = local.getMinute();
+			var hours = local.getHour();
+			return new Time((int) Math.round(
+					hours * TICKS_PER_HOUR
+					- HOUR_ZERO
+					+ minutes * TICKS_PER_MINUTE));
+		}
+		return null;
+	}
+	
+	private static Object asTime(Time time) {
+		if (time != null) {
+			return new java.sql.Time(time.getTime());
+		}
+		return null;
+	}
+	
+	
+	private static Date getTimestamp(ResultSet rs, int column) throws SQLException {
+		return new Date(rs.getTimestamp(column).getTime());
+	}
+	
+	private static Object asTimestamp(Date date) {
+		return Timestamp.from(Instant.ofEpochMilli(date.getTimestamp()));
+	}
+	
+	private static Object asBoolean(Object obj) {
+		if (obj instanceof Number n) {
+			return n.doubleValue() > 0;
+		} else if (obj instanceof Boolean b) {
+			return b;
+		}
+		return null;
+	}
+	
+	
+	private static String getBinary(ResultSet rs, int column) throws SQLException {
+		byte[] bytes = rs.getBytes(column);
+		if (!rs.wasNull()) {
+			StringBuilder sb = new StringBuilder(bytes.length);
+			for (int i = 0; i < bytes.length; i++) {
+				sb.append(String.format("%02X", bytes[i]));
+			}
+			return sb.toString();
+		}
+		return null;
+	}
+	
+	
+	private static <T, U> U noParser(T t) {
+		throw new IllegalStateException("This value shouldn't have a parser");
+	}
+	
+	
+	private interface ResultFetcher<T> {
+		public T fetch(ResultSet rs, int index) throws SQLException;
+	}
+
+}

src/main/java/com/btk5h/skriptdb/skript/EffExecuteStatement.java

@@ -1,33 +1,51 @@
 package com.btk5h.skriptdb.skript;
 
-import ch.njol.skript.Skript;
-import ch.njol.skript.effects.Delay;
-import ch.njol.skript.lang.*;
-import ch.njol.skript.variables.Variables;
-import ch.njol.util.Kleenean;
-import ch.njol.util.Pair;
-import com.btk5h.skriptdb.SkriptDB;
-import com.btk5h.skriptdb.SkriptUtil;
-import com.zaxxer.hikari.HikariDataSource;
-import org.bukkit.Bukkit;
-import org.bukkit.event.Event;
-
-import javax.sql.DataSource;
-import javax.sql.rowset.CachedRowSet;
-import javax.sql.rowset.serial.SerialBlob;
-import javax.sql.rowset.serial.SerialException;
 import java.io.IOException;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.sql.Statement;
-import java.util.*;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.regex.Pattern;
+import java.util.stream.Stream;
+
+import javax.sql.DataSource;
+import javax.sql.rowset.serial.SerialBlob;
+import javax.sql.rowset.serial.SerialException;
+
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+
+import com.btk5h.skriptdb.SkriptDB;
+import com.btk5h.skriptdb.SkriptUtil;
+import com.btk5h.skriptdb.SkriptValueWrapper;
+import com.zaxxer.hikari.HikariDataSource;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.effects.Delay;
+import ch.njol.skript.lang.Effect;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.Trigger;
+import ch.njol.skript.lang.TriggerItem;
+import ch.njol.skript.lang.Variable;
+import ch.njol.skript.lang.VariableString;
+import ch.njol.skript.variables.Variables;
+import ch.njol.util.Kleenean;
+import ch.njol.util.Pair;
 
 /**
  * Executes a statement on a database and optionally stores the result in a variable. Expressions
@@ -153,7 +171,10 @@ public class EffExecuteStatement extends Effect {
                                 .orElse("unknown")));
                 args = Arrays.copyOf(args, queryArgCount);
             }
-            return new Pair<>(query.getSingle(e), Arrays.asList(args));
+            List<Object> argsList = Stream.of(args)
+            		.map(arg -> SkriptValueWrapper.getBySkriptType(arg.getClass()).asSql(arg))
+            		.toList();
+            return new Pair<>(query.getSingle(e), argsList);
         } else if (query instanceof VariableString && !((VariableString) query).isSimple()) {
             return parseVariableQuery(e, (VariableString) query);
         }
@@ -223,14 +244,16 @@ public class EffExecuteStatement extends Effect {
         }
 
         if (hasResultSet) {
-            CachedRowSet crs = SkriptDB.getRowSetFactory().createCachedRowSet();
+        	// TODO: Check if caching is even needed
-            crs.populate(generatedKeys ? stmt.getGeneratedKeys() : stmt.getResultSet());
+            //CachedRowSet crs = SkriptDB.getRowSetFactory().createCachedRowSet();
+            ResultSet rs = generatedKeys ? stmt.getGeneratedKeys() : stmt.getResultSet();
+            //crs.populate(rs);
 
             if (isList) {
-                return fetchQueryResultSet(crs, baseVariable);
+                return fetchQueryResultSet(rs, baseVariable);
             } else {
-                crs.last();
+            	rs.last();
-                return Map.of(baseVariable, crs.getRow());
+                return Map.of(baseVariable, rs.getRow());
             }
         } else if (!isList) {
             //if no results are returned and the specified variable isn't a list variable, put the affected rows count in the variable
@@ -239,21 +262,25 @@ public class EffExecuteStatement extends Effect {
         return Map.of();
     }
     
-    private Map<String, Object> fetchQueryResultSet(CachedRowSet crs, String baseVariable) throws SQLException {
+    private Map<String, Object> fetchQueryResultSet(/*CachedRowSet*/ResultSet crs, String baseVariable) throws SQLException {
     	Map<String, Object> variableList = new HashMap<>();
         ResultSetMetaData meta = crs.getMetaData();
         int columnCount = meta.getColumnCount();
-
+        SkriptValueWrapper[] wrappers = new SkriptValueWrapper[columnCount];
+        String[] columnNames = new String[columnCount];
         for (int i = 1; i <= columnCount; i++) {
             String label = meta.getColumnLabel(i);
             variableList.put(baseVariable + label, label);
+            columnNames[i - 1] = label;
+            wrappers[i - 1] = SkriptValueWrapper.getBySQLType(meta.getColumnType(i));
         }
         
         int rowNumber = 1;
         while (crs.next()) {
             for (int i = 1; i <= columnCount; i++) {
-                variableList.put(baseVariable + meta.getColumnLabel(i).toLowerCase(Locale.ENGLISH)
+            	Object obj = wrappers[i - 1].asSkript(crs, i);
-                        + Variable.SEPARATOR + rowNumber, crs.getObject(i));
+                variableList.put(baseVariable + columnNames[i - 1].toLowerCase(Locale.ENGLISH)
+                        + Variable.SEPARATOR + rowNumber, obj);
             }
             rowNumber++;
         }
@@ -338,7 +365,6 @@ public class EffExecuteStatement extends Effect {
             }
             queryArguments = (Expression<Object>) exprs[2];
         }
-        ;
         Expression<?> resultHolder = exprs[3];
         quickly = parseResult.hasTag("quickly");
         if (resultHolder instanceof Variable) {