Feat: Support for Distributions in Templated Workloads

data/templated/example.xml

@@ -20,10 +20,10 @@
    <template name="GetCust">
       <query><![CDATA[SELECT C_DISCOUNT, C_LAST, C_CREDIT FROM customer WHERE C_W_ID = ?]]></query>
       <types>
-         <type>INTEGER</type>
+         <type>DISTRIBUTION</type>
       </types>
       <values>
-         <value>8</value>
+         <value>uniform,0,100</value>
       </values>
    </template>
    <template name="GetCustNull">

src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java

@@ -17,18 +17,26 @@
 package com.oltpbenchmark.benchmarks.templated.procedures;
 
 import java.sql.Connection;
+import java.sql.Date;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
 import java.sql.Types;
+import java.text.SimpleDateFormat;
 import java.util.List;
+import java.util.Random;
 
 import org.immutables.value.Value;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.oltpbenchmark.api.Procedure;
 import com.oltpbenchmark.api.SQLStmt;
+import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
+import com.oltpbenchmark.distributions.ZipfianGenerator;
+import com.oltpbenchmark.util.TextGenerator;
 
 public abstract class GenericQuery extends Procedure {
 
@@ -38,7 +46,7 @@ public abstract class GenericQuery extends Procedure {
     public void run(Connection conn, List<Object> params) throws SQLException {
         try (PreparedStatement stmt = getStatement(conn, params); ResultSet rs = stmt.executeQuery()) {
             while (rs.next()) {
-                //do nothing
+                // do nothing
             }
         }
         conn.commit();
@@ -48,33 +56,98 @@ public void run(Connection conn, List<Object> params) throws SQLException {
     public void run(Connection conn) throws SQLException {
         QueryTemplateInfo queryTemplateInfo = this.getQueryTemplateInfo();
 
-        try (PreparedStatement stmt = this.getPreparedStatement(conn, queryTemplateInfo.getQuery()); ResultSet rs = stmt.executeQuery()) {
+        try (PreparedStatement stmt = this.getPreparedStatement(conn, queryTemplateInfo.getQuery());
+                ResultSet rs = stmt.executeQuery()) {
             while (rs.next()) {
-                //do nothing
+                // do nothing
             }
         }
         conn.commit();
     }
 
     public PreparedStatement getStatement(Connection conn, List<Object> params) throws SQLException {
         QueryTemplateInfo queryTemplateInfo = this.getQueryTemplateInfo();
+        Random rng = new Random();
 
         PreparedStatement stmt = this.getPreparedStatement(conn, queryTemplateInfo.getQuery());
         String[] paramsTypes = queryTemplateInfo.getParamsTypes();
         for (int i = 0; i < paramsTypes.length; i++) {
             if (paramsTypes[i].equalsIgnoreCase("NULL")) {
                 stmt.setNull(i + 1, Types.NULL);
+                // ENTER RIGHT HERE WITH THE DISTRIBUTION
+            } else if (paramsTypes[i].equalsIgnoreCase("DISTRIBUTION")) {
+                String distType = params.get(i).toString();
+                String min, max;
+                int minI, maxI;
+                int val;
+                switch (distType) {
+                    case "zipf":
+                        min = params.get(i + 1).toString();
+                        max = params.get(i + 2).toString();
+                        ZipfianGenerator zipf = new ZipfianGenerator(rng, Integer.parseInt(min),
+                                Integer.parseInt(max));
+                        stmt.setInt(i + 1, zipf.nextInt());
+                        break;
+                    case "uniform":
+                        minI = Integer.parseInt(params.get(i + 1).toString());
+                        maxI = Integer.parseInt(params.get(i + 2).toString());
+                        val = rng.nextInt(maxI - minI) + minI;
+                        stmt.setInt(i + 1, val);
+                        break;
+                    case "binomial":
+                        minI = Integer.parseInt(params.get(i + 1).toString());
+                        maxI = Integer.parseInt(params.get(i + 2).toString());
+                        do {
+                            val = (int) (minI + Math.abs(rng.nextGaussian()) * maxI);
+                        } while (val > maxI || val < minI);
+
+                        stmt.setInt(i + 1, val);
+                        break;
+                    case "scrambled":
+                        minI = Integer.parseInt(params.get(i + 1).toString());
+                        maxI = Integer.parseInt(params.get(i + 2).toString());
+                        ScrambledZipfianGenerator scramZipf = new ScrambledZipfianGenerator(minI,
+                                maxI);
+                        stmt.setInt(i + 1, scramZipf.nextInt());
+                        break;
+                    case "string":
+                        maxI = Integer.parseInt(params.get(i + 1).toString());
+                        String randText = TextGenerator.randomStr(rng, maxI);
+                        stmt.setString(i + 1, randText);
+                        break;
+                    case "datetime":
+                    case "timestamp":
+                        Timestamp timestamp = new Timestamp(System.currentTimeMillis());
+                        stmt.setTimestamp(i + 1, timestamp);
+                        break;
+                    case "date":
+                        Date date = new Date(System.currentTimeMillis());
+                        stmt.setDate(i + 1, date);
+                        break;
+                    case "time":
+                        Time time = new Time(System.currentTimeMillis());
+                        stmt.setTime(i + 1, time);
+                        break;
+                    default:
+                        throw new RuntimeException(
+                                "No suitable distribution found. Currently supported are 'zipf' | 'scrambled' | 'normal' | 'uniform' | 'string' ");
+                }
+                System.out.println(stmt.toString());
+
             } else {
                 try {
                     // TODO: add support for nullable other types
-                    // For instance, can we provide a <value /> tag in the XML file to represent a NULL value?
+                    // For instance, can we provide a <value /> tag in the XML file to represent a
+                    // NULL value?
                     // Or does it need a special marker like "$null" to signify a NULL value?
                     Object param = params.get(i);
-                    stmt.setObject(i + 1, param, Integer.parseInt(Types.class.getDeclaredField(paramsTypes[i]).get(null).toString()));
+                    stmt.setObject(i + 1, param,
+                            Integer.parseInt(Types.class.getDeclaredField(paramsTypes[i]).get(null).toString()));
                 } catch (Exception e) {
                     e.printStackTrace();
                     throw new RuntimeException(
-                        "Error when setting parameters. Parameter type: " + paramsTypes[i] + ", parameter value: " + params.get(i));
+                            "Error when setting parameters. Parameter type: " + paramsTypes[i] + ", parameter value: "
+                                    + params.get(i));
                 }
             }
         }