Fixed Govindas weirdness on project files

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

@@ -0,0 +1,127 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2016 Bryan Terce
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+
+package com.btk5h.skriptdb;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.sql.SQLException;
+
+import javax.sql.rowset.RowSetFactory;
+import javax.sql.rowset.RowSetProvider;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.SkriptAddon;
+
+/**
+ * # skript-db
+ *
+ * > Sensible SQL support for Skript.
+ *
+ * @index -1
+ */
+public final class SkriptDB extends JavaPlugin {
+
+  private static SkriptDB instance;
+  private static SkriptAddon addonInstance;
+
+  private static RowSetFactory rowSetFactory;
+  protected FileConfiguration config;
+
+  public SkriptDB() {
+    if (instance == null) {
+      instance = this;
+    } else {
+      throw new IllegalStateException();
+    }
+  }
+
+  private void setupConfig() throws IOException {
+    //don't check if it exists, because mkdir already does that
+    File file = new File("plugins/skript-db/config.yml");
+    if (file.getParentFile().mkdirs()) {
+      BufferedWriter out = null;
+      try {
+        out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("plugins/skript-db/config.yml", false), StandardCharsets.UTF_8));
+      } catch (FileNotFoundException e) {
+        e.printStackTrace();
+      }
+      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("sql-driver-class-name: " + "\"default\"" + "\n");
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+
+      try {
+        out.close();
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    }
+  }
+
+  @Override
+  public void onEnable() {
+    try {
+      setupConfig();
+    } catch (IOException e) {
+      e.printStackTrace();
+    } finally {
+      try {
+        rowSetFactory = RowSetProvider.newFactory();
+
+        getAddonInstance().loadClasses("com.btk5h.skriptdb.skript");
+      } catch (SQLException e) {
+        throw new RuntimeException(e);
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    }
+  }
+
+  public static SkriptAddon getAddonInstance() {
+    if (addonInstance == null) {
+      addonInstance = Skript.registerAddon(getInstance());
+    }
+    return addonInstance;
+  }
+
+  public static SkriptDB getInstance() {
+    if (instance == null) {
+      throw new IllegalStateException();
+    }
+    return instance;
+  }
+
+  public static RowSetFactory getRowSetFactory() {
+    return rowSetFactory;
+  }
+}

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

@@ -0,0 +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;
+
+public class SkriptUtil {
+
+  private static final Field STRING;
+  private static final Field EXPR;
+
+  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;
+
+    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 Expression<?> getExpressionFromInfo(Object o) {
+    try {
+      return (Expression<?>) EXPR.get(o);
+    } catch (IllegalAccessException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+}

src/main/java/com/btk5h/skriptdb/events/SQLQueryCompleteEvent.java

@@ -0,0 +1,34 @@
+package com.btk5h.skriptdb.events;
+
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class SQLQueryCompleteEvent extends Event {
+    private final static HandlerList HANDLERS = new HandlerList();
+    private String argument;
+    private Object variables;
+
+    public SQLQueryCompleteEvent(String argument) {
+        super(true);
+        this.argument = argument;
+      //  this.variables = variables;
+    }
+    @Override
+    public String getEventName() {
+        return super.getEventName();
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return HANDLERS;
+    }
+    public static HandlerList getHandlerList() {
+        return HANDLERS;
+    }
+
+    public String getArgument() {
+        return argument;
+    }
+
+  //  public String getVariables() {return;}
+}

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

@@ -0,0 +1,324 @@
+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.btk5h.skriptdb.events.SQLQueryCompleteEvent;
+import com.zaxxer.hikari.HikariDataSource;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+
+import javax.sql.DataSource;
+import javax.sql.rowset.CachedRowSet;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Executes a statement on a database and optionally stores the result in a variable. Expressions
+ * embedded in the query will be escaped to avoid SQL injection.
+ * <p>
+ * If a single variable, such as `{test}`, is passed, the variable will be set to the number of
+ * affected rows.
+ * <p>
+ * If a list variable, such as `{test::*}`, is passed, the query result will be mapped to the list
+ * variable in the form `{test::<column name>::<row number>}`
+ *
+ * @name Execute Statement
+ * @pattern [synchronously] execute %string% (in|on) %datasource% [and store [[the] (output|result)[s]] (to|in)
+ * [the] [var[iable]] %-objects%]
+ * @example execute "select * from table" in {sql} and store the result in {output::*}
+ * @example execute "select * from %{table variable}%" in {sql} and store the result in {output::*}
+ * @since 0.1.0
+ */
+public class EffExecuteStatement extends Effect {
+  static {
+    Skript.registerEffect(EffExecuteStatement.class,
+        "execute %string% (in|on) %datasource% " +
+            "[and store [[the] (output|result)[s]] (to|in) [the] [var[iable]] %-objects%]", "synchronously execute %string% (in|on) %datasource% " +
+            "[and store [[the] (output|result)[s]] (to|in) [the] [var[iable]] %-objects%]");
+  }
+
+  static String lastError;
+
+  private static final ExecutorService threadPool =
+      Executors.newCachedThreadPool();
+
+  private Expression<String> query;
+  private Expression<HikariDataSource> dataSource;
+  private VariableString var;
+  private boolean isLocal;
+  private boolean isList;
+  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;
+
+      boolean sync = false;
+      if (!Bukkit.isPrimaryThread()) {
+        sync = true;
+      }
+      Object locals = Variables.removeLocals(e);
+
+      //execute SQL statement
+      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
+            if (locals != null)
+              //bring back local variables
+
+            //populate SQL data into variables
+            if (!(res instanceof String)) {
+
+              //also set variables in the sql query complete event
+
+              SQLQueryCompleteEvent event = new SQLQueryCompleteEvent("something");
+              ((Map<String, Object>) res).forEach((name, value) -> setVariable(event, name, value));
+              SkriptDB.getPlugin(SkriptDB.class).getServer().getPluginManager().callEvent(event);
+            }
+            if (isSync || finalSync) {
+
+              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(), () -> {
+                      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);
+    //I think no longer needed as of 1.3.0, uncomment if something breaks
+    if (!isSync) {
+      Delay.addDelayedEvent(e);
+    }
+    execute(e);
+    return null;
+  }
+
+  private Pair<String, List<Object>> parseQuery(Event e) {
+    if (!(query instanceof VariableString)) {
+      return new Pair<>(query.getSingle(e), null);
+    }
+    VariableString q = (VariableString) query;
+    if (q.isSimple()) {
+      return new Pair<>(q.toString(e), null);
+    }
+
+    StringBuilder sb = new StringBuilder();
+    List<Object> parameters = new ArrayList<>();
+    Object[] objects = SkriptUtil.getTemplateString(q);
+
+    for (int i = 0; i < objects.length; i++) {
+      Object o = objects[i];
+      if (o instanceof String) {
+        sb.append(o);
+      } else {
+        Expression<?> 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) {
+          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 Object executeStatement(DataSource ds, String baseVariable, Pair<String, List<Object>> query) {
+    if (ds == null) {
+      return "Data source is not set";
+    }
+    Map<String, Object> variableList = new HashMap<>();
+    try (Connection conn = ds.getConnection();
+         PreparedStatement stmt = createStatement(conn, query)) {
+
+      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());
+        }
+      }
+    } catch (SQLException ex) {
+      return ex.getMessage();
+    }
+    return variableList;
+  }
+
+  private PreparedStatement createStatement(Connection conn, Pair<String, List<Object>> query) throws SQLException {
+    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 String getString(Object[] objects, int index) {
+    if (index < 0 || index >= objects.length) {
+      return null;
+    }
+
+    Object object = objects[index];
+
+    if (object instanceof String) {
+      return (String) object;
+    }
+
+    return null;
+  }
+
+  private void setVariable(Event e, String name, Object obj) {
+    Variables.setVariable(name.toLowerCase(Locale.ENGLISH), obj, e, isLocal);
+  }
+
+  @Override
+  public String toString(Event e, boolean debug) {
+    return "execute " + query.toString(e, debug) + " in " + dataSource.toString(e, debug);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  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;
+    } else {
+      Skript.error("Database statements must be string literals. If you must use an expression, " +
+          "you may use \"%unsafe (your expression)%\", but keep in mind, you may be vulnerable " +
+          "to SQL injection attacks!");
+      return false;
+    }
+    dataSource = (Expression<HikariDataSource>) exprs[1];
+    Expression<?> expr = exprs[2];
+    isSync = matchedPattern == 1;
+    if (expr instanceof Variable) {
+      Variable<?> varExpr = (Variable<?>) expr;
+      var = varExpr.getName();
+      isLocal = varExpr.isLocal();
+      isList = varExpr.isList();
+    } else if (expr != null) {
+      Skript.error(expr + " is not a variable");
+      return false;
+    }
+    return true;
+  }
+}

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

@@ -0,0 +1,29 @@
+package com.btk5h.skriptdb.skript;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Literal;
+import ch.njol.skript.lang.SkriptEvent;
+import ch.njol.skript.lang.SkriptParser;
+import com.btk5h.skriptdb.events.SQLQueryCompleteEvent;
+import org.bukkit.event.Event;
+import org.eclipse.jdt.annotation.Nullable;
+
+public class EvtSQLQueryComplete extends SkriptEvent {
+    static {
+        Skript.registerEvent("complete of sql query", EvtSQLQueryComplete.class, SQLQueryCompleteEvent.class, "complete of [(sql|database)] query");
+    }
+        @Override
+        public boolean init(final Literal<?>[] literals, final int i, final SkriptParser.ParseResult parseResult) {
+            return true;
+        }
+
+        @Override
+        public boolean check(Event event) {
+            return (event instanceof SQLQueryCompleteEvent);
+        }
+
+    @Override
+    public String toString(@Nullable Event event, boolean debug) {
+        return "complete of sql query";
+    }
+}

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

@@ -0,0 +1,50 @@
+package com.btk5h.skriptdb.skript;
+
+import org.bukkit.event.Event;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ExpressionType;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.util.Kleenean;
+
+/**
+ * Stores the error from the last executed statement, if there was one.
+ *
+ * @name Last Data Source Error
+ * @pattern [the] [last] (sql|db|data(base|[ ]source)) error
+ * @return text
+ * @since 0.1.0
+ */
+public class ExprDBError extends SimpleExpression<String> {
+  static {
+    Skript.registerExpression(ExprDBError.class, String.class,
+        ExpressionType.SIMPLE, "[the] [last] (sql|db|data(base|[ ]source)) error");
+  }
+
+  @Override
+  protected String[] get(Event e) {
+    return new String[]{EffExecuteStatement.lastError};
+  }
+
+  @Override
+  public boolean isSingle() {
+    return true;
+  }
+
+  @Override
+  public Class<? extends String> getReturnType() {
+    return String.class;
+  }
+
+  @Override
+  public String toString(Event e, boolean debug) {
+    return "last database error";
+  }
+
+  @Override
+  public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
+    return true;
+  }
+}

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

@@ -0,0 +1,103 @@
+package com.btk5h.skriptdb.skript;
+
+import com.btk5h.skriptdb.SkriptDB;
+import com.zaxxer.hikari.HikariDataSource;
+
+import org.bukkit.event.Event;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ExpressionType;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.skript.util.Timespan;
+import ch.njol.util.Kleenean;
+
+/**
+ * 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.
+ *
+ * @name Data Source
+ * @index -1
+ * @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
+ */
+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%]");
+  }
+
+  private static Map<String, HikariDataSource> connectionCache = new HashMap<>();
+
+  private Expression<String> url;
+  private Expression<Timespan> maxLifetime;
+
+  @Override
+  protected HikariDataSource[] get(Event e) {
+    String jdbcUrl = url.getSingle(e);
+    if (jdbcUrl == null) {
+      return null;
+    }
+
+    if (!jdbcUrl.startsWith("jdbc:")) {
+      jdbcUrl = "jdbc:" + jdbcUrl;
+    }
+
+    if (connectionCache.containsKey(jdbcUrl)) {
+      return new HikariDataSource[]{connectionCache.get(jdbcUrl)};
+    }
+
+    HikariDataSource ds = new HikariDataSource();
+
+    //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) {
+      Timespan l = maxLifetime.getSingle(e);
+
+      if (l != null) {
+        ds.setMaxLifetime(l.getMilliSeconds());
+      }
+    }
+
+    connectionCache.put(jdbcUrl, ds);
+
+    return new HikariDataSource[]{ds};
+  }
+
+  @Override
+  public boolean isSingle() {
+    return true;
+  }
+
+  @Override
+  public Class<? extends HikariDataSource> getReturnType() {
+    return HikariDataSource.class;
+  }
+
+  @Override
+  public String toString(Event e, boolean debug) {
+    return "datasource " + url.toString(e, debug);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed,
+                      SkriptParser.ParseResult parseResult) {
+    url = (Expression<String>) exprs[0];
+    maxLifetime = (Expression<Timespan>) exprs[1];
+    return true;
+  }
+}

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

@@ -0,0 +1,63 @@
+package com.btk5h.skriptdb.skript;
+
+import org.bukkit.event.Event;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.ExpressionType;
+import ch.njol.skript.lang.SkriptParser;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.util.Kleenean;
+
+/**
+ * Opts out of automatic SQL injection protection for a specific expression in a statement.
+ *
+ * @name Unsafe Expression
+ * @pattern unsafe %text%
+ * @return text
+ * @example execute "select %unsafe {columns variable}% from %{table variable}%" in {sql}
+ * @example execute unsafe {fully dynamic query} in {sql}
+ * @since 0.1.0
+ */
+public class ExprUnsafe extends SimpleExpression<String> {
+  static {
+    Skript.registerExpression(ExprUnsafe.class, String.class, ExpressionType.COMBINED,
+        "unsafe %string%");
+  }
+
+  private Expression<String> stringExpression;
+  private String rawExpression;
+
+  public String getRawExpression() {
+    return rawExpression;
+  }
+
+  @Override
+  protected String[] get(Event e) {
+    return stringExpression.getArray(e);
+  }
+
+  @Override
+  public boolean isSingle() {
+    return true;
+  }
+
+  @Override
+  public Class<? extends String> getReturnType() {
+    return String.class;
+  }
+
+  @Override
+  public String toString(Event e, boolean debug) {
+    return "unsafe " + stringExpression.toString(e, debug);
+  }
+
+  @SuppressWarnings("unchecked")
+  @Override
+  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;
+  }
+}

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

@@ -0,0 +1,68 @@
+package com.btk5h.skriptdb.skript;
+
+import ch.njol.skript.classes.ClassInfo;
+import ch.njol.skript.classes.Parser;
+import ch.njol.skript.classes.Serializer;
+import ch.njol.skript.lang.ParseContext;
+import ch.njol.skript.registrations.Classes;
+import ch.njol.yggdrasil.Fields;
+import com.zaxxer.hikari.HikariDataSource;
+
+import java.io.StreamCorruptedException;
+
+public class Types {
+  static {
+    Classes.registerClass(new ClassInfo<>(HikariDataSource.class, "datasource")
+        .user("datasources?")
+        .parser(new Parser<>() {
+            @Override
+            public HikariDataSource parse(String s, ParseContext context) {
+                return null;
+            }
+
+            @Override
+            public String toString(HikariDataSource o, int flags) {
+                return o.getJdbcUrl();
+            }
+
+            @Override
+            public String toVariableNameString(HikariDataSource o) {
+                return o.getJdbcUrl();
+            }
+
+            @Override
+            public String getVariableNamePattern() {
+                return "jdbc:.+";
+            }
+        })
+        .serializer(new Serializer<>() {
+            @Override
+            public Fields serialize(HikariDataSource o) {
+                Fields fields = new Fields();
+                fields.putObject("jdbcurl", o.getJdbcUrl());
+                return fields;
+            }
+
+            @Override
+            public void deserialize(HikariDataSource o, Fields f) {
+            }
+
+            @Override
+            protected HikariDataSource deserialize(Fields fields) throws StreamCorruptedException {
+                HikariDataSource ds = new HikariDataSource();
+                ds.setJdbcUrl((String) fields.getObject("jdbcurl"));
+                return ds;
+            }
+
+            @Override
+            public boolean mustSyncDeserialization() {
+                return false;
+            }
+
+            @Override
+            protected boolean canBeInstantiated() {
+                return false;
+            }
+        }));
+  }
+}