Some java 17 code cleanup

.gitignore

@@ -7,3 +7,19 @@
 out/
 target
 compile/
+
+# eclipse specific git ignore
+*.pydevproject
+.project
+.metadata
+bin/**
+tmp/**
+tmp/**/*
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.classpath
+.settings/
+.loadpath

README.md

@@ -5,13 +5,14 @@
 
 ### Difference from original skript-db
 - Fixed local variables disappearance in newer Skript versions (very hacky fix, but it works, so that's good!)
-- Thread-pool size is now automatically increasing on demand with use of CachedThreadPool, instead of a fixed hard-coded number
 - Uses newer versions of dependencies (Increased performance and security)
 - Replaced `synchronously execute` with `quickly execute`, which allows to speed up queries by 50ms with some risk
-- SQL Driver is configurable
+- If a sql query is detected to be running on non-main thread, it becomes synchronous automatically
+- SQL Driver is configurable both in config and in database connection, comes with shaded MariaDB and PostgreSQL drivers
 - A few variable type related bugs fixed
 - Uses Java 11 instead of Java 8
 
+
 ### Installation
 1. Use 1.8+ Minecraft server version.
 2. Use Skript 2.5+ (1.8 Skript fork is needed if you're using 1.8)
@@ -21,15 +22,23 @@
 Stores the connection information for a data source. This should be saved to a variable in a
  `script load` event or manually through an effect command.
 
- The url format for your database may vary! The example provided uses a MySQL database.
+ The url format for your database may vary depending on database you are using. 
+ MariaDB/PostgreSQL users: make sure to check `config.yml` to use the correct driver.
 #### Syntax
 ```
-[the] data(base|[ ]source) [(of|at)] %string%
+[the] data(base|[ ]source) [(of|at)] %string% [with [a] [max[imum]] [connection] life[ ]time of %timespan%] [[(using|with)] [a] driver %-string%]
 ```
 
 #### Examples
 ```
 set {sql} to the database "mysql://localhost:3306/mydatabase?user=admin&password=12345&useSSL=false"
+set {sql} to the database "mariadb://localhost:3306/mydatabase?user=admin&password=12345&useSSL=false"
+set {sql} to the database "postgresql://localhost:3306/mydatabase?user=admin&password=12345&ssl=false"
+set {sql} to the database "sqlite:database.db"
+
+# Extra parameters:
+set {sql} to the database "postgresql://localhost:3306/mydatabase?user=admin&password=12345&ssl=false" with a maximum connection lifetime of 30 minutes
+set {sql} to the database "postgresql://localhost:3306/mydatabase?user=admin&password=12345&ssl=false" with a maximum connection lifetime of 30 minutes using driver "org.postgresql.Driver"
 ```
 
 ---
@@ -71,6 +80,7 @@ Stores the error from the last executed statement, if there was one.
 
 ### Expression `Unsafe Expression` => `text`
 Opts out of automatic SQL injection protection for a specific expression in a statement.
+Note: If using PostgreSQL, this will always be needed, due to skript-db not supporting SQL injection protection for PostgreSQL currently.
 #### Syntax
 ```
 unsafe %text%
@@ -84,6 +94,18 @@ execute "select %unsafe {columns variable}% from %{table variable}%" in {sql}
 execute unsafe {fully dynamic query} in {sql}
 ```
 
+#### FAQ: How to return sql data in a function?
+You can't because functions don't allow delays, but you can use skript-reflect sections for this:
+```
+on load:
+	create new section stored in {-section::getPlayersFromDatabase}:
+		execute "SELECT uuid FROM table" in {-sql} and store the result in {_result::*}
+		return {_result::uuid::*}
+command /showplayers [<text>]:
+	trigger:
+		run section {-section::getPlayersFromDatabase} async and store result in {_uuids::*} and wait
+		send "%{_uuids::*}%"
+```
 ---
 ### Configuration
 plugins/skript-db/config.yml

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.btk5h</groupId>
     <artifactId>skript-db</artifactId>
-    <version>1.3.7</version>
+    <version>1.4.0</version>
     <packaging>jar</packaging>
 
     <repositories>
@@ -27,8 +27,8 @@
             <url>https://repo.destroystokyo.com/repository/maven-public/</url>
         </repository>
         <repository>
-            <id>sk89q</id>
+            <id>skript</id>
-            <url>http://maven.sk89q.com/repo</url>
+            <url>https://repo.skriptlang.org/releases</url>
         </repository>
     </repositories>
 
@@ -45,8 +45,8 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.6.1</version>
                 <configuration>
-                    <source>11</source>
+                    <source>17</source>
-                    <target>11</target>
+                    <target>17</target>
                     <encoding>UTF-8</encoding>
                 </configuration>
             </plugin>
@@ -93,14 +93,21 @@
         <dependency>
             <groupId>com.github.SkriptLang</groupId>
             <artifactId>Skript</artifactId>
-            <version>2.6-beta3</version>
+            <version>2.6.1</version>
             <scope>provided</scope>
         </dependency>
         <!-- https://mvnrepository.com/artifact/org.mariadb.jdbc/mariadb-java-client -->
         <dependency>
             <groupId>org.mariadb.jdbc</groupId>
             <artifactId>mariadb-java-client</artifactId>
-            <version>3.0.3</version>
+            <version>3.1.2</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.postgresql/postgresql -->
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>42.6.0</version>
             <scope>compile</scope>
         </dependency>
 

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

@@ -73,8 +73,14 @@ public final class SkriptDB extends JavaPlugin {
       }
       try {
         if (out == null) return;
-        out.write("# Only change this if you wish to use a different driver than Java's default, like MariaDB driver.\n");
+
-        out.write("# If you use MariaDB, its driver is shaded together with skript-db, so you can just specify:" + "\"org.mariadb.jdbc.Driver\"" + ".\n");
+        out.write("# How many connections can be awaited for simultaneously, may be useful to increase if SQL database is hosted on a separate machine to account for ping.\n");
+        out.write("# If it is hosted within the same machine, set it to the count of cores your processor has or the count of threads your processor can process at once.\n");
+        out.write("thread-pool-size: " + (Runtime.getRuntime().availableProcessors() + 2) + "\n");
+        out.write("# How long SQL connections should be kept alive in HikariCP. Default: 1800000 (30 minutes)");
+        out.write("max-connection-lifetime: 1800000");
+        out.write("# Only change this if you wish to use a different driver than Java's default, like MariaDB/PostgreSQL driver.\n");
+        out.write("# If you use MariaDB or PostgreSQL, its driver is shaded together with skript-db, so you can just specify:" + "\"org.mariadb.jdbc.Driver\"" + " or " + "\"org.postgresql.Driver\"" + ".\n");
         out.write("sql-driver-class-name: " + "\"default\"" + "\n");
       } catch (IOException e) {
         e.printStackTrace();

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

@@ -1,61 +1,94 @@
 package com.btk5h.skriptdb;
 
-import ch.njol.skript.Skript;
-import ch.njol.skript.lang.Expression;
-import ch.njol.skript.lang.VariableString;
-
 import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.Optional;
 
+import org.bukkit.event.Event;
+
+import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.VariableString;
+import ch.njol.skript.lang.parser.ParserInstance;
+
 public class SkriptUtil {
 
-  private static final Field STRING;
+    private static final Field STRING;
-  private static final Field EXPR;
+    private static final Field EXPR;
 
-  static {
+    static {
-    Field _FIELD = null;
+        STRING = tryGetOldStringField()
-    try {
+                .or(() -> tryGetNewStringField())
-      _FIELD = VariableString.class.getDeclaredField("string");
+                .orElseGet(() -> {
-      _FIELD.setAccessible(true);
+                    Skript.error("Skript's 'string' field could not be resolved.");
-    } catch (NoSuchFieldException e) {
+                    return null;
-      Skript.error("Skript's 'string' field could not be resolved.");
+                });
-      e.printStackTrace();
-    }
-    STRING = _FIELD;
 
-    try {
+        Field f = null;
-      Optional<Class<?>> expressionInfo = Arrays.stream(VariableString.class.getDeclaredClasses())
+        try {
-          .filter(cls -> cls.getSimpleName().equals("ExpressionInfo"))
+            Optional<Class<?>> expressionInfo = Arrays.stream(VariableString.class.getDeclaredClasses())
-          .findFirst();
+                    .filter(cls -> cls.getSimpleName().equals("ExpressionInfo"))
-      if (expressionInfo.isPresent()) {
+                    .findFirst();
-        Class<?> expressionInfoClass = expressionInfo.get();
+            if (expressionInfo.isPresent()) {
-        _FIELD = expressionInfoClass.getDeclaredField("expr");
+                Class<?> expressionInfoClass = expressionInfo.get();
-        _FIELD.setAccessible(true);
+                f = expressionInfoClass.getDeclaredField("expr");
-      } else {
+                f.setAccessible(true);
-        Skript.error("Skript's 'ExpressionInfo' class could not be resolved.");
+            } else {
-      }
+                Skript.error("Skript's 'ExpressionInfo' class could not be resolved.");
-    } catch (NoSuchFieldException e) {
+            }
-      e.printStackTrace();
+        } catch (NoSuchFieldException e) {
-      Skript.error("Skript's 'expr' field could not be resolved.");
+            e.printStackTrace();
+            Skript.error("Skript's 'expr' field could not be resolved.");
+        }
+        EXPR = f;
     }
-    EXPR = _FIELD;
-  }
 
-  public static Object[] getTemplateString(VariableString vs) {
+    public static Object[] getTemplateString(VariableString vs) {
-    try {
+        try {
-      return (Object[]) STRING.get(vs);
+            return (Object[]) STRING.get(vs);
-    } catch (IllegalAccessException e) {
+        } catch (IllegalAccessException e) {
-      throw new RuntimeException(e);
+            throw new RuntimeException(e);
+        }
     }
-  }
 
-  public static Expression<?> getExpressionFromInfo(Object o) {
+    public static Expression<?> getExpressionFromInfo(Object o) {
-    try {
+        try {
-      return (Expression<?>) EXPR.get(o);
+            return (Expression<?>) EXPR.get(o);
-    } catch (IllegalAccessException e) {
+        } catch (IllegalAccessException e) {
-      throw new RuntimeException(e);
+            throw new RuntimeException(e);
+        }
+    }
+    
+    @SuppressWarnings("deprecation")
+	public static boolean isCurrentEvent(Class<? extends Event> event) {
+        try {
+            Class.forName("ch.njol.skript.lang.parser.ParserInstance");
+            return ParserInstance.get().isCurrentEvent(event);
+        } catch (ClassNotFoundException e) {
+            return ScriptLoader.isCurrentEvent(event);
+        }
+    }
+    
+    
+    private static Optional<Field> tryGetOldStringField() {
+        try {
+            Field f = VariableString.class.getDeclaredField("string");
+            f.setAccessible(true);
+            return Optional.of(f);
+        } catch (NoSuchFieldException e) {
+            return Optional.empty();
+        }
+    }
+    
+    private static Optional<Field> tryGetNewStringField() {
+        try {
+            Field f = VariableString.class.getDeclaredField("strings");
+            f.setAccessible(true);
+            return Optional.of(f);
+        } catch (NoSuchFieldException e) {
+            return Optional.empty();
+        }
     }
-  }
 
 }

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/events/SQLQueryCompleteEvent.java

@@ -4,32 +4,26 @@ import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
 
 public class SQLQueryCompleteEvent extends Event {
-    private final static HandlerList HANDLERS = new HandlerList();
+    
+	private static final HandlerList HANDLERS = new HandlerList();
+	
     private final String argument;
 
     public SQLQueryCompleteEvent(String argument) {
         super(true);
         this.argument = argument;
-        //  this.variables = variables;
-    }
-
-    public static HandlerList getHandlerList() {
-        return HANDLERS;
-    }
-
-    @Override
-    public String getEventName() {
-        return super.getEventName();
     }
 
     @Override
     public HandlerList getHandlers() {
-        return HANDLERS;
+        return getHandlerList();
     }
 
     public String getQuery() {
         return argument;
     }
 
-    //  public String getVariables() {return;}
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
 }

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

@@ -1,30 +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.util.*;
+import java.sql.Statement;
+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
@@ -44,131 +65,91 @@ import java.util.concurrent.Executors;
  * @since 0.1.0
  */
 public class EffExecuteStatement extends Effect {
-    private static final ExecutorService threadPool =
+    private static final ExecutorService threadPool = Executors.newFixedThreadPool(SkriptDB.getInstance().getConfig().getInt("thread-pool-size", 10));
-            Executors.newCachedThreadPool();
+    private static final Pattern ARGUMENT_PLACEHOLDER = Pattern.compile("(?<!\\\\)\\?");
     static String lastError;
 
     static {
         Skript.registerEffect(EffExecuteStatement.class,
-                "execute %string% (in|on) %datasource% " +
+                "[quickly:quickly] execute %string% (in|on) %datasource% " +
-                        "[and store [[the] (output|result)[s]] (to|in) [the] [var[iable]] %-objects%]", "quickly execute %string% (in|on) %datasource% " +
+                        "[with arg[ument][s] %-objects%] [and store [[the] [keys:generated keys] (output|result)[s]] (to|in) [the] [var[iable]] %-objects%]");
-                        "[and store [[the] (output|result)[s]] (to|in) [the] [var[iable]] %-objects%]");
     }
 
     private Expression<String> query;
     private Expression<HikariDataSource> dataSource;
-    private VariableString var;
+    private Expression<Object> queryArguments;
+    private VariableString resultVariableName;
     private boolean isLocal;
     private boolean isList;
-    private boolean isSync;
+    private boolean quickly;
-
+    private boolean generatedKeys;
-    private void continueScriptExecution(Event e, Object populatedVariables) {
+    private boolean isSync = false;
-        lastError = null;
-        if (populatedVariables instanceof String) {
-            lastError = (String) populatedVariables;
-        } else {
-
-            if (getNext() != null) {
-                ((Map<String, Object>) populatedVariables).forEach((name, value) -> setVariable(e, name, value));
-            }
-        }
-        TriggerItem.walk(getNext(), e);
-    }
 
     @Override
     protected void execute(Event e) {
         DataSource ds = dataSource.getSingle(e);
-        Pair<String, List<Object>> query = parseQuery(e);
-        String baseVariable = var != null ? var.toString(e).toLowerCase(Locale.ENGLISH) : null;
         //if data source isn't set
-        if (ds == null) return;
+        if (ds == null) {
-
+            return;
-        boolean sync = !Bukkit.isPrimaryThread();
+        }
-
+        Pair<String, List<Object>> parsedQuery = parseQuery(e);
-        //if current thread is not main thread, then make this query to not have delays
+        String baseVariable = resultVariableName != null ? resultVariableName.toString(e).toLowerCase(Locale.ENGLISH) : null;
         
         Object locals = Variables.removeLocals(e);
 
         //execute SQL statement
-
+        if (Bukkit.isPrimaryThread()) {
-        CompletableFuture<Object> sql = null;
+            CompletableFuture.supplyAsync(() -> executeStatement(ds, baseVariable, parsedQuery), threadPool)
-        Object resources = null;
+                    .whenComplete((resources, err) -> {
-        if (!sync) {
+                        //handle last error syntax data
-            sql = CompletableFuture.supplyAsync(() -> executeStatement(ds, baseVariable, query), threadPool);
+                        resetLastSQLError();
+                        if (err instanceof CompletionException && err.getCause() instanceof SkriptDBQueryException) {
+                            setLastSQLError(err.getCause().getMessage());
+                        }
+                        //if local variables are present
+                        //bring back local variables
+                        //populate SQL data into variables
+                        if (!quickly) {
+                            Bukkit.getScheduler().runTask(SkriptDB.getInstance(),
+                                    () -> postExecution(e, locals, resources));
+                        } else {
+                            postExecution(e, locals, resources);
+                        }
+                    });
+            // sync executed SQL query, same as above, just sync
         } else {
-            resources = executeStatement(ds, baseVariable, query);
+            isSync = true;
-        }
+            Map<String, Object> resources = null;
-
+            resetLastSQLError();
-        //when SQL statement is completed
+            try {
-        boolean finalSync = sync;
+                resources = executeStatement(ds, baseVariable, parsedQuery);
-        if (sql != null) {
+            } catch (SkriptDBQueryException err) {
-            sql.whenComplete((res, err) -> {
-                if (err != null) {
-                    err.printStackTrace();
-                }
                 //handle last error syntax data
-                lastError = null;
+                setLastSQLError(err.getMessage());
-                if (res instanceof String) {
-                    lastError = (String) res;
-                }
-                if (getNext() != null) {
-                    //if local variables are present
-                    //bring back local variables
-                    //populate SQL data into variables
-                    if (isSync || finalSync) {
-                        if (locals != null) {
-                            Variables.setLocalVariables(e, locals);
-                        }
-                        if (!(res instanceof String)) {
-                            ((Map<String, Object>) res).forEach((name, value) -> setVariable(e, name, value));
-                        }
-                        TriggerItem.walk(getNext(), e);
-                        Variables.removeLocals(e);
-                    } else {
-                        Bukkit.getScheduler().runTask(SkriptDB.getInstance(), () -> {
-                            if (locals != null) {
-                                Variables.setLocalVariables(e, locals);
-                            }
-                            if (!(res instanceof String)) {
-                                ((Map<String, Object>) res).forEach((name, value) -> setVariable(e, name, value));
-                            }
-                            TriggerItem.walk(getNext(), e);
-                            //the line below is required to prevent memory leaks
-                            //no functionality difference notice with it being removed from my test, but the memory gets filled with leaks
-                            //so it must be kept
-                            Variables.removeLocals(e);
-                        });
-                    }
-                }
-            });
-        // sync executed SQL query, same as above, just sync
-        } else {
-            //handle last error syntax data
-            lastError = null;
-            if (resources instanceof String) {
-                lastError = (String) resources;
-            }
-            if (getNext() != null) {
-                //if local variables are present
-                //bring back local variables
-                //populate SQL data into variables
-                if (locals != null) {
-                    Variables.setLocalVariables(e, locals);
-                }
-                if (!(resources instanceof String)) {
-                    ((Map<String, Object>) resources).forEach((name, value) -> setVariable(e, name, value));
-                }
-                TriggerItem.walk(getNext(), e);
-                Variables.removeLocals(e);
             }
+            //if local variables are present
+            //bring back local variables
+            //populate SQL data into variables
+            postExecution(e, locals, resources);
         }
     }
     
+    private void postExecution(Event e, Object locals, Map<String, Object> resources) {
+        if (locals != null && getNext() != null) {
+            Variables.setLocalVariables(e, locals);
+        }
+        if (resources != null) {
+            resources.forEach((name, value) -> setVariable(e, name, value));
+        }
+        TriggerItem.walk(getNext(), e);
+        //the line below is required to prevent memory leaks
+        Variables.removeLocals(e);
+    }
+
     @Override
     protected TriggerItem walk(Event e) {
         debug(e, true);
-        //I think no longer needed as of 1.3.0, uncomment if something breaks
+        if (!quickly || !isSync) {
-        if (!isSync) {
             Delay.addDelayedEvent(e);
         }
         execute(e);
@@ -176,142 +157,160 @@ public class EffExecuteStatement extends Effect {
     }
 
     private Pair<String, List<Object>> parseQuery(Event e) {
-        if (!(query instanceof VariableString)) {
+        if (queryArguments != null) {
-            return new Pair<>(query.getSingle(e), null);
+            Object[] args = queryArguments.getArray(e);
-        }
+            String queryString = query.getSingle(e);
-        VariableString q = (VariableString) query;
+            int queryArgCount = (int) ARGUMENT_PLACEHOLDER.matcher(queryString).results().count();
-        if (q.isSimple()) {
+            if (queryArgCount != args.length) {
-            return new Pair<>(q.toString(e), null);
+                Skript.warning(String.format("Your query has %d question marks, but you provided %d arguments. (%s) [%s]",
+                        queryArgCount,
+                        args.length,
+                        queryArguments.toString(e, true),
+                        Optional.ofNullable(getTrigger())
+                                .map(Trigger::getDebugLabel)
+                                .orElse("unknown")));
+                args = Arrays.copyOf(args, queryArgCount);
+            }
+            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 queryString && !queryString.isSimple()) {
+            return parseVariableQuery(e, (VariableString) query);
         }
+        return new Pair<>(query.getSingle(e), null);
+    }
     
+    private Pair<String, List<Object>> parseVariableQuery(Event e, VariableString varQuery) {
         StringBuilder sb = new StringBuilder();
-        List<Object> parameters = new ArrayList<>();
+        List<Object> parameters = new LinkedList<>();
-        Object[] objects = SkriptUtil.getTemplateString(q);
+        Object[] objects = SkriptUtil.getTemplateString(varQuery);
         
         for (int i = 0; i < objects.length; i++) {
-            Object o = objects[i];
+            if (objects[i] instanceof String) {
-            if (o instanceof String) {
+                sb.append(objects[i]);
-                sb.append(o);
             } else {
-                Expression<?> expr;
+                Expression<?> expr = objects[i] instanceof Expression ? (Expression<?>) objects[i] : SkriptUtil.getExpressionFromInfo(objects[i]);
-                if (o instanceof Expression)
+                boolean standaloneString = isStandaloneString(objects, i);
-                    expr = (Expression<?>) o;
-                else
-                    expr = SkriptUtil.getExpressionFromInfo(o);
-
-                String before = getString(objects, i - 1);
-                String after = getString(objects, i + 1);
-                boolean standaloneString = false;
-
-                if (before != null && after != null) {
-                    if (before.endsWith("'") && after.endsWith("'")) {
-                        standaloneString = true;
-                    }
-                }
-
                 Object expressionValue = expr.getSingle(e);
 
-                if (expr instanceof ExprUnsafe) {
+                Pair<String, Object> toAppend = parseExpressionQuery(expr, expressionValue, standaloneString);
-                    sb.append(expressionValue);
+                sb.append(toAppend.getFirst());
-
+                if (toAppend.getSecond() != null) {
-                    if (standaloneString && expressionValue instanceof String) {
+                    parameters.add(toAppend.getSecond());
-                        String rawExpression = ((ExprUnsafe) expr).getRawExpression();
-                        Skript.warning(
-                                String.format("Unsafe may have been used unnecessarily. Try replacing 'unsafe %1$s' with %1$s",
-                                        rawExpression));
-                    }
-                } else {
-                    parameters.add(expressionValue);
-                    sb.append('?');
-
-                    if (standaloneString) {
-                        Skript.warning("Do not surround expressions with quotes!");
-                    }
                 }
             }
         }
         return new Pair<>(sb.toString(), parameters);
     }
     
-    private Object executeStatement(DataSource ds, String baseVariable, Pair<String, List<Object>> query) {
+    private Pair<String, Object> parseExpressionQuery(Expression<?> expr, Object expressionValue, boolean standaloneString) {
-        if (ds == null) {
+        if (expr instanceof ExprUnsafe unsafe) {
-            return "Data source is not set";
+            if (standaloneString && expressionValue instanceof String) {
+                Skript.warning(
+                        String.format("Unsafe may have been used unnecessarily. Try replacing 'unsafe %1$s' with %1$s",
+                        		unsafe.getRawExpression()));
+            }
+            return new Pair<>((String) expressionValue, null);
+        } else {
+            if (standaloneString) {
+                Skript.warning("Do not surround expressions with quotes!");
+            }
+            return new Pair<>("?", expressionValue);
         }
-        Map<String, Object> variableList = new HashMap<>();
+    }
-        try (Connection conn = ds.getConnection();
-             PreparedStatement stmt = createStatement(conn, query)) {
 
-            boolean hasResultSet = stmt.execute();
+    private Map<String, Object> executeStatement(DataSource ds, String baseVariable, Pair<String, List<Object>> query) throws SkriptDBQueryException {
+        if (ds == null) {
+            throw new SkriptDBQueryException("Data source is not set");
+        }
+        try (Connection conn = ds.getConnection()) {
+            try (PreparedStatement stmt = createStatement(conn, query)) {
+                boolean hasResultSet = stmt.execute();
 
-            if (baseVariable != null) {
+                if (baseVariable != null) {
-                if (isList) {
+                    return processBaseVariable(baseVariable, stmt, hasResultSet);
-                    baseVariable = baseVariable.substring(0, baseVariable.length() - 1);
-                }
-
-                if (hasResultSet) {
-                    CachedRowSet crs = SkriptDB.getRowSetFactory().createCachedRowSet();
-                    crs.populate(stmt.getResultSet());
-
-                    if (isList) {
-                        ResultSetMetaData meta = crs.getMetaData();
-                        int columnCount = meta.getColumnCount();
-
-                        for (int i = 1; i <= columnCount; i++) {
-                            String label = meta.getColumnLabel(i);
-                            variableList.put(baseVariable + label, label);
-                        }
-
-                        int rowNumber = 1;
-                        try {
-                            while (crs.next()) {
-                                for (int i = 1; i <= columnCount; i++) {
-                                    variableList.put(baseVariable + meta.getColumnLabel(i).toLowerCase(Locale.ENGLISH)
-                                            + Variable.SEPARATOR + rowNumber, crs.getObject(i));
-                                }
-                                rowNumber++;
-                            }
-                        } catch (SQLException ex) {
-                            return ex.getMessage();
-                        }
-                    } else {
-                        crs.last();
-                        variableList.put(baseVariable, crs.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
-                    variableList.put(baseVariable, stmt.getUpdateCount());
                 }
+                return Map.of();
             }
         } catch (SQLException ex) {
-            return ex.getMessage();
+            throw new SkriptDBQueryException(ex.getMessage());
+        }
+    }
+    
+    private Map<String, Object> processBaseVariable(String baseVariable, PreparedStatement stmt, boolean hasResultSet) throws SQLException {
+        if (isList) {
+            baseVariable = baseVariable.substring(0, baseVariable.length() - 1);
+        }
+
+        if (hasResultSet) {
+        	// TODO: Check if caching is even needed
+            //CachedRowSet crs = SkriptDB.getRowSetFactory().createCachedRowSet();
+            ResultSet rs = generatedKeys ? stmt.getGeneratedKeys() : stmt.getResultSet();
+            //crs.populate(rs);
+
+            if (isList) {
+                return fetchQueryResultSet(rs, baseVariable);
+            } else {
+            	rs.last();
+                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
+            return Map.of(baseVariable, stmt.getUpdateCount());
+        }
+        return Map.of();
+    }
+    
+    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++) {
+            	Object obj = wrappers[i - 1].asSkript(crs, i);
+                variableList.put(baseVariable + columnNames[i - 1].toLowerCase(Locale.ENGLISH)
+                        + Variable.SEPARATOR + rowNumber, obj);
+            }
+            rowNumber++;
         }
         return variableList;
     }
 
     private PreparedStatement createStatement(Connection conn, Pair<String, List<Object>> query) throws SQLException {
-        PreparedStatement stmt = conn.prepareStatement(query.getFirst());
+        PreparedStatement stmt = generatedKeys ? 
-        List<Object> parameters = query.getSecond();
+                conn.prepareStatement(query.getFirst(), Statement.RETURN_GENERATED_KEYS)
-
+                : conn.prepareStatement(query.getFirst(), Statement.NO_GENERATED_KEYS);
-        if (parameters != null) {
+        if (query.getSecond() != null) {
-            for (int i = 0; i < parameters.size(); i++) {
+            Iterator<Object> iter = query.getSecond().iterator();
-                stmt.setObject(i + 1, parameters.get(i));
+            for (int i = 1; iter.hasNext(); i++) {
+                stmt.setObject(i, iter.next());
             }
         }
 
         return stmt;
     }
     
+    private boolean isStandaloneString(Object[] objects, int index) {
+        String before = getString(objects, index - 1);
+        String after = getString(objects, index + 1);
+        return before != null && before.endsWith("'") && after != null && after.endsWith("'");
+    }
+
     private String getString(Object[] objects, int index) {
-        if (index < 0 || index >= objects.length) {
+        if (index >= 0 && index < objects.length && objects[index] instanceof String str) {
-            return null;
+            return str;
         }
-
-        Object object = objects[index];
-
-        if (object instanceof String) {
-            return (String) object;
-        }
-
         return null;
     }
 
@@ -319,13 +318,13 @@ public class EffExecuteStatement extends Effect {
 
         //fix mediumblob and similar column types, so they return a String correctly
         if (obj != null) {
-            if (obj.getClass().getName().equals("[B")) {
+            if (obj instanceof byte[] bytes) {
-                obj = new String((byte[]) obj);
+                obj = new String(bytes);
 
                 //in some servers instead of being byte array, it appears as SerialBlob (depends on mc version, 1.12.2 is bvte array, 1.16.5 SerialBlob)
-            } else if (obj instanceof SerialBlob) {
+            } else if (obj instanceof SerialBlob blob) {
                 try {
-                    obj = new String(((SerialBlob) obj).getBinaryStream().readAllBytes());
+                    obj = new String(blob.getBinaryStream().readAllBytes());
                 } catch (IOException | SerialException ex) {
                     ex.printStackTrace();
                 }
@@ -334,6 +333,14 @@ public class EffExecuteStatement extends Effect {
         Variables.setVariable(name.toLowerCase(Locale.ENGLISH), obj, e, isLocal);
     }
     
+    private static void resetLastSQLError() {
+        lastError = null;
+    }
+    
+    private static void setLastSQLError(String error) {
+        lastError = error;
+    }
+
     @Override
     public String toString(Event e, boolean debug) {
         return "execute " + query.toString(e, debug) + " in " + dataSource.toString(e, debug);
@@ -341,8 +348,7 @@ public class EffExecuteStatement extends Effect {
 
     @SuppressWarnings("unchecked")
     @Override
-    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed,
+    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
-                        SkriptParser.ParseResult parseResult) {
         Expression<String> statementExpr = (Expression<String>) exprs[0];
         if (statementExpr instanceof VariableString || statementExpr instanceof ExprUnsafe) {
             query = statementExpr;
@@ -353,17 +359,35 @@ public class EffExecuteStatement extends Effect {
             return false;
         }
         dataSource = (Expression<HikariDataSource>) exprs[1];
-        Expression<?> expr = exprs[2];
+        if (exprs[2] != null) {
-        isSync = matchedPattern == 1;
+            if (query instanceof VariableString queryString && !queryString.isSimple()) {
-        if (expr instanceof Variable) {
+                Skript.warning("Your query string contains expresions, but you've also provided query arguments. Consider using `unsafe` keyword before your query.");
-            Variable<?> varExpr = (Variable<?>) expr;
+            }
-            var = varExpr.getName();
+            queryArguments = (Expression<Object>) exprs[2];
+        }
+        Expression<?> resultHolder = exprs[3];
+        quickly = parseResult.hasTag("quickly");
+        if (resultHolder instanceof Variable) {
+            Variable<?> varExpr = (Variable<?>) resultHolder;
+            resultVariableName = varExpr.getName();
             isLocal = varExpr.isLocal();
             isList = varExpr.isList();
-        } else if (expr != null) {
+            generatedKeys = parseResult.hasTag("keys");
-            Skript.error(expr + " is not a variable");
+        } else if (resultHolder != null) {
+            Skript.error(resultHolder + " is not a variable");
             return false;
         }
         return true;
     }
+    
+    public static class SkriptDBQueryException extends RuntimeException {
+
+        private static final long serialVersionUID = -1869895286406538884L;
+        
+        public SkriptDBQueryException(String message) {
+            super(message);
+        }
+        
+    }
+    
 }

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

@@ -22,7 +22,7 @@ import java.util.Map;
  *
  * @name Data Source
  * @index -1
- * @pattern [the] data(base|[ ]source) [(of|at)] %string% [with [a] [max[imum]] [connection] life[ ]time of %timespan%]"
+ * @pattern [the] data(base|[ ]source) [(of|at)] %string% [with [a] [max[imum]] [connection] life[ ]time of %timespan%] [[(using|with)] [a] driver %-string%]"
  * @return datasource
  * @example set {sql} to the database "mysql://localhost:3306/mydatabase?user=admin&password=12345&useSSL=false"
  * @since 0.1.0
@@ -32,12 +32,14 @@ public class ExprDataSource extends SimpleExpression<HikariDataSource> {
 
     static {
         Skript.registerExpression(ExprDataSource.class, HikariDataSource.class,
-                ExpressionType.COMBINED, "[the] data(base|[ ]source) [(of|at)] %string% " +
+                ExpressionType.COMBINED, "[the] data(base|[ ]source) [(of|at)] %string% "
-                        "[with [a] [max[imum]] [connection] life[ ]time of %-timespan%]");
+                		+ "[with [a] [max[imum]] [connection] life[ ]time of %-timespan%] "
+                		+ "[[(using|with)] [a] driver %-string%]");
     }
 
     private Expression<String> url;
     private Expression<Timespan> maxLifetime;
+    private Expression<String> driver;
 
     @Override
     protected HikariDataSource[] get(Event e) {
@@ -55,11 +57,18 @@ public class ExprDataSource extends SimpleExpression<HikariDataSource> {
         }
 
         HikariDataSource ds = new HikariDataSource();
+        ds.setMaximumPoolSize(SkriptDB.getInstance().getConfig().getInt("thread-pool-size", 10));
 
-        //allow specifying of own sql driver class name
+        // 30 minutes by default
-        if (!SkriptDB.getInstance().getConfig().getString("sql-driver-class-name", "default").equals("default")) {
+        ds.setMaxLifetime(SkriptDB.getInstance().getConfig().getInt("max-connection-lifetime", 1800000));
+
+        // Allow specifying of own sql driver class name
+        if (driver != null && driver.getSingle(e) != null) {
+            ds.setDriverClassName(driver.getSingle(e));
+        } else if (!SkriptDB.getInstance().getConfig().getString("sql-driver-class-name", "default").equals("default")) {
             ds.setDriverClassName(SkriptDB.getInstance().getConfig().getString("sql-driver-class-name"));
         }
+
         ds.setJdbcUrl(jdbcUrl);
 
         if (maxLifetime != null) {
@@ -92,10 +101,10 @@ public class ExprDataSource extends SimpleExpression<HikariDataSource> {
 
     @SuppressWarnings("unchecked")
     @Override
-    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed,
+    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
-                        SkriptParser.ParseResult parseResult) {
         url = (Expression<String>) exprs[0];
         maxLifetime = (Expression<Timespan>) exprs[1];
+        driver = (Expression<String>) exprs[2];
         return true;
     }
 }

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

@@ -1,6 +1,10 @@
 package com.btk5h.skriptdb.skript;
 
-import ch.njol.skript.ScriptLoader;
+import org.bukkit.event.Event;
+
+import com.btk5h.skriptdb.SkriptUtil;
+import com.btk5h.skriptdb.events.SQLQueryCompleteEvent;
+
 import ch.njol.skript.Skript;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.ExpressionType;
@@ -8,8 +12,6 @@ import ch.njol.skript.lang.SkriptParser;
 import ch.njol.skript.lang.util.SimpleExpression;
 import ch.njol.skript.log.ErrorQuality;
 import ch.njol.util.Kleenean;
-import com.btk5h.skriptdb.events.SQLQueryCompleteEvent;
-import org.bukkit.event.Event;
 
 /**
  * Stores the error from the last executed statement, if there was one.
@@ -28,8 +30,8 @@ public class ExprSQLQuery extends SimpleExpression<String> {
 
     @Override
     protected String[] get(Event e) {
-        if (e instanceof SQLQueryCompleteEvent) {
+        if (e instanceof SQLQueryCompleteEvent sqlEvent) {
-            return new String[]{((SQLQueryCompleteEvent) e).getQuery()};
+            return new String[]{ sqlEvent.getQuery() };
         }
         return null;
     }
@@ -51,7 +53,7 @@ public class ExprSQLQuery extends SimpleExpression<String> {
 
     @Override
     public boolean init(final Expression<?>[] expressions, final int matchedPattern, final Kleenean isDelayed, final SkriptParser.ParseResult parseResult) {
-        if (!ScriptLoader.isCurrentEvent(SQLQueryCompleteEvent.class)) {
+        if (!SkriptUtil.isCurrentEvent(SQLQueryCompleteEvent.class)) {
             Skript.error("Cannot use 'sql query' outside of a complete of sql query event", ErrorQuality.SEMANTIC_ERROR);
             return false;
         }

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

@@ -53,8 +53,7 @@ public class ExprUnsafe extends SimpleExpression<String> {
 
     @SuppressWarnings("unchecked")
     @Override
-    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed,
+    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
-                        SkriptParser.ParseResult parseResult) {
         stringExpression = (Expression<String>) exprs[0];
         rawExpression = parseResult.expr.substring("unsafe".length()).trim();
         return true;

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

@@ -30,10 +30,6 @@ public class Types {
                         return o.getJdbcUrl();
                     }
 
-                    @Override
-                    public String getVariableNamePattern() {
-                        return "jdbc:.+";
-                    }
                 })
                 .serializer(new Serializer<HikariDataSource>() {
                     @Override

src/main/resources/plugin.yml

@@ -1,5 +1,5 @@
 name: skript-db
-version: 1.3.5
+version: 1.4.0
 main: com.btk5h.skriptdb.SkriptDB
 depend: [Skript]
 authors: [btk5h, FranKusmiruk, Govindas, TPGamesNL]