12 changed files with 292 additions and 391 deletions
--- a/.gitignore
+++ b/.gitignore
@ -7,19 +7,3 @@
 out/
 target
 compile/
-
-# eclipse specific git ignore
-*.pydevproject
-.project
-.metadata
-bin/**
-tmp/**
-tmp/**/*
-*.tmp
-*.bak
-*.swp
-*~.nib
-local.properties
-.classpath
-.settings/
-.loadpath
--- a/README.md
+++ b/README.md
@ -5,14 +5,13 @@

 ### 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
- 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
+- SQL Driver is configurable
 - 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)
@ -22,23 +21,15 @@
 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 depending on database you are using. 
- MariaDB/PostgreSQL users: make sure to check `config.yml` to use the correct driver.
+ The url format for your database may vary! The example provided uses a MySQL database.
 #### Syntax
 ```
-[the] data(base|[ ]source) [(of|at)] %string% [with [a] [max[imum]] [connection] life[ ]time of %timespan%] [[(using|with)] [a] driver %-string%]
+[the] data(base|[ ]source) [(of|at)] %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"
 ```

 ---
@ -80,7 +71,6 @@ 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%
@ -94,18 +84,6 @@ 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
@ -113,4 +91,4 @@ plugins/skript-db/config.yml
 # Only change this if you wish to use a different driver than Java's default, like MariaDB driver.
 # If you use MariaDB, its driver is shaded together with skript-db, so you can just specify: "org.mariadb.jdbc.Driver"
 sql-driver-class-name: "default"
-```
+```
--- a/pom.xml
+++ b/pom.xml
@ -6,7 +6,7 @@

    <groupId>com.btk5h</groupId>
    <artifactId>skript-db</artifactId>
-    <version>1.4.0</version>
+    <version>1.3.5</version>
    <packaging>jar</packaging>

    <repositories>
@ -19,8 +19,8 @@
            <url>https://jitpack.io</url>
        </repository>
        <repository>
-            <id>mvnrepository</id>
-            <url>https://mvnrepository.com</url>
+            <id>commons-pool2</id>
+            <url>https://mvnrepository.com/artifact/org.apache.commons/commons-pool2</url>
        </repository>
        <repository>
            <id>PaperMC</id>
@ -28,11 +28,7 @@
        </repository>
        <repository>
            <id>sk89q</id>
-            <url>https://maven.sk89q.com/repo</url>
-        </repository>
-        <repository>
-            <id>skript</id>
-            <url>https://repo.skriptlang.org/releases</url>
+            <url>http://maven.sk89q.com/repo</url>
        </repository>
    </repositories>

@ -60,6 +56,7 @@
                <version>3.2.3</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
+                    <minimizeJar>true</minimizeJar>
                </configuration>
                <executions>
                    <execution>
@ -97,21 +94,14 @@
        <dependency>
            <groupId>com.github.SkriptLang</groupId>
            <artifactId>Skript</artifactId>
-            <version>2.6.1</version>
+            <version>2.6-beta3</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.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>
+            <version>3.0.3</version>
            <scope>compile</scope>
        </dependency>

--- a/src/main/java/com/btk5h/skriptdb/SkriptDB.java
+++ b/src/main/java/com/btk5h/skriptdb/SkriptDB.java
@ -73,14 +73,8 @@ public final class SkriptDB extends JavaPlugin {
      }
      try {
        if (out == null) return;
-
-        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("# 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("sql-driver-class-name: " + "\"default\"" + "\n");
      } catch (IOException e) {
        e.printStackTrace();
--- a/src/main/java/com/btk5h/skriptdb/SkriptUtil.java
+++ b/src/main/java/com/btk5h/skriptdb/SkriptUtil.java
@ -1,94 +1,61 @@
 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 EXPR;
+  private static final Field STRING;
+  private static final Field EXPR;

-    static {
-        STRING = tryGetOldStringField()
-                .or(() -> tryGetNewStringField())
-                .orElseGet(() -> {
-                    Skript.error("Skript's 'string' field could not be resolved.");
-                    return null;
-                });
+  static {
+    Field _FIELD = null;
+    try {
+      _FIELD = VariableString.class.getDeclaredField("string");
+      _FIELD.setAccessible(true);
+    } catch (NoSuchFieldException e) {
+      Skript.error("Skript's 'string' field could not be resolved.");
+      e.printStackTrace();
+    }
+    STRING = _FIELD;

-        Field f = null;
-        try {
-            Optional<Class<?>> expressionInfo = Arrays.stream(VariableString.class.getDeclaredClasses())
-                    .filter(cls -> cls.getSimpleName().equals("ExpressionInfo"))
-                    .findFirst();
-            if (expressionInfo.isPresent()) {
-                Class<?> expressionInfoClass = expressionInfo.get();
-                f = expressionInfoClass.getDeclaredField("expr");
-                f.setAccessible(true);
-            } else {
-                Skript.error("Skript's 'ExpressionInfo' class could not be resolved.");
-            }
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-            Skript.error("Skript's 'expr' field could not be resolved.");
-        }
-        EXPR = f;
+    try {
+      Optional<Class<?>> expressionInfo = Arrays.stream(VariableString.class.getDeclaredClasses())
+          .filter(cls -> cls.getSimpleName().equals("ExpressionInfo"))
+          .findFirst();
+      if (expressionInfo.isPresent()) {
+        Class<?> expressionInfoClass = expressionInfo.get();
+        _FIELD = expressionInfoClass.getDeclaredField("expr");
+        _FIELD.setAccessible(true);
+      } else {
+        Skript.error("Skript's 'ExpressionInfo' class could not be resolved.");
+      }
+    } catch (NoSuchFieldException e) {
+      e.printStackTrace();
+      Skript.error("Skript's 'expr' field could not be resolved.");
    }
+    EXPR = _FIELD;
+  }

-    public static Object[] getTemplateString(VariableString vs) {
-        try {
-            return (Object[]) STRING.get(vs);
-        } catch (IllegalAccessException e) {
-            throw new RuntimeException(e);
-        }
+  public static Object[] getTemplateString(VariableString vs) {
+    try {
+      return (Object[]) STRING.get(vs);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException(e);
    }
+  }

-    public static Expression<?> getExpressionFromInfo(Object o) {
-        try {
-            return (Expression<?>) EXPR.get(o);
-        } catch (IllegalAccessException 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();
-        }
+  public static Expression<?> getExpressionFromInfo(Object o) {
+    try {
+      return (Expression<?>) EXPR.get(o);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException(e);
    }
+  }

 }
--- a/src/main/java/com/btk5h/skriptdb/events/SQLQueryCompleteEvent.java
+++ b/src/main/java/com/btk5h/skriptdb/events/SQLQueryCompleteEvent.java
@ -4,26 +4,32 @@ import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;

 public class SQLQueryCompleteEvent extends Event {
-    
-	private static final HandlerList HANDLERS = new HandlerList();
-	
+    private final static 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 getHandlerList();
+        return HANDLERS;
    }

    public String getQuery() {
        return argument;
    }

-    public static HandlerList getHandlerList() {
-        return HANDLERS;
-    }
+    //  public String getVariables() {return;}
 }
--- a/src/main/java/com/btk5h/skriptdb/skript/EffExecuteStatement.java
+++ b/src/main/java/com/btk5h/skriptdb/skript/EffExecuteStatement.java
@ -21,13 +21,10 @@ import java.sql.Connection;
 import java.sql.PreparedStatement;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
-import java.sql.Statement;
 import java.util.*;
 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;

 /**
 * Executes a statement on a database and optionally stores the result in a variable. Expressions
@ -47,91 +44,117 @@ import java.util.regex.Pattern;
 * @since 0.1.0
 */
 public class EffExecuteStatement extends Effect {
-    private static final ExecutorService threadPool = Executors.newFixedThreadPool(SkriptDB.getInstance().getConfig().getInt("thread-pool-size", 10));
-    private static final Pattern ARGUMENT_PLACEHOLDER = Pattern.compile("(?<!\\\\)\\?");
+    private static final ExecutorService threadPool =
+            Executors.newCachedThreadPool();
    static String lastError;

    static {
        Skript.registerEffect(EffExecuteStatement.class,
-                "[quickly: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%]");
+                "execute %string% (in|on) %datasource% " +
+                        "[and store [[the] (output|result)[s]] (to|in) [the] [var[iable]] %-objects%]", "quickly execute %string% (in|on) %datasource% " +
+                        "[and store [[the] (output|result)[s]] (to|in) [the] [var[iable]] %-objects%]");
    }

    private Expression<String> query;
    private Expression<HikariDataSource> dataSource;
-    private Expression<Object> queryArguments;
-    private VariableString resultVariableName;
+    private VariableString var;
    private boolean isLocal;
    private boolean isList;
-    private boolean quickly;
-    private boolean generatedKeys;
-    private boolean isSync = false;
+    private boolean isSync;
+
+    private void continueScriptExecution(Event e, Object populatedVariables) {
+        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;
-        }
-        Pair<String, List<Object>> parsedQuery = parseQuery(e);
-        String baseVariable = resultVariableName != null ? resultVariableName.toString(e).toLowerCase(Locale.ENGLISH) : null;
-        
+        if (ds == null) return;
+
+        boolean sync = !Bukkit.isPrimaryThread();
+
+        //if current thread is not main thread, then make this query to not have delays
+
        Object locals = Variables.removeLocals(e);

        //execute SQL statement
-        if (Bukkit.isPrimaryThread()) {
-            CompletableFuture.supplyAsync(() -> executeStatement(ds, baseVariable, parsedQuery), threadPool)
-		            .whenComplete((resources, err) -> {
-		            	//handle last error syntax data
-		            	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 {
-            isSync = true;
-            Map<String, Object> resources = null;
-            resetLastSQLError();
-            try {
-                resources = executeStatement(ds, baseVariable, parsedQuery);
-			} catch (SkriptDBQueryException err) {
-	            //handle last error syntax data
-				setLastSQLError(err.getMessage());
-			}
-            //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);
+        CompletableFuture<Object> sql =
+                CompletableFuture.supplyAsync(() -> executeStatement(ds, baseVariable, query), threadPool);
+
+        //when SQL statement is completed
+        boolean finalSync = sync;
+        sql.whenComplete((res, err) -> {
+            if (err != null) {
+                err.printStackTrace();
+            }
+
+            //handle last error syntax data
+            lastError = null;
+            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 (!(res instanceof String)) {
+
+                    //also set variables in the sql query complete event
+
+                    //TEMPORARILY DISABLED, AS THIS WOULD WORSEN PERFORMANCE OF THE QUERIES AND NOT BE USED BY MOST PEOPLE.
+                    //I may add config option to enable this later?
+
+                    //SQLQueryCompleteEvent event = new SQLQueryCompleteEvent(this.query.getSingle(e));
+                    //((Map<String, Object>) res).forEach((name, value) -> setVariable(event, name, value));
+                    //SkriptDB.getPlugin(SkriptDB.class).getServer().getPluginManager().callEvent(event);
+                }
+                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);
+                    });
+                }
+            }
+        });
    }

    @Override
    protected TriggerItem walk(Event e) {
        debug(e, true);
-        if (!quickly || !isSync) {
+        //I think no longer needed as of 1.3.0, uncomment if something breaks
+        if (!isSync) {
            Delay.addDelayedEvent(e);
        }
        execute(e);
@ -139,151 +162,142 @@ public class EffExecuteStatement extends Effect {
    }

    private Pair<String, List<Object>> parseQuery(Event e) {
-        if (queryArguments != null) {
-            Object[] args = queryArguments.getArray(e);
-            String queryString = query.getSingle(e);
-            int queryArgCount = (int) ARGUMENT_PLACEHOLDER.matcher(queryString).results().count();
-            if (queryArgCount != args.length) {
-                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);
-            }
-            return new Pair<>(query.getSingle(e), Arrays.asList(args));
-        } else if (query instanceof VariableString && !((VariableString) query).isSimple()) {
-            return parseVariableQuery(e, (VariableString) query);
+        if (!(query instanceof VariableString)) {
+            return new Pair<>(query.getSingle(e), null);
        }
-        return new Pair<>(query.getSingle(e), null);
-    }
-    
-    private Pair<String, List<Object>> parseVariableQuery(Event e, VariableString varQuery) {
+        VariableString q = (VariableString) query;
+        if (q.isSimple()) {
+            return new Pair<>(q.toString(e), null);
+        }
+
        StringBuilder sb = new StringBuilder();
-        List<Object> parameters = new LinkedList<>();
-        Object[] objects = SkriptUtil.getTemplateString(varQuery);
-        
+        List<Object> parameters = new ArrayList<>();
+        Object[] objects = SkriptUtil.getTemplateString(q);
+
        for (int i = 0; i < objects.length; i++) {
-            if (objects[i] instanceof String) {
-                sb.append(objects[i]);
+            Object o = objects[i];
+            if (o instanceof String) {
+                sb.append(o);
            } else {
-                Expression<?> expr = objects[i] instanceof Expression ? (Expression<?>) objects[i] : SkriptUtil.getExpressionFromInfo(objects[i]);
-                boolean standaloneString = isStandaloneString(objects, i);
+                Expression<?> expr;
+                if (o instanceof Expression)
+                    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);

-                Pair<String, Object> toAppend = parseExpressionQuery(expr, expressionValue, standaloneString);
-                sb.append(toAppend.getFirst());
-                if (toAppend.getSecond() != null) {
-                    parameters.add(toAppend.getSecond());
+                if (expr instanceof ExprUnsafe) {
+                    sb.append(expressionValue);
+
+                    if (standaloneString && expressionValue instanceof String) {
+                        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 Pair<String, Object> parseExpressionQuery(Expression<?> expr, Object expressionValue, boolean standaloneString) {
-        if (expr instanceof ExprUnsafe) {
-            if (standaloneString && expressionValue instanceof String) {
-                Skript.warning(
-                        String.format("Unsafe may have been used unnecessarily. Try replacing 'unsafe %1$s' with %1$s",
-                                ((ExprUnsafe) expr).getRawExpression()));
-            }
-            return new Pair<>((String) expressionValue, null);
-        } else {
-            if (standaloneString) {
-                Skript.warning("Do not surround expressions with quotes!");
-            }
-            return new Pair<>("?", expressionValue);
-        }
-    }

-    private Map<String, Object> executeStatement(DataSource ds, String baseVariable, Pair<String, List<Object>> query) throws SkriptDBQueryException {
+    private Object executeStatement(DataSource ds, String baseVariable, Pair<String, List<Object>> query) {
        if (ds == null) {
-        	throw new SkriptDBQueryException("Data source is not set");
+            return "Data source is not set";
        }
-        try (Connection conn = ds.getConnection()) {
-            try (PreparedStatement stmt = createStatement(conn, query)) {
-                boolean hasResultSet = stmt.execute();
+        Map<String, Object> variableList = new HashMap<>();
+        try (Connection conn = ds.getConnection();
+             PreparedStatement stmt = createStatement(conn, query)) {

-                if (baseVariable != null) {
-                    return processBaseVariable(baseVariable, stmt, hasResultSet);
+            boolean hasResultSet = stmt.execute();
+
+            if (baseVariable != null) {
+                if (isList) {
+                    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) {
-            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) {
-            CachedRowSet crs = SkriptDB.getRowSetFactory().createCachedRowSet();
-            crs.populate(generatedKeys ? stmt.getGeneratedKeys() : stmt.getResultSet());
-
-            if (isList) {
-                return fetchQueryResultSet(crs, baseVariable);
-            } else {
-                crs.last();
-                return Map.of(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
-            return Map.of(baseVariable, stmt.getUpdateCount());
-        }
-        return Map.of();
-    }
-    
-    private Map<String, Object> fetchQueryResultSet(CachedRowSet crs, String baseVariable) throws SQLException {
-        Map<String, Object> variableList = new HashMap<>();
-        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;
-        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++;
+            return ex.getMessage();
        }
        return variableList;
    }

    private PreparedStatement createStatement(Connection conn, Pair<String, List<Object>> query) throws SQLException {
-        PreparedStatement stmt = generatedKeys ? 
-        		conn.prepareStatement(query.getFirst(), Statement.RETURN_GENERATED_KEYS)
-        		: conn.prepareStatement(query.getFirst(), Statement.NO_GENERATED_KEYS);
-        if (query.getSecond() != null) {
-            Iterator<Object> iter = query.getSecond().iterator();
-            for (int i = 1; iter.hasNext(); i++) {
-                stmt.setObject(i, iter.next());
+        PreparedStatement stmt = conn.prepareStatement(query.getFirst());
+        List<Object> parameters = query.getSecond();
+
+        if (parameters != null) {
+            for (int i = 0; i < parameters.size(); i++) {
+                stmt.setObject(i + 1, parameters.get(i));
            }
        }

        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 && objects[index] instanceof String) {
-            return (String) objects[index];
+        if (index < 0 || index >= objects.length) {
+            return null;
        }
+
+        Object object = objects[index];
+
+        if (object instanceof String) {
+            return (String) object;
+        }
+
        return null;
    }

@ -291,7 +305,7 @@ public class EffExecuteStatement extends Effect {

        //fix mediumblob and similar column types, so they return a String correctly
        if (obj != null) {
-            if (obj instanceof byte[]) {
+            if (obj.getClass().getName().equals("[B")) {
                obj = new String((byte[]) obj);

                //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)
@ -305,14 +319,6 @@ 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) {
@ -321,7 +327,8 @@ public class EffExecuteStatement extends Effect {

    @SuppressWarnings("unchecked")
    @Override
-    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
+    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed,
+                        SkriptParser.ParseResult parseResult) {
        Expression<String> statementExpr = (Expression<String>) exprs[0];
        if (statementExpr instanceof VariableString || statementExpr instanceof ExprUnsafe) {
            query = statementExpr;
@ -332,36 +339,17 @@ public class EffExecuteStatement extends Effect {
            return false;
        }
        dataSource = (Expression<HikariDataSource>) exprs[1];
-        if (exprs[2] != null) {
-            if (query instanceof VariableString && !((VariableString) query).isSimple()) {
-                Skript.warning("Your query string contains expresions, but you've also provided query arguments. Consider using `unsafe` keyword before your query.");
-            }
-            queryArguments = (Expression<Object>) exprs[2];
-        }
-        ;
-        Expression<?> resultHolder = exprs[3];
-        quickly = parseResult.hasTag("quickly");
-        if (resultHolder instanceof Variable) {
-            Variable<?> varExpr = (Variable<?>) resultHolder;
-            resultVariableName = varExpr.getName();
+        Expression<?> expr = exprs[2];
+        isSync = matchedPattern == 1;
+        if (expr instanceof Variable) {
+            Variable<?> varExpr = (Variable<?>) expr;
+            var = varExpr.getName();
            isLocal = varExpr.isLocal();
            isList = varExpr.isList();
-            generatedKeys = parseResult.hasTag("keys");
-        } else if (resultHolder != null) {
-            Skript.error(resultHolder + " is not a variable");
+        } else if (expr != null) {
+            Skript.error(expr + " 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);
-		}
-    	
-    }
-    
 }
--- a/src/main/java/com/btk5h/skriptdb/skript/ExprDataSource.java
+++ b/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%] [[(using|with)] [a] driver %-string%]"
+ * @pattern [the] data(base|[ ]source) [(of|at)] %string% [with [a] [max[imum]] [connection] life[ ]time of %timespan%]"
 * @return datasource
 * @example set {sql} to the database "mysql://localhost:3306/mydatabase?user=admin&password=12345&useSSL=false"
 * @since 0.1.0
@ -32,14 +32,12 @@ public class ExprDataSource extends SimpleExpression<HikariDataSource> {

    static {
        Skript.registerExpression(ExprDataSource.class, HikariDataSource.class,
-                ExpressionType.COMBINED, "[the] data(base|[ ]source) [(of|at)] %string% "
-                		+ "[with [a] [max[imum]] [connection] life[ ]time of %-timespan%] "
-                		+ "[[(using|with)] [a] driver %-string%]");
+                ExpressionType.COMBINED, "[the] data(base|[ ]source) [(of|at)] %string% " +
+                        "[with [a] [max[imum]] [connection] life[ ]time of %-timespan%]");
    }

    private Expression<String> url;
    private Expression<Timespan> maxLifetime;
-    private Expression<String> driver;

    @Override
    protected HikariDataSource[] get(Event e) {
@ -57,18 +55,11 @@ public class ExprDataSource extends SimpleExpression<HikariDataSource> {
        }

        HikariDataSource ds = new HikariDataSource();
-        ds.setMaximumPoolSize(SkriptDB.getInstance().getConfig().getInt("thread-pool-size", 10));

-        // 30 minutes by 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")) {
+        //allow specifying of own sql driver class name
+        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) {
@ -101,10 +92,10 @@ public class ExprDataSource extends SimpleExpression<HikariDataSource> {

    @SuppressWarnings("unchecked")
    @Override
-    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
+    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed,
+                        SkriptParser.ParseResult parseResult) {
        url = (Expression<String>) exprs[0];
        maxLifetime = (Expression<Timespan>) exprs[1];
-        driver = (Expression<String>) exprs[2];
        return true;
    }
 }
--- a/src/main/java/com/btk5h/skriptdb/skript/ExprSQLQuery.java
+++ b/src/main/java/com/btk5h/skriptdb/skript/ExprSQLQuery.java
@ -1,10 +1,6 @@
 package com.btk5h.skriptdb.skript;

-import org.bukkit.event.Event;
-
-import com.btk5h.skriptdb.SkriptUtil;
-import com.btk5h.skriptdb.events.SQLQueryCompleteEvent;
-
+import ch.njol.skript.ScriptLoader;
 import ch.njol.skript.Skript;
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.ExpressionType;
@ -12,6 +8,8 @@ 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.
@ -53,7 +51,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 (!SkriptUtil.isCurrentEvent(SQLQueryCompleteEvent.class)) {
+        if (!ScriptLoader.isCurrentEvent(SQLQueryCompleteEvent.class)) {
            Skript.error("Cannot use 'sql query' outside of a complete of sql query event", ErrorQuality.SEMANTIC_ERROR);
            return false;
        }
--- a/src/main/java/com/btk5h/skriptdb/skript/ExprUnsafe.java
+++ b/src/main/java/com/btk5h/skriptdb/skript/ExprUnsafe.java
@ -53,7 +53,8 @@ public class ExprUnsafe extends SimpleExpression<String> {

    @SuppressWarnings("unchecked")
    @Override
-    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
+    public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed,
+                        SkriptParser.ParseResult parseResult) {
        stringExpression = (Expression<String>) exprs[0];
        rawExpression = parseResult.expr.substring("unsafe".length()).trim();
        return true;
--- a/src/main/java/com/btk5h/skriptdb/skript/Types.java
+++ b/src/main/java/com/btk5h/skriptdb/skript/Types.java
@ -30,6 +30,10 @@ public class Types {
                        return o.getJdbcUrl();
                    }

+                    @Override
+                    public String getVariableNamePattern() {
+                        return "jdbc:.+";
+                    }
                })
                .serializer(new Serializer<HikariDataSource>() {
                    @Override
--- a/src/main/resources/plugin.yml
+++ b/src/main/resources/plugin.yml
@ -1,5 +1,5 @@
 name: skript-db
-version: 1.4.0
+version: 1.3.5
 main: com.btk5h.skriptdb.SkriptDB
 depend: [Skript]
 authors: [btk5h, FranKusmiruk, Govindas, TPGamesNL]