Feat: Support for Distributions in Templated Workloads

config/postgres/sample_templated_config.xml

@@ -24,7 +24,7 @@
         <work>
             <time>10</time>
             <rate>100</rate>
-            <weights>30,20,10,30,10</weights>
+            <weights>30,20,10,20,10,10</weights>
         </work>
     </works>
 
@@ -45,5 +45,8 @@
         <transactiontype>
             <name>GetItemByPrice</name>
         </transactiontype>
+        <transactiontype>
+            <name>GetItemRandom</name>
+        </transactiontype>
     </transactiontypes>
 </parameters>

data/templated/example.xml

@@ -61,4 +61,16 @@
          <value>11</value>
       </values>
    </template>
+   <template name="GetItemRandom">
+      <query><![CDATA[SELECT COUNT(*) FROM item WHERE i_im_id = ?]]></query>
+      <types>
+         <type>RANDOM</type>
+      </types>
+      <values>
+         <value>binomial,0,9999</value>
+      </values>
+      <values>
+         <value>uniform,0,9999</value>
+      </values>
+   </template>
 </templates>

src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java

@@ -107,9 +107,9 @@ protected List<Worker<? extends BenchmarkModule>> makeWorkersImpl() {
                 // Sanity check that the procedure has the right type.
                 if (!(kv.getValue() instanceof GenericQuery)) {
                     LOG.error(
-                        String.format(
-                            "Procedure %s does not have the correct class type (GenericQuery).",
-                        kv.getValue().toString()));
+                            String.format(
+                                    "Procedure %s does not have the correct class type (GenericQuery).",
+                                    kv.getValue().toString()));
                     continue;
                 }
                 GenericQuery proc = (GenericQuery) kv.getValue();
@@ -194,14 +194,14 @@ public final class %s extends %s {
                             }
                         }
                         """.formatted(
-                            GenericQuery.class.getPackageName(),
-                            qt.getName(),
-                            GenericQuery.class.getCanonicalName(),
-                            QueryTemplateInfo.class.getCanonicalName(),
-                            SQLStmt.class.getCanonicalName(),
-                            StringEscapeUtils.escapeJava(qt.getQuery()),
-                            getParamsString(qt.getParamsTypes()),
-                            getParamsString(qt.getParamsValues()));
+                        GenericQuery.class.getPackageName(),
+                        qt.getName(),
+                        GenericQuery.class.getCanonicalName(),
+                        QueryTemplateInfo.class.getCanonicalName(),
+                        SQLStmt.class.getCanonicalName(),
+                        StringEscapeUtils.escapeJava(qt.getQuery()),
+                        getParamsString(qt.getParamsTypes()),
+                        getParamsString(qt.getParamsValues()));
                 LOG.debug("Class definition for query template {}:\n {}", qt.getName(), s);
                 final String qualifiedClassName = GenericQuery.class.getPackageName() + "." + qt.getName();
                 final ISimpleCompiler compiler = compilerFactory.newSimpleCompiler();

src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedWorker.java

@@ -33,7 +33,7 @@ public class TemplatedWorker extends Worker<TemplatedBenchmark> {
     protected final Map<Class<? extends Procedure>, TraceTransactionGenerator> generators;
 
     public TemplatedWorker(TemplatedBenchmark benchmarkModule, int id,
-                     Map<Class<? extends Procedure>, TraceTransactionGenerator> generators) {
+            Map<Class<? extends Procedure>, TraceTransactionGenerator> generators) {
         super(benchmarkModule, id);
         this.rng().setSeed(benchmarkModule.getWorkloadConfiguration().getRandomSeed());
         this.generators = generators;
@@ -49,7 +49,8 @@ protected TransactionStatus executeWork(Connection conn, TransactionType nextTra
                 // If there is a generator available use it to create a
                 // parameter binding.
                 TraceTransactionGenerator generator = generators.get(clazz);
-                proc.run(conn, generator.nextTransaction().getParams());
+                proc.run(conn, generator.nextTransaction().getParams(),
+                        generator.nextTransaction().getRandomGenHashMap());
             } else {
                 // If the generator has no transactions, there are no parameters.
                 proc.run(conn);
@@ -63,4 +64,3 @@ protected TransactionStatus executeWork(Connection conn, TransactionType nextTra
 
     }
 }
-

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

@@ -17,28 +17,38 @@
 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.util.HashMap;
 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 {
 
     protected static final Logger LOG = LoggerFactory.getLogger(GenericQuery.class);
 
     /** Execution method with parameters. */
-    public void run(Connection conn, List<Object> params) throws SQLException {
-        try (PreparedStatement stmt = getStatement(conn, params); ResultSet rs = stmt.executeQuery()) {
+    public void run(Connection conn, List<Object> params, HashMap<Integer, Object> randomGenerators)
+            throws SQLException {
+        try (PreparedStatement stmt = getStatement(conn, params, randomGenerators);
+                ResultSet rs = stmt.executeQuery()) {
             while (rs.next()) {
-                //do nothing
+                // do nothing
             }
         }
         conn.commit();
@@ -48,33 +58,96 @@ 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 {
+    public PreparedStatement getStatement(Connection conn, List<Object> params,
+            HashMap<Integer, Object> randomGenerators) throws SQLException {
         QueryTemplateInfo queryTemplateInfo = this.getQueryTemplateInfo();
 
         PreparedStatement stmt = this.getPreparedStatement(conn, queryTemplateInfo.getQuery());
         String[] paramsTypes = queryTemplateInfo.getParamsTypes();
+        int j = 0;
         for (int i = 0; i < paramsTypes.length; i++) {
             if (paramsTypes[i].equalsIgnoreCase("NULL")) {
                 stmt.setNull(i + 1, Types.NULL);
+            } else if (paramsTypes[i].equalsIgnoreCase("RANDOM")) {
+                int index = i + j;
+                String distType = params.get(index).toString();
+                int minI, maxI;
+                switch (distType) {
+                    case "zipf":
+                        ZipfianGenerator zipfGen = (ZipfianGenerator) randomGenerators.get(index);
+                        stmt.setInt(i + 1, zipfGen.nextInt());
+                        j += 2;
+                        break;
+                    case "uniform":
+                        minI = Integer.parseInt(params.get(index + 1).toString());
+                        maxI = Integer.parseInt(params.get(index + 2).toString());
+                        Random rnd = (Random) randomGenerators.get(index);
+                        int uVal = rnd.nextInt(maxI - minI) + minI;
+                        stmt.setInt(i + 1, uVal);
+                        j += 2;
+                        break;
+                    case "binomial":
+                        minI = Integer.parseInt(params.get(index + 1).toString());
+                        maxI = Integer.parseInt(params.get(index + 2).toString());
+                        Random rng = (Random) randomGenerators.get(index);
+                        int bVal;
+                        do {
+                            bVal = (int) (minI + Math.abs(rng.nextGaussian()) * maxI);
+                        } while (bVal > maxI || bVal < minI);
+
+                        stmt.setInt(i + 1, bVal);
+                        j += 2;
+                        break;
+                    case "scrambled":
+                        ScrambledZipfianGenerator scramZipf = (ScrambledZipfianGenerator) randomGenerators.get(index);
+                        stmt.setInt(i + 1, scramZipf.nextInt());
+                        j += 2;
+                        break;
+                    case "string":
+                        maxI = Integer.parseInt(params.get(index + 1).toString());
+                        Random rand = (Random) randomGenerators.get(index);
+                        String randText = TextGenerator.randomStr(rand, maxI);
+                        stmt.setString(i + 1, randText);
+                        j += 1;
+                        break;
+                    case "datetime":
+                    case "timestamp":
+                        stmt.setTimestamp(i + 1, new Timestamp(System.currentTimeMillis()));
+                        break;
+                    case "date":
+                        stmt.setDate(i + 1, new Date(System.currentTimeMillis()));
+                        break;
+                    case "time":
+                        stmt.setTime(i + 1, new Time(System.currentTimeMillis()));
+                        break;
+                    default:
+                        throw new RuntimeException(
+                                "No suitable distribution found. Currently supported are 'zipf' | 'scrambled' | 'normal' | 'uniform' | 'string' | 'datetime' | 'timestamp' | 'date' | 'time' ");
+                }
+
             } 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));
                 }
             }
         }

src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java

@@ -18,24 +18,68 @@
 
 import java.util.Arrays;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Random;
 
 import com.oltpbenchmark.api.Operation;
+import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
+import com.oltpbenchmark.distributions.ZipfianGenerator;
 
 /**
  * Immutable class containing information about transactions.
  */
 public class GenericQueryOperation extends Operation {
 
     public final List<Object> params;
-
+    public final HashMap<Integer, Object> randomGenerators;
 
     public GenericQueryOperation(Object[] params) {
         super();
         this.params = Collections.unmodifiableList(Arrays.asList(params));
+        this.randomGenerators = this.mapRandom();
     }
 
     public List<Object> getParams() {
         return params;
     }
+
+    private HashMap<Integer, Object> mapRandom() {
+        HashMap<Integer, Object> randomGenerators = new HashMap<Integer, Object>();
+        Integer min, max;
+        for (int i = 0; i < params.size(); i++) {
+            String paramString = params.get(i).toString();
+            switch (paramString) {
+                case "zipf":
+                    min = Integer.parseInt(params.get(i + 1).toString());
+                    max = Integer.parseInt(params.get(i + 2).toString());
+                    ZipfianGenerator zipf = new ZipfianGenerator(new Random(), min, max);
+                    randomGenerators.put(i, zipf);
+                    break;
+                case "uniform":
+                    randomGenerators.put(i, new Random());
+                    break;
+                case "binomial":
+                    randomGenerators.put(i, new Random());
+                    break;
+                case "scrambled":
+                    min = Integer.parseInt(params.get(i + 1).toString());
+                    max = Integer.parseInt(params.get(i + 2).toString());
+                    ScrambledZipfianGenerator scramZipf = new ScrambledZipfianGenerator(min, max);
+                    randomGenerators.put(i, scramZipf);
+                    break;
+                case "string":
+                    randomGenerators.put(i, new Random());
+                    i -= 1;
+                    break;
+            }
+            i += 2;
+        }
+        return randomGenerators;
+
+    }
+
+    public HashMap<Integer, Object> getRandomGenHashMap() {
+        return this.randomGenerators;
+    }
 }