From 760ede7d1d3d0cdc31a5755aef869791c152446f Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Thu, 26 Oct 2023 09:55:37 +0200
Subject: [PATCH 01/24] Added Random distributions

---
 data/templated/example.xml                    |  4 +-
 .../templated/procedures/GenericQuery.java    | 60 +++++++++++++++++--
 2 files changed, 56 insertions(+), 8 deletions(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index 2e2177859..d16404290 100644
--- a/data/templated/example.xml
+++ b/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,100</value>
       </values>
    </template>
    <template name="GetCustNull">
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 2d5df5957..99a40c5b0 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -22,6 +22,7 @@
 import java.sql.SQLException;
 import java.sql.Types;
 import java.util.List;
+import java.util.Random;
 
 import org.immutables.value.Value;
 import org.slf4j.Logger;
@@ -29,6 +30,9 @@
 
 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 +42,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,9 +52,10 @@ 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();
@@ -58,23 +63,66 @@ public void run(Connection conn) throws SQLException {
 
     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 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":
+                        max = params.get(i + 1).toString();
+                        val = rng.nextInt(Integer.parseInt(max));
+                        stmt.setInt(i + 1, val);
+                        break;
+                    case "scrambled":
+                        min = params.get(i + 1).toString();
+                        max = params.get(i + 2).toString();
+                        ScrambledZipfianGenerator scramZipf = new ScrambledZipfianGenerator(Integer.parseInt(min),
+                                Integer.parseInt(max));
+
+                        stmt.setInt(i + 1, scramZipf.nextInt());
+                        break;
+                    case "string":
+                        max = params.get(i + 1).toString();
+                        String randText = TextGenerator.randomStr(rng, Integer.parseInt(max));
+                        stmt.setString(i + 1, randText);
+                        break;
+                    default:
+                        throw new RuntimeException(
+                                "No suitable distribution found. Currently supported are 'zipf' | '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));
                 }
             }
         }

From 9acfc1921bc8879144a5c6961696005468adcf2c Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Thu, 26 Oct 2023 11:34:44 +0200
Subject: [PATCH 02/24] Added Binomial Distribution

---
 .../benchmarks/templated/procedures/GenericQuery.java | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 99a40c5b0..dbf095153 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -81,12 +81,20 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
                         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":
                         max = params.get(i + 1).toString();
                         val = rng.nextInt(Integer.parseInt(max));
+                        stmt.setInt(i + 1, val);
+                        break;
+                    case "binomial":
+                        int minI = Integer.parseInt(params.get(i + 1).toString());
+                        int 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":
@@ -94,7 +102,6 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
                         max = params.get(i + 2).toString();
                         ScrambledZipfianGenerator scramZipf = new ScrambledZipfianGenerator(Integer.parseInt(min),
                                 Integer.parseInt(max));
-
                         stmt.setInt(i + 1, scramZipf.nextInt());
                         break;
                     case "string":

From 36174c0a314d56a7eae5479a4438f9dc01de5d84 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Mon, 30 Oct 2023 14:41:20 +0100
Subject: [PATCH 03/24] Min/Max for all Distributions

---
 data/templated/example.xml                    |  2 +-
 .../templated/procedures/GenericQuery.java    | 26 +++++++++----------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index d16404290..f25f5e7f5 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -23,7 +23,7 @@
          <type>DISTRIBUTION</type>
       </types>
       <values>
-         <value>uniform,100</value>
+         <value>uniform,0,100</value>
       </values>
    </template>
    <template name="GetCustNull">
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index dbf095153..efdd5fb36 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -74,6 +74,7 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
             } else if (paramsTypes[i].equalsIgnoreCase("DISTRIBUTION")) {
                 String distType = params.get(i).toString();
                 String min, max;
+                int minI, maxI;
                 int val;
                 switch (distType) {
                     case "zipf":
@@ -84,13 +85,14 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
                         stmt.setInt(i + 1, zipf.nextInt());
                         break;
                     case "uniform":
-                        max = params.get(i + 1).toString();
-                        val = rng.nextInt(Integer.parseInt(max));
+                        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":
-                        int minI = Integer.parseInt(params.get(i + 1).toString());
-                        int maxI = Integer.parseInt(params.get(i + 2).toString());
+                        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);
@@ -98,24 +100,22 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
                         stmt.setInt(i + 1, val);
                         break;
                     case "scrambled":
-                        min = params.get(i + 1).toString();
-                        max = params.get(i + 2).toString();
-                        ScrambledZipfianGenerator scramZipf = new ScrambledZipfianGenerator(Integer.parseInt(min),
-                                Integer.parseInt(max));
+                        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":
-                        max = params.get(i + 1).toString();
-                        String randText = TextGenerator.randomStr(rng, Integer.parseInt(max));
+                        maxI = Integer.parseInt(params.get(i + 1).toString());
+                        String randText = TextGenerator.randomStr(rng, maxI);
                         stmt.setString(i + 1, randText);
                         break;
                     default:
                         throw new RuntimeException(
-                                "No suitable distribution found. Currently supported are 'zipf' | 'normal' | 'uniform' | 'string' ");
+                                "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

From b28f7eed2359fb865be2f8bcf1304aa6cf7bc995 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Tue, 7 Nov 2023 13:52:01 +0100
Subject: [PATCH 04/24] Added Timestamps, Time,Date

---
 .../templated/procedures/GenericQuery.java     | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index efdd5fb36..a7eaf42da 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -17,10 +17,14 @@
 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;
 
@@ -111,10 +115,24 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
                         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 {

From d42d950dc7cf353c8270ac5b0f326493fc75b712 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Fri, 10 Nov 2023 17:02:37 +0100
Subject: [PATCH 05/24] HashMap Solution with type casting

---
 .../templated/TemplatedBenchmark.java         | 22 ++++-----
 .../benchmarks/templated/TemplatedWorker.java |  6 +--
 .../templated/procedures/GenericQuery.java    | 43 ++++++++---------
 .../templated/util/GenericQueryOperation.java | 47 ++++++++++++++++++-
 4 files changed, 80 insertions(+), 38 deletions(-)

diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index 01ed0ec91..01569e28e 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/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();
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedWorker.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedWorker.java
index c1fcdfc7e..16118ad90 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedWorker.java
+++ b/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
 
     }
 }
-
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index a7eaf42da..8fc4aceed 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -25,6 +25,7 @@
 import java.sql.Timestamp;
 import java.sql.Types;
 import java.text.SimpleDateFormat;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Random;
 
@@ -43,8 +44,10 @@ 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
             }
@@ -65,9 +68,9 @@ public void run(Connection conn) throws SQLException {
         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();
-        Random rng = new Random();
 
         PreparedStatement stmt = this.getPreparedStatement(conn, queryTemplateInfo.getQuery());
         String[] paramsTypes = queryTemplateInfo.getParamsTypes();
@@ -77,26 +80,24 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
                 // 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());
+                        ZipfianGenerator zipfGen = (ZipfianGenerator) randomGenerators.get(i);
+                        stmt.setInt(i + 1, zipfGen.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;
+                        Random rnd = (Random) randomGenerators.get(i);
+                        val = rnd.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());
+                        Random rng = (Random) randomGenerators.get(i);
                         do {
                             val = (int) (minI + Math.abs(rng.nextGaussian()) * maxI);
                         } while (val > maxI || val < minI);
@@ -104,33 +105,29 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
                         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);
+
+                        ScrambledZipfianGenerator scramZipf = (ScrambledZipfianGenerator) randomGenerators.get(i);
                         stmt.setInt(i + 1, scramZipf.nextInt());
                         break;
                     case "string":
                         maxI = Integer.parseInt(params.get(i + 1).toString());
-                        String randText = TextGenerator.randomStr(rng, maxI);
+                        Random randStr = (Random) randomGenerators.get(i);
+                        String randText = TextGenerator.randomStr(randStr, maxI);
                         stmt.setString(i + 1, randText);
                         break;
                     case "datetime":
                     case "timestamp":
-                        Timestamp timestamp = new Timestamp(System.currentTimeMillis());
-                        stmt.setTimestamp(i + 1, timestamp);
+                        stmt.setTimestamp(i + 1, new Timestamp(System.currentTimeMillis()));
                         break;
                     case "date":
-                        Date date = new Date(System.currentTimeMillis());
-                        stmt.setDate(i + 1, date);
+                        stmt.setDate(i + 1, new Date(System.currentTimeMillis()));
                         break;
                     case "time":
-                        Time time = new Time(System.currentTimeMillis());
-                        stmt.setTime(i + 1, 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' ");
+                                "No suitable distribution found. Currently supported are 'zipf' | 'scrambled' | 'normal' | 'uniform' | 'string' | 'datetime' | 'timestamp' | 'date' | 'time' ");
                 }
                 System.out.println(stmt.toString());
 
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
index b2a3cdc73..6d0ddfde4 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
@@ -18,9 +18,13 @@
 
 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.
@@ -28,14 +32,55 @@
 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;
+    }
 }

From 572ca57cf00970d33ee26dc7e5a203bd6f3e68e5 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Tue, 14 Nov 2023 15:04:41 +0100
Subject: [PATCH 06/24] Multi random support

---
 config/postgres/sample_templated_config.xml   |  5 +-
 data/templated/example.xml                    | 16 +++++-
 .../templated/procedures/GenericQuery.java    | 49 ++++++++++---------
 .../templated/util/GenericQueryOperation.java |  1 -
 4 files changed, 44 insertions(+), 27 deletions(-)

diff --git a/config/postgres/sample_templated_config.xml b/config/postgres/sample_templated_config.xml
index 2ef942e93..9ab417941 100644
--- a/config/postgres/sample_templated_config.xml
+++ b/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>
diff --git a/data/templated/example.xml b/data/templated/example.xml
index f25f5e7f5..2d562cf92 100644
--- a/data/templated/example.xml
+++ b/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>DISTRIBUTION</type>
+         <type>INTEGER</type>
       </types>
       <values>
-         <value>uniform,0,100</value>
+         <value>8</value>
       </values>
    </template>
    <template name="GetCustNull">
@@ -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>
\ No newline at end of file
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 8fc4aceed..2118234c4 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -24,7 +24,6 @@
 import java.sql.Time;
 import java.sql.Timestamp;
 import java.sql.Types;
-import java.text.SimpleDateFormat;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Random;
@@ -74,46 +73,51 @@ public PreparedStatement getStatement(Connection conn, List<Object> params,
 
         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);
-                // ENTER RIGHT HERE WITH THE DISTRIBUTION
-            } else if (paramsTypes[i].equalsIgnoreCase("DISTRIBUTION")) {
-                String distType = params.get(i).toString();
+            } else if (paramsTypes[i].equalsIgnoreCase("RANDOM")) {
+                int index = i + j;
+                String distType = params.get(index).toString();
                 int minI, maxI;
-                int val;
                 switch (distType) {
                     case "zipf":
-                        ZipfianGenerator zipfGen = (ZipfianGenerator) randomGenerators.get(i);
+                        ZipfianGenerator zipfGen = (ZipfianGenerator) randomGenerators.get(index);
                         stmt.setInt(i + 1, zipfGen.nextInt());
+                        j += 2;
                         break;
                     case "uniform":
-                        minI = Integer.parseInt(params.get(i + 1).toString());
-                        maxI = Integer.parseInt(params.get(i + 2).toString());
-                        Random rnd = (Random) randomGenerators.get(i);
-                        val = rnd.nextInt(maxI - minI) + minI;
-                        stmt.setInt(i + 1, val);
+                        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(i + 1).toString());
-                        maxI = Integer.parseInt(params.get(i + 2).toString());
-                        Random rng = (Random) randomGenerators.get(i);
+                        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 {
-                            val = (int) (minI + Math.abs(rng.nextGaussian()) * maxI);
-                        } while (val > maxI || val < minI);
+                            bVal = (int) (minI + Math.abs(rng.nextGaussian()) * maxI);
+                        } while (bVal > maxI || bVal < minI);
 
-                        stmt.setInt(i + 1, val);
+                        stmt.setInt(i + 1, bVal);
+                        j += 2;
                         break;
                     case "scrambled":
-
-                        ScrambledZipfianGenerator scramZipf = (ScrambledZipfianGenerator) randomGenerators.get(i);
+                        ScrambledZipfianGenerator scramZipf = (ScrambledZipfianGenerator) randomGenerators.get(index);
                         stmt.setInt(i + 1, scramZipf.nextInt());
+                        j += 2;
                         break;
                     case "string":
-                        maxI = Integer.parseInt(params.get(i + 1).toString());
-                        Random randStr = (Random) randomGenerators.get(i);
-                        String randText = TextGenerator.randomStr(randStr, maxI);
+                        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":
@@ -129,7 +133,6 @@ public PreparedStatement getStatement(Connection conn, List<Object> params,
                         throw new RuntimeException(
                                 "No suitable distribution found. Currently supported are 'zipf' | 'scrambled' | 'normal' | 'uniform' | 'string' | 'datetime' | 'timestamp' | 'date' | 'time' ");
                 }
-                System.out.println(stmt.toString());
 
             } else {
                 try {
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
index 6d0ddfde4..d6d380cad 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
@@ -75,7 +75,6 @@ private HashMap<Integer, Object> mapRandom() {
             }
             i += 2;
         }
-
         return randomGenerators;
 
     }

From 6f287d9013485d6a43adf96a40ee2afe7e081285 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Fri, 17 Nov 2023 11:36:06 +0100
Subject: [PATCH 07/24] Architecture change | Uniform distribution implemented

---
 data/templated/example.xml                    |   7 +-
 .../api/templates/ObjectFactory.java          |  63 +++++--
 .../api/templates/TemplateType.java           | 132 +++++++++++---
 .../api/templates/TemplatesType.java          |  71 +++++---
 .../api/templates/TypesType.java              |  67 ++++---
 .../api/templates/ValueType.java              | 171 ++++++++++++++++++
 .../api/templates/ValuesType.java             |  71 +++++---
 .../templated/TemplatedBenchmark.java         |  60 ++++--
 .../benchmarks/templated/TemplatedWorker.java |   3 +-
 .../templated/procedures/GenericQuery.java    |  98 ++++++----
 .../templated/util/ComplexValue.java          |  82 +++++++++
 .../templated/util/GenericQueryOperation.java |  55 +-----
 src/main/resources/templates.xsd              |  18 +-
 13 files changed, 666 insertions(+), 232 deletions(-)
 create mode 100644 src/main/java/com/oltpbenchmark/api/templates/ValueType.java
 create mode 100644 src/main/java/com/oltpbenchmark/benchmarks/templated/util/ComplexValue.java

diff --git a/data/templated/example.xml b/data/templated/example.xml
index 2d562cf92..a3f96a482 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -64,13 +64,10 @@
    <template name="GetItemRandom">
       <query><![CDATA[SELECT COUNT(*) FROM item WHERE i_im_id = ?]]></query>
       <types>
-         <type>RANDOM</type>
+         <type>INTEGER</type>
       </types>
       <values>
-         <value>binomial,0,9999</value>
-      </values>
-      <values>
-         <value>uniform,0,9999</value>
+         <value dist="uniform" min="0" max="9999" seed="12"></value>
       </values>
    </template>
 </templates>
\ No newline at end of file
diff --git a/src/main/java/com/oltpbenchmark/api/templates/ObjectFactory.java b/src/main/java/com/oltpbenchmark/api/templates/ObjectFactory.java
index 82cbd4b96..1ff6dffdb 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/ObjectFactory.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/ObjectFactory.java
@@ -15,11 +15,11 @@
  *
  */
 
-//
-// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.10 
-// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+ //
+// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
+// See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
 // Any modifications to this file will be lost upon recompilation of the source schema. 
-// Generated on: 2011.12.28 at 11:42:38 PM EST 
+// Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
 
@@ -32,17 +32,18 @@
 
 
 /**
- * This object contains factory methods for each
- * Java content interface and Java element interface
- * generated in the com.oltpbenchmark.api.templates package.
- * <p>An ObjectFactory allows you to programatically
- * construct new instances of the Java representation
- * for XML content. The Java representation of XML
- * content can consist of schema derived interfaces
- * and classes representing the binding of schema
- * type definitions, element declarations and model
- * groups.  Factory methods for each of these are
+ * This object contains factory methods for each 
+ * Java content interface and Java element interface 
+ * generated in the main.java.com.oltpbenchmark.api.templates package. 
+ * <p>An ObjectFactory allows you to programatically 
+ * construct new instances of the Java representation 
+ * for XML content. The Java representation of XML 
+ * content can consist of schema derived interfaces 
+ * and classes representing the binding of schema 
+ * type definitions, element declarations and model 
+ * groups.  Factory methods for each of these are 
  * provided in this class.
+ * 
  */
 @XmlRegistry
 public class ObjectFactory {
@@ -50,14 +51,23 @@ public class ObjectFactory {
     private final static QName _Templates_QNAME = new QName("", "templates");
 
     /**
-     * Create a new ObjectFactory that can be used to create new instances of
-     * schema derived classes for package: com.oltpbenchmark.api.templates
+     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: main.java.com.oltpbenchmark.api.templates
+     * 
      */
     public ObjectFactory() {
     }
 
+    /**
+     * Create an instance of {@link TemplatesType }
+     * 
+     */
+    public TemplatesType createTemplatesType() {
+        return new TemplatesType();
+    }
+
     /**
      * Create an instance of {@link TemplateType }
+     * 
      */
     public TemplateType createTemplateType() {
         return new TemplateType();
@@ -65,6 +75,7 @@ public TemplateType createTemplateType() {
 
     /**
      * Create an instance of {@link TypesType }
+     * 
      */
     public TypesType createTypesType() {
         return new TypesType();
@@ -72,17 +83,31 @@ public TypesType createTypesType() {
 
     /**
      * Create an instance of {@link ValuesType }
+     * 
      */
     public ValuesType createValuesType() {
         return new ValuesType();
     }
 
     /**
-     * Create an instance of {@link JAXBElement }{@code <}{@link TemplatesType }{@code >}}
+     * Create an instance of {@link ValueType }
+     * 
+     */
+    public ValueType createValueType() {
+        return new ValueType();
+    }
+
+    /**
+     * Create an instance of {@link JAXBElement }{@code <}{@link TemplatesType }{@code >}
+     * 
+     * @param value
+     *     Java instance representing xml element's value.
+     * @return
+     *     the new instance of {@link JAXBElement }{@code <}{@link TemplatesType }{@code >}
      */
     @XmlElementDecl(namespace = "", name = "templates")
-    public JAXBElement<TemplatesType> createDialects(TemplatesType value) {
-        return new JAXBElement<>(_Templates_QNAME, TemplatesType.class, null, value);
+    public JAXBElement<TemplatesType> createTemplates(TemplatesType value) {
+        return new JAXBElement<TemplatesType>(_Templates_QNAME, TemplatesType.class, null, value);
     }
 
 }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java b/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
index 1bcba2164..6a6cae997 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
@@ -15,88 +15,160 @@
  *
  */
 
-//
-// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.10 
-// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+ //
+// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
+// See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
 // Any modifications to this file will be lost upon recompilation of the source schema. 
-// Generated on: 2011.12.28 at 11:42:38 PM EST 
+// Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
 
 package com.oltpbenchmark.api.templates;
 
-import jakarta.xml.bind.annotation.*;
 import java.util.ArrayList;
 import java.util.List;
+import jakarta.xml.bind.annotation.*;
+
 
 
 /**
- * <p>Java class for dialectType complex type.
- *
+ * <p>Java class for templateType complex type.
+ * 
  * <p>The following schema fragment specifies the expected content contained within this class.
- *
+ * 
  * <pre>
- * &lt;complexType name="dialectType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence>
- *         &lt;element name="procedure" type="{}procedureType" maxOccurs="unbounded"/>
- *       &lt;/sequence>
- *       &lt;attribute name="type" use="required" type="{http://www.w3.org/2001/XMLSchema}string" />
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
+ * &lt;complexType name="templateType"&gt;
+ *   &lt;complexContent&gt;
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
+ *       &lt;sequence&gt;
+ *         &lt;element name="query" type="{http://www.w3.org/2001/XMLSchema}string"/&gt;
+ *         &lt;element name="types" type="{}typesType"/&gt;
+ *         &lt;element name="values" type="{}valuesType" maxOccurs="unbounded"/&gt;
+ *       &lt;/sequence&gt;
+ *       &lt;attribute name="name" use="required" type="{http://www.w3.org/2001/XMLSchema}string" /&gt;
+ *     &lt;/restriction&gt;
+ *   &lt;/complexContent&gt;
+ * &lt;/complexType&gt;
  * </pre>
+ * 
+ * 
  */
 @XmlAccessorType(XmlAccessType.FIELD)
 @XmlType(name = "templateType", propOrder = {
-    "query", "types", "values"
+    "query",
+    "types",
+    "values"
 })
 public class TemplateType {
 
-    @XmlAttribute(required = true)
-    protected String name;
     @XmlElement(required = true)
     protected String query;
     @XmlElement(required = true)
     protected TypesType types;
     @XmlElement(required = true)
     protected List<ValuesType> values;
+    @XmlAttribute(name = "name", required = true)
+    protected String name;
 
     /**
      * Gets the value of the query property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
      */
     public String getQuery() {
-        return this.query;
+        return query;
+    }
+
+    /**
+     * Sets the value of the query property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setQuery(String value) {
+        this.query = value;
     }
-    
 
     /**
      * Gets the value of the types property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link TypesType }
+     *     
      */
     public TypesType getTypes() {
-        return this.types;
+        return types;
     }
 
     /**
-     * Gets the value of the types property.
+     * Sets the value of the types property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link TypesType }
+     *     
+     */
+    public void setTypes(TypesType value) {
+        this.types = value;
+    }
+
+    /**
+     * Gets the value of the values property.
+     * 
+     * <p>
+     * This accessor method returns a reference to the live list,
+     * not a snapshot. Therefore any modification you make to the
+     * returned list will be present inside the JAXB object.
+     * This is why there is not a <CODE>set</CODE> method for the values property.
+     * 
+     * <p>
+     * For example, to add a new item, do as follows:
+     * <pre>
+     *    getValues().add(newItem);
+     * </pre>
+     * 
+     * 
+     * <p>
+     * Objects of the following type(s) are allowed in the list
+     * {@link ValuesType }
+     * 
      * 
-     * Objects of the following type(s) are allowed in the list {@link ValuesType }
      */
     public List<ValuesType> getValues() {
-        if (this.values == null) {
-            this.values = new ArrayList<>();
+        if (values == null) {
+            values = new ArrayList<ValuesType>();
         }
         return this.values;
     }
 
     /**
      * Gets the value of the name property.
-     *
-     * @return possible object is {@link String }
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
      */
     public String getName() {
         return name;
     }
 
+    /**
+     * Sets the value of the name property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setName(String value) {
+        this.name = value;
+    }
+
 }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java b/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
index 6910f5477..c0d573cce 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
@@ -15,44 +15,44 @@
  *
  */
 
-//
-// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.10 
-// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+ //
+// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
+// See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
 // Any modifications to this file will be lost upon recompilation of the source schema. 
-// Generated on: 2011.12.28 at 11:42:38 PM EST 
+// Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
 
 package com.oltpbenchmark.api.templates;
 
-import jakarta.xml.bind.annotation.XmlAccessType;
-import jakarta.xml.bind.annotation.XmlAccessorType;
-import jakarta.xml.bind.annotation.XmlElement;
-import jakarta.xml.bind.annotation.XmlType;
 import java.util.ArrayList;
 import java.util.List;
+import jakarta.xml.bind.annotation.*;
+
 
 
 /**
- * <p>Java class for dialectsType complex type.
- *
+ * <p>Java class for templatesType complex type.
+ * 
  * <p>The following schema fragment specifies the expected content contained within this class.
- *
+ * 
  * <pre>
- * &lt;complexType name="dialectsType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence>
- *         &lt;element name="dialect" type="{}dialectType" maxOccurs="unbounded"/>
- *       &lt;/sequence>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
+ * &lt;complexType name="templatesType"&gt;
+ *   &lt;complexContent&gt;
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
+ *       &lt;sequence&gt;
+ *         &lt;element name="template" type="{}templateType" maxOccurs="unbounded"/&gt;
+ *       &lt;/sequence&gt;
+ *     &lt;/restriction&gt;
+ *   &lt;/complexContent&gt;
+ * &lt;/complexType&gt;
  * </pre>
+ * 
+ * 
  */
 @XmlAccessorType(XmlAccessType.FIELD)
 @XmlType(name = "templatesType", propOrder = {
-        "template"
+    "template"
 })
 public class TemplatesType {
 
@@ -60,15 +60,32 @@ public class TemplatesType {
     protected List<TemplateType> template;
 
     /**
-     * Gets the value of the dialect property.
+     * Gets the value of the template property.
+     * 
+     * <p>
+     * This accessor method returns a reference to the live list,
+     * not a snapshot. Therefore any modification you make to the
+     * returned list will be present inside the JAXB object.
+     * This is why there is not a <CODE>set</CODE> method for the template property.
+     * 
+     * <p>
+     * For example, to add a new item, do as follows:
+     * <pre>
+     *    getTemplate().add(newItem);
+     * </pre>
+     * 
+     * 
+     * <p>
+     * Objects of the following type(s) are allowed in the list
+     * {@link TemplateType }
+     * 
      * 
-     * Objects of the following type(s) are allowed in the list {@link TemplateType }
      */
-    public List<TemplateType> getTemplateList() {
-        if (this.template == null) {
-            this.template = new ArrayList<>();
+    public List<TemplateType> getTemplate() {
+        if (template == null) {
+            template = new ArrayList<TemplateType>();
         }
         return this.template;
     }
-    
+
 }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/TypesType.java b/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
index 170844d78..68405ed61 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
@@ -16,55 +16,74 @@
  */
 
 //
-// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.10 
-// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
+// See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
 // Any modifications to this file will be lost upon recompilation of the source schema. 
-// Generated on: 2011.12.28 at 11:42:38 PM EST 
+// Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
 
 package com.oltpbenchmark.api.templates;
 
-import jakarta.xml.bind.annotation.*;
 import java.util.ArrayList;
 import java.util.List;
-
+import jakarta.xml.bind.annotation.*;
 
 /**
- * <p>Java class for dialectType complex type.
- *
+ * <p>Java class for typesType complex type.
+ * 
  * <p>The following schema fragment specifies the expected content contained within this class.
- *
+ * 
  * <pre>
- * &lt;complexType name="parameterTypesType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence>
- *         &lt;element name="parameters_type" type="{}procedureType" maxOccurs="unbounded"/>
- *       &lt;/sequence>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
+ * &lt;complexType name="typesType"&gt;
+ *   &lt;complexContent&gt;
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
+ *       &lt;sequence&gt;
+ *         &lt;element name="type" type="{http://www.w3.org/2001/XMLSchema}string" maxOccurs="unbounded"/&gt;
+ *       &lt;/sequence&gt;
+ *     &lt;/restriction&gt;
+ *   &lt;/complexContent&gt;
+ * &lt;/complexType&gt;
  * </pre>
+ * 
+ * 
  */
 @XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "typesType", propOrder = {"type"})
+@XmlType(name = "typesType", propOrder = {
+    "type"
+})
 public class TypesType {
 
     @XmlElement(required = true)
     protected List<String> type;
-    
 
     /**
      * Gets the value of the type property.
      * 
-     * Objects of the following type(s) are allowed in the list {@link String }
+     * <p>
+     * This accessor method returns a reference to the live list,
+     * not a snapshot. Therefore any modification you make to the
+     * returned list will be present inside the JAXB object.
+     * This is why there is not a <CODE>set</CODE> method for the type property.
+     * 
+     * <p>
+     * For example, to add a new item, do as follows:
+     * <pre>
+     *    getType().add(newItem);
+     * </pre>
+     * 
+     * 
+     * <p>
+     * Objects of the following type(s) are allowed in the list
+     * {@link String }
+     * 
+     * 
      */
-    public List<String> getTypeList() {
-        if (this.type == null) {
-            this.type = new ArrayList<>();
+    public List<String> getType() {
+        if (type == null) {
+            type = new ArrayList<String>();
         }
         return this.type;
     }
-    
+
 }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/ValueType.java b/src/main/java/com/oltpbenchmark/api/templates/ValueType.java
new file mode 100644
index 000000000..aff8f4086
--- /dev/null
+++ b/src/main/java/com/oltpbenchmark/api/templates/ValueType.java
@@ -0,0 +1,171 @@
+//
+// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
+// See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
+// Any modifications to this file will be lost upon recompilation of the source schema. 
+// Generated on: 2023.11.16 at 08:29:59 AM UTC 
+//
+
+
+package com.oltpbenchmark.api.templates;
+
+import jakarta.xml.bind.annotation.*;
+
+
+/**
+ * <p>Java class for valueType complex type.
+ * 
+ * <p>The following schema fragment specifies the expected content contained within this class.
+ * 
+ * <pre>
+ * &lt;complexType name="valueType"&gt;
+ *   &lt;simpleContent&gt;
+ *     &lt;extension base="&lt;http://www.w3.org/2001/XMLSchema&gt;string"&gt;
+ *       &lt;attribute name="dist" type="{http://www.w3.org/2001/XMLSchema}string" /&gt;
+ *       &lt;attribute name="min" type="{http://www.w3.org/2001/XMLSchema}string" /&gt;
+ *       &lt;attribute name="max" type="{http://www.w3.org/2001/XMLSchema}string" /&gt;
+ *       &lt;attribute name="seed" type="{http://www.w3.org/2001/XMLSchema}string" /&gt;
+ *     &lt;/extension&gt;
+ *   &lt;/simpleContent&gt;
+ * &lt;/complexType&gt;
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "valueType", propOrder = {
+    "value"
+})
+public class ValueType {
+
+    @XmlValue
+    protected String value;
+    @XmlAttribute(name = "dist")
+    protected String dist;
+    @XmlAttribute(name = "min")
+    protected String min;
+    @XmlAttribute(name = "max")
+    protected String max;
+    @XmlAttribute(name = "seed")
+    protected String seed;
+
+    /**
+     * Gets the value of the value property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getValue() {
+        return value;
+    }
+
+    /**
+     * Sets the value of the value property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    /**
+     * Gets the value of the dist property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getDist() {
+        return dist;
+    }
+
+    /**
+     * Sets the value of the dist property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setDist(String value) {
+        this.dist = value;
+    }
+
+    /**
+     * Gets the value of the min property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getMin() {
+        return min;
+    }
+
+    /**
+     * Sets the value of the min property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setMin(String value) {
+        this.min = value;
+    }
+
+    /**
+     * Gets the value of the max property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getMax() {
+        return max;
+    }
+
+    /**
+     * Sets the value of the max property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setMax(String value) {
+        this.max = value;
+    }
+
+    /**
+     * Gets the value of the seed property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getSeed() {
+        return seed;
+    }
+
+    /**
+     * Sets the value of the seed property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setSeed(String value) {
+        this.seed = value;
+    }
+
+}
diff --git a/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java b/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
index e2120bb14..2c5f97e12 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
@@ -15,56 +15,77 @@
  *
  */
 
-//
-// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, vJAXB 2.1.10 
-// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 
+ //
+// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
+// See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
 // Any modifications to this file will be lost upon recompilation of the source schema. 
-// Generated on: 2011.12.28 at 11:42:38 PM EST 
+// Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
 
 package com.oltpbenchmark.api.templates;
 
-import jakarta.xml.bind.annotation.*;
 import java.util.ArrayList;
 import java.util.List;
+import jakarta.xml.bind.annotation.*;
+
 
 
 /**
- * <p>Java class for dialectType complex type.
- *
+ * <p>Java class for valuesType complex type.
+ * 
  * <p>The following schema fragment specifies the expected content contained within this class.
- *
+ * 
  * <pre>
- * &lt;complexType name="parameterTypesType">
- *   &lt;complexContent>
- *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
- *       &lt;sequence>
- *         &lt;element name="parameters_type" type="{}procedureType" maxOccurs="unbounded"/>
- *       &lt;/sequence>
- *     &lt;/restriction>
- *   &lt;/complexContent>
- * &lt;/complexType>
+ * &lt;complexType name="valuesType"&gt;
+ *   &lt;complexContent&gt;
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
+ *       &lt;sequence&gt;
+ *         &lt;element name="value" type="{}valueType" maxOccurs="unbounded"/&gt;
+ *       &lt;/sequence&gt;
+ *     &lt;/restriction&gt;
+ *   &lt;/complexContent&gt;
+ * &lt;/complexType&gt;
  * </pre>
+ * 
+ * 
  */
 @XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "valuesType", propOrder = {"value"})
+@XmlType(name = "valuesType", propOrder = {
+    "value"
+})
 public class ValuesType {
 
     @XmlElement(required = true)
-    protected List<String> value;
-    
+    protected List<ValueType> value;
 
     /**
      * Gets the value of the value property.
      * 
-     * Objects of the following type(s) are allowed in the list {@link String }
+     * <p>
+     * This accessor method returns a reference to the live list,
+     * not a snapshot. Therefore any modification you make to the
+     * returned list will be present inside the JAXB object.
+     * This is why there is not a <CODE>set</CODE> method for the value property.
+     * 
+     * <p>
+     * For example, to add a new item, do as follows:
+     * <pre>
+     *    getValue().add(newItem);
+     * </pre>
+     * 
+     * 
+     * <p>
+     * Objects of the following type(s) are allowed in the list
+     * {@link ValueType }
+     * 
+     * 
      */
-    public List<String> getValueList() {
-        if (this.value == null) {
-            this.value = new ArrayList<>();
+    public List<ValueType> getValue() {
+        if (value == null) {
+            value = new ArrayList<ValueType>();
         }
         return this.value;
     }
-    
+
 }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index 01569e28e..9de6cb151 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
@@ -18,6 +18,7 @@
 
 import java.io.FileInputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -45,12 +46,12 @@
 import com.oltpbenchmark.api.templates.ValuesType;
 import com.oltpbenchmark.api.templates.TemplateType;
 import com.oltpbenchmark.api.templates.TemplatesType;
+import com.oltpbenchmark.api.templates.ValueType;
 import com.oltpbenchmark.benchmarks.templated.procedures.GenericQuery;
 import com.oltpbenchmark.benchmarks.templated.procedures.GenericQuery.QueryTemplateInfo;
+import com.oltpbenchmark.benchmarks.templated.util.ComplexValue;
 import com.oltpbenchmark.benchmarks.templated.util.GenericQueryOperation;
 import com.oltpbenchmark.benchmarks.templated.util.TraceTransactionGenerator;
-import com.opencsv.CSVParser;
-import com.opencsv.CSVParserBuilder;
 
 import jakarta.xml.bind.JAXBContext;
 import jakarta.xml.bind.JAXBElement;
@@ -124,14 +125,25 @@ protected List<Worker<? extends BenchmarkModule>> makeWorkersImpl() {
                 // list of params.
                 List<GenericQueryOperation> list = new ArrayList<>();
                 String[] paramsTypes = info.getParamsTypes();
-                CSVParser parser = new CSVParserBuilder()
-                        .withQuoteChar('\'')
-                        .build();
-                for (String binding : info.getParamsValues()) {
-                    Object[] params = parser.parseLine(binding);
-                    assert paramsTypes.length == params.length;
+               
+                ComplexValue[] params = info.getParamsValues();
+                int paramsLen = params.length;
+                int typesLen = paramsTypes.length;
+
+                assert (paramsLen % typesLen) == 0;
+
+                
+                int subRange = paramsLen / typesLen;
+                if(paramsLen == typesLen){
                     list.add(new GenericQueryOperation(params));
+                } else {
+                    for(int j = 0; j < paramsLen; j+= subRange){
+                        ComplexValue[] subset = Arrays.copyOfRange(params, j, j+subRange);
+                        assert subset.length == typesLen;
+                        list.add(new GenericQueryOperation(subset));
+                    }
                 }
+                
                 generators.put(proc.getClass(), new TraceTransactionGenerator(list));
             }
 
@@ -170,38 +182,43 @@ private CustomClassLoader loadQueryTemplates(String file) {
             JAXBElement<TemplatesType> result = unmarshaller.unmarshal(streamSource, TemplatesType.class);
             TemplatesType templates = result.getValue();
 
-            for (TemplateType template : templates.getTemplateList()) {
+            for (TemplateType template : templates.getTemplate()) {
                 ImmutableParsedQueryTemplate.Builder b = ImmutableParsedQueryTemplate.builder();
                 b.name(template.getName());
                 b.query(template.getQuery());
-                b.paramsTypes(template.getTypes().getTypeList());
+                b.paramsTypes(template.getTypes().getType());
+            
                 for (ValuesType paramValue : template.getValues()) {
-                    b.addParamsValues(String.join(",", paramValue.getValueList()));
+                    for(ValueType value: paramValue.getValue()){
+                        b.addParamsValues(new ComplexValue(value.getDist(),value.getMin(),value.getMax(),value.getSeed(),value.getValue()));
+                    }  
                 }
 
                 ParsedQueryTemplate qt = b.build();
                 // Create and compile class.
                 final String s = """
                         package %s ;
+                        import %s ;
                         public final class %s extends %s {
                             @Override
                             public %s getQueryTemplateInfo() {
                                 return ImmutableQueryTemplateInfo.builder()
                                         .query(new %s(\"%s\"))
                                         .paramsTypes(new String[] {%s})
-                                        .paramsValues(new String[] {%s})
+                                        .paramsValues(new ComplexValue[] {%s})
                                         .build();
                             }
                         }
                         """.formatted(
                         GenericQuery.class.getPackageName(),
+                        ComplexValue.class.getCanonicalName(),
                         qt.getName(),
                         GenericQuery.class.getCanonicalName(),
                         QueryTemplateInfo.class.getCanonicalName(),
                         SQLStmt.class.getCanonicalName(),
                         StringEscapeUtils.escapeJava(qt.getQuery()),
                         getParamsString(qt.getParamsTypes()),
-                        getParamsString(qt.getParamsValues()));
+                        buildComplexValueString(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();
@@ -225,6 +242,21 @@ private String getParamsString(List<String> params) {
         return result.isEmpty() ? "" : result.substring(0, result.length() - 1);
     }
 
+    private String buildComplexValueString(List<ComplexValue> params) {
+        String result = "";
+        for (ComplexValue param : params) {
+            result += "new ComplexValue(" 
+                    + "\"" + param.getDist() + "\"" + ","
+                    + "\"" + param.getMin() + "\"" + ","
+                    + "\"" + param.getMax() + "\"" + ","
+                    + "\"" + param.getSeed() + "\"" + ","
+                    + "\"" + StringEscapeUtils.escapeJava(param.getValue()) + "\""
+                    + "),";
+        }
+        return result.isEmpty() ? "" : result.substring(0,result.length()-1);
+    }
+
+
     private static class CustomClassLoader extends ClassLoader {
 
         private final Map<String, Class<?>> classes = new HashMap<>();
@@ -272,7 +304,7 @@ default List<String> getParamsTypes() {
 
         /** Potential query parameter values. */
         @Value.Default
-        default List<String> getParamsValues() {
+        default List<ComplexValue> getParamsValues() {
             return List.of();
         }
     }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedWorker.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedWorker.java
index 16118ad90..375ef2907 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedWorker.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedWorker.java
@@ -49,8 +49,7 @@ 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(),
-                        generator.nextTransaction().getRandomGenHashMap());
+                proc.run(conn, generator.nextTransaction().getParams());
             } else {
                 // If the generator has no transactions, there are no parameters.
                 proc.run(conn);
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 2118234c4..3fa909933 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -24,7 +24,6 @@
 import java.sql.Time;
 import java.sql.Timestamp;
 import java.sql.Types;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Random;
 
@@ -34,6 +33,7 @@
 
 import com.oltpbenchmark.api.Procedure;
 import com.oltpbenchmark.api.SQLStmt;
+import com.oltpbenchmark.benchmarks.templated.util.ComplexValue;
 import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
 import com.oltpbenchmark.distributions.ZipfianGenerator;
 import com.oltpbenchmark.util.TextGenerator;
@@ -43,9 +43,9 @@ 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, HashMap<Integer, Object> randomGenerators)
+    public void run(Connection conn, List<ComplexValue> params)
             throws SQLException {
-        try (PreparedStatement stmt = getStatement(conn, params, randomGenerators);
+        try (PreparedStatement stmt = getStatement(conn, params);
                 ResultSet rs = stmt.executeQuery()) {
             while (rs.next()) {
                 // do nothing
@@ -67,35 +67,60 @@ public void run(Connection conn) throws SQLException {
         conn.commit();
     }
 
-    public PreparedStatement getStatement(Connection conn, List<Object> params,
-            HashMap<Integer, Object> randomGenerators) throws SQLException {
+    public PreparedStatement getStatement(Connection conn, List<ComplexValue> params) 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")) {
+
+            ComplexValue param = params.get(i);
+            boolean hasDist = param.getDist().length() > 0;
+            boolean hasValue = param.getValue().length() > 0;
+
+            if ((!hasDist && !hasValue) || 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;
+            
+            } else if (hasDist) {
+                String distribution = param.getDist();
+                switch (distribution) {
                     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;
+                        Random rnd = (Random) param.getGen();
+
+                        switch (paramsTypes[i].toLowerCase()) {
+                            case "integer":
+                                int min = param.getMin().intValue();
+                                int max = param.getMax().intValue();
+                                stmt.setInt(i+1, rnd.nextInt(min,max));
+                                break;
+                            case "float":
+                            case "real":
+                                float minF = Float.parseFloat(param.getMinString());
+                                float maxF = Float.parseFloat(param.getMaxString());
+                                stmt.setFloat(i+1, rnd.nextFloat(minF,maxF));
+                                break;
+                            case "bigint":
+                                stmt.setLong(i+1,rnd.nextLong(param.getMin(), param.getMax()));
+                            case "string": 
+                                int maxLen = param.getMax().intValue();
+                                stmt.setString(i + 1, TextGenerator.randomStr(rnd, maxLen));
+                                break;
+                            case "timestamp":
+                                stmt.setTimestamp(i + 1, new Timestamp(rnd.nextLong(param.getMin(), param.getMax())));
+                                break;
+                            case "date":
+                                stmt.setDate(i + 1, new Date(rnd.nextLong(param.getMin(), param.getMax())));
+                                break;
+                            case "time":
+                                stmt.setTime(i + 1, new Time(rnd.nextLong(param.getMin(), param.getMax())));
+                                break;
+                            default:
+                                throw new RuntimeException("The type '" + paramsTypes[i] + "' is not supported by the '" + distribution + "' distribution");
+                        }
                         break;
                     case "binomial":
+                        break;
+                     /*
                         minI = Integer.parseInt(params.get(index + 1).toString());
                         maxI = Integer.parseInt(params.get(index + 2).toString());
                         Random rng = (Random) randomGenerators.get(index);
@@ -103,10 +128,18 @@ public PreparedStatement getStatement(Connection conn, List<Object> params,
                         do {
                             bVal = (int) (minI + Math.abs(rng.nextGaussian()) * maxI);
                         } while (bVal > maxI || bVal < minI);
-
                         stmt.setInt(i + 1, bVal);
                         j += 2;
                         break;
+
+                    case "zipf":
+                        ZipfianGenerator zipfGen = (ZipfianGenerator) randomGenerators.get(index);
+                        stmt.setInt(i + 1, zipfGen.nextInt());
+                        zipfGen.n
+                        j += 2;
+                        break;
+                    
+                   
                     case "scrambled":
                         ScrambledZipfianGenerator scramZipf = (ScrambledZipfianGenerator) randomGenerators.get(index);
                         stmt.setInt(i + 1, scramZipf.nextInt());
@@ -129,28 +162,25 @@ public PreparedStatement getStatement(Connection conn, List<Object> params,
                     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' ");
+                        throw new RuntimeException("No suitable distribution found: " + distribution);
                 }
 
             } 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?
-                    // Or does it need a special marker like "$null" to signify a NULL value?
-                    Object param = params.get(i);
-                    stmt.setObject(i + 1, param,
+                    Object val = param.getValue();
+                    stmt.setObject(i + 1, val,
                             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));
+                                    + param.getValue());
                 }
             }
         }
+        System.out.println(stmt.toString());
         return stmt;
     }
 
@@ -166,7 +196,7 @@ public interface QueryTemplateInfo {
         String[] getParamsTypes();
 
         /** Potential query parameter values. */
-        String[] getParamsValues();
+        ComplexValue[] getParamsValues();
     }
 
 }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ComplexValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ComplexValue.java
new file mode 100644
index 000000000..bf1a5585d
--- /dev/null
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ComplexValue.java
@@ -0,0 +1,82 @@
+package com.oltpbenchmark.benchmarks.templated.util;
+
+import java.util.Random;
+
+import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
+import com.oltpbenchmark.distributions.ZipfianGenerator;
+
+public class ComplexValue {
+    String dist;
+    Long min;
+    Long max;
+    Long seed;
+    String value;
+    String minS;
+    String maxS;
+
+    public final Object randGen;
+
+
+    public ComplexValue(String dist, String min, String max, String seed, String value) {
+        this.dist = dist == null ? "" : dist;
+        this.min = min == null ? 0 : Long.parseLong(min);
+        this.max = max == null ? 1 : Long.parseLong(max);
+        this.seed = seed == null ? 0 : Long.parseLong(seed);
+        this.value = value;
+        this.randGen = createGen(dist,this.min,this.max,this.seed);
+        this.minS = min;
+        this.maxS = max;
+    }
+
+    private Object createGen(String distribution, Long min, Long max, Long seed) {
+
+        if(distribution == null || distribution.length() < 1) return null;
+
+        switch (distribution) {
+            case "uniform":
+            case "binomial":
+                return new Random(seed);
+            case "zipf":
+                return new ZipfianGenerator(new Random(seed),min,max);
+            case "scrambled":
+                return new ScrambledZipfianGenerator(min,max);
+            default:
+                throw new RuntimeException(
+                "The distribution: '" + distribution + "' is not supported. Currently supported are 'zipf' | 'scrambled' | 'normal' | 'uniform'");
+        }
+
+    }
+
+
+    public String getDist(){
+        return dist;
+    }
+
+    public Long getMin(){
+        return min;
+    }
+
+    public Long getMax(){
+        return max;
+    }
+
+    public Long getSeed(){
+        return seed;
+    }
+
+    public String getValue(){
+        return value;
+    }
+
+    public String getMinString(){
+        return this.minS;
+    }
+
+    public String getMaxString(){
+        return this.maxS;
+    }
+
+    public Object getGen(){
+        return this.randGen;
+    }
+}
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
index d6d380cad..7c570926a 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
@@ -17,69 +17,24 @@
 package com.oltpbenchmark.benchmarks.templated.util;
 
 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 final List<ComplexValue> params;
+  
 
-    public GenericQueryOperation(Object[] params) {
+    public GenericQueryOperation(ComplexValue[] params) {
         super();
-        this.params = Collections.unmodifiableList(Arrays.asList(params));
-        this.randomGenerators = this.mapRandom();
+        this.params = Arrays.asList(params);
     }
 
-    public List<Object> getParams() {
+    public List<ComplexValue> 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;
-    }
 }
diff --git a/src/main/resources/templates.xsd b/src/main/resources/templates.xsd
index a2bdf7763..dc1091af3 100644
--- a/src/main/resources/templates.xsd
+++ b/src/main/resources/templates.xsd
@@ -6,7 +6,7 @@
     bindings. It's easy to do:
 
     cd src/
-    xjc -p com.oltpbenchmark.api.templates com/oltpbenchmark/api/templates.xsd
+    xjc -p main.java.com.oltpbenchmark.api.templates main/resources/templates.xsd
 
     You can check that changes to this file produce a valid schema using
     the public tool at http://www.w3.org/2001/03/webdata/xsv.
@@ -46,8 +46,22 @@
     <!-- <values> -->
     <xsd:complexType name="valuesType">
         <xsd:sequence>
-            <xsd:element name="value" type="xsd:string" minOccurs="1" maxOccurs="unbounded"/>
+            <xsd:element name="value" type="valueType" minOccurs="1" maxOccurs="unbounded"/>
         </xsd:sequence>
     </xsd:complexType>
 
+
+<!-- <value> -->
+  <xsd:complexType name="valueType">
+    <xsd:simpleContent>
+      <xsd:extension base="xsd:string">
+        <xsd:attribute name="dist" type="xsd:string"/>
+        <xsd:attribute name="min" type="xsd:string"/>
+        <xsd:attribute name="max" type="xsd:string"/>
+        <xsd:attribute name="seed" type="xsd:string"/>
+      </xsd:extension>
+    </xsd:simpleContent>
+  </xsd:complexType>
+
 </xsd:schema>
+

From 33bef1e4708f532116703649b5c7890e9510cad2 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Mon, 20 Nov 2023 14:55:01 +0100
Subject: [PATCH 08/24] Switched Dist and Type, changed subarray calculation

---
 data/templated/example.xml                    |   3 +
 .../templated/TemplatedBenchmark.java         |  27 +-
 .../templated/procedures/GenericQuery.java    | 243 +++++++++++++-----
 3 files changed, 195 insertions(+), 78 deletions(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index a3f96a482..116e8a0f0 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -69,5 +69,8 @@
       <values>
          <value dist="uniform" min="0" max="9999" seed="12"></value>
       </values>
+      <values>
+         <value dist="zipf" min="0" max="9999" seed="12"></value>
+      </values>
    </template>
 </templates>
\ No newline at end of file
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index 9de6cb151..0c0f44c6b 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
@@ -125,25 +125,24 @@ protected List<Worker<? extends BenchmarkModule>> makeWorkersImpl() {
                 // list of params.
                 List<GenericQueryOperation> list = new ArrayList<>();
                 String[] paramsTypes = info.getParamsTypes();
-               
+
                 ComplexValue[] params = info.getParamsValues();
                 int paramsLen = params.length;
                 int typesLen = paramsTypes.length;
 
                 assert (paramsLen % typesLen) == 0;
 
-                
-                int subRange = paramsLen / typesLen;
-                if(paramsLen == typesLen){
+                if (paramsLen == typesLen) {
                     list.add(new GenericQueryOperation(params));
                 } else {
-                    for(int j = 0; j < paramsLen; j+= subRange){
-                        ComplexValue[] subset = Arrays.copyOfRange(params, j, j+subRange);
+                    int numSplits = paramsLen / typesLen;
+                    for (int j = 0; j < numSplits; j += 1) {
+                        ComplexValue[] subset = Arrays.copyOfRange(params, j * typesLen, j * typesLen + typesLen);
                         assert subset.length == typesLen;
                         list.add(new GenericQueryOperation(subset));
                     }
                 }
-                
+
                 generators.put(proc.getClass(), new TraceTransactionGenerator(list));
             }
 
@@ -187,11 +186,12 @@ private CustomClassLoader loadQueryTemplates(String file) {
                 b.name(template.getName());
                 b.query(template.getQuery());
                 b.paramsTypes(template.getTypes().getType());
-            
+
                 for (ValuesType paramValue : template.getValues()) {
-                    for(ValueType value: paramValue.getValue()){
-                        b.addParamsValues(new ComplexValue(value.getDist(),value.getMin(),value.getMax(),value.getSeed(),value.getValue()));
-                    }  
+                    for (ValueType value : paramValue.getValue()) {
+                        b.addParamsValues(new ComplexValue(value.getDist(), value.getMin(), value.getMax(),
+                                value.getSeed(), value.getValue()));
+                    }
                 }
 
                 ParsedQueryTemplate qt = b.build();
@@ -245,7 +245,7 @@ private String getParamsString(List<String> params) {
     private String buildComplexValueString(List<ComplexValue> params) {
         String result = "";
         for (ComplexValue param : params) {
-            result += "new ComplexValue(" 
+            result += "new ComplexValue("
                     + "\"" + param.getDist() + "\"" + ","
                     + "\"" + param.getMin() + "\"" + ","
                     + "\"" + param.getMax() + "\"" + ","
@@ -253,10 +253,9 @@ private String buildComplexValueString(List<ComplexValue> params) {
                     + "\"" + StringEscapeUtils.escapeJava(param.getValue()) + "\""
                     + "),";
         }
-        return result.isEmpty() ? "" : result.substring(0,result.length()-1);
+        return result.isEmpty() ? "" : result.substring(0, result.length() - 1);
     }
 
-
     private static class CustomClassLoader extends ClassLoader {
 
         private final Map<String, Class<?>> classes = new HashMap<>();
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 3fa909933..81fa4d319 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -80,93 +80,208 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
 
             if ((!hasDist && !hasValue) || paramsTypes[i].equalsIgnoreCase("NULL")) {
                 stmt.setNull(i + 1, Types.NULL);
-            
+
             } else if (hasDist) {
                 String distribution = param.getDist();
-                switch (distribution) {
-                    case "uniform":
-                        Random rnd = (Random) param.getGen();
+                String paramType = paramsTypes[i].toLowerCase();
+                switch (paramType) {
+                    case "integer":
+                        int min = param.getMin().intValue();
+                        int max = param.getMax().intValue();
+
+                        switch (distribution) {
 
-                        switch (paramsTypes[i].toLowerCase()) {
-                            case "integer":
-                                int min = param.getMin().intValue();
-                                int max = param.getMax().intValue();
-                                stmt.setInt(i+1, rnd.nextInt(min,max));
+                            case "uniform":
+                                Random uniformRand = (Random) param.getGen();
+                                stmt.setInt(i + 1, uniformRand.nextInt(min, max));
                                 break;
-                            case "float":
-                            case "real":
-                                float minF = Float.parseFloat(param.getMinString());
-                                float maxF = Float.parseFloat(param.getMaxString());
-                                stmt.setFloat(i+1, rnd.nextFloat(minF,maxF));
+                            case "binomial":
+                                Random binomialRandom = (Random) param.getGen();
+                                int bVal;
+                                do {
+                                    bVal = (int) (min + Math.abs(binomialRandom.nextGaussian()) * max);
+                                } while (bVal > max || bVal < min);
+
+                                stmt.setInt(i + 1, bVal);
                                 break;
-                            case "bigint":
-                                stmt.setLong(i+1,rnd.nextLong(param.getMin(), param.getMax()));
-                            case "string": 
-                                int maxLen = param.getMax().intValue();
-                                stmt.setString(i + 1, TextGenerator.randomStr(rnd, maxLen));
+                            case "zipf":
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                stmt.setInt(i + 1, zipfGen.nextInt());
                                 break;
-                            case "timestamp":
-                                stmt.setTimestamp(i + 1, new Timestamp(rnd.nextLong(param.getMin(), param.getMax())));
+                            case "scrambled":
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                stmt.setInt(i + 1, scramGen.nextInt());
                                 break;
-                            case "date":
-                                stmt.setDate(i + 1, new Date(rnd.nextLong(param.getMin(), param.getMax())));
+                            default:
+                                throw new RuntimeException(
+                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                        }
+                        break;
+                    case "float":
+                    case "real":
+                        float minF = Float.parseFloat(param.getMinString());
+                        float maxF = Float.parseFloat(param.getMaxString());
+                        switch (distribution) {
+
+                            case "uniform":
+                                Random uniformRand = (Random) param.getGen();
+                                stmt.setFloat(i + 1, uniformRand.nextFloat(minF, maxF));
                                 break;
-                            case "time":
-                                stmt.setTime(i + 1, new Time(rnd.nextLong(param.getMin(), param.getMax())));
+                            case "binomial":
+                                Random binomialRandom = (Random) param.getGen();
+                                float fVal;
+                                do {
+                                    fVal = (float) (minF + Math.abs(binomialRandom.nextGaussian()) * maxF);
+                                } while (fVal > maxF || fVal < minF);
+
+                                stmt.setFloat(i + 1, fVal);
                                 break;
                             default:
-                                throw new RuntimeException("The type '" + paramsTypes[i] + "' is not supported by the '" + distribution + "' distribution");
+                                throw new RuntimeException(
+                                        "Distribution: " + distribution + " not supported for type: " + paramType);
                         }
                         break;
-                    case "binomial":
-                        break;
-                     /*
-                        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 "bigint":
+                        Long minL = param.getMin();
+                        Long maxL = param.getMax();
+                        switch (distribution) {
 
-                    case "zipf":
-                        ZipfianGenerator zipfGen = (ZipfianGenerator) randomGenerators.get(index);
-                        stmt.setInt(i + 1, zipfGen.nextInt());
-                        zipfGen.n
-                        j += 2;
-                        break;
-                    
-                   
-                    case "scrambled":
-                        ScrambledZipfianGenerator scramZipf = (ScrambledZipfianGenerator) randomGenerators.get(index);
-                        stmt.setInt(i + 1, scramZipf.nextInt());
-                        j += 2;
+                            case "uniform":
+                                Random uniformRand = (Random) param.getGen();
+                                stmt.setLong(i + 1, uniformRand.nextLong(minL, maxL));
+                                break;
+                            case "binomial":
+                                Random binomialRandom = (Random) param.getGen();
+                                Long lVal;
+                                do {
+                                    lVal = Double.valueOf(minL + Math.abs(binomialRandom.nextGaussian()) * maxL)
+                                            .longValue();
+                                } while (lVal > maxL || lVal < minL);
+
+                                stmt.setLong(i + 1, lVal);
+                                break;
+                            case "zipf":
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                stmt.setLong(i + 1, zipfGen.nextLong());
+                                break;
+                            case "scrambled":
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                stmt.setLong(i + 1, scramGen.nextLong());
+                                break;
+                            default:
+                                throw new RuntimeException(
+                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                        }
                         break;
+                    case "varchar":
                     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;
+                        switch (distribution) {
+                            case "uniform":
+                                Random strRandom = (Random) param.getGen();
+                                stmt.setString(i + 1, TextGenerator.randomStr(strRandom, param.getMax().intValue()));
+                                break;
+                            default:
+                                throw new RuntimeException(
+                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                        }
                         break;
-                    case "datetime":
                     case "timestamp":
-                        stmt.setTimestamp(i + 1, new Timestamp(System.currentTimeMillis()));
+                        Long stampMin = param.getMin();
+                        Long stampMax = param.getMax();
+                        switch (distribution) {
+                            case "uniform":
+                                Random uniformRand = (Random) param.getGen();
+                                stmt.setTimestamp(i + 1, new Timestamp(uniformRand.nextLong(stampMin, stampMax)));
+                                break;
+                            case "binomial":
+                                Random binomialRandom = (Random) param.getGen();
+                                Long lVal;
+                                do {
+                                    lVal = Double.valueOf(stampMin + Math.abs(binomialRandom.nextGaussian()) * stampMax)
+                                            .longValue();
+                                } while (lVal > stampMax || lVal < stampMin);
+
+                                stmt.setTimestamp(i + 1, new Timestamp(lVal));
+                                break;
+                            case "zipf":
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                stmt.setTimestamp(i + 1, new Timestamp(zipfGen.nextLong()));
+                                break;
+                            case "scrambled":
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                stmt.setTimestamp(i + 1, new Timestamp(scramGen.nextLong()));
+                                break;
+                            default:
+                                throw new RuntimeException(
+                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                        }
                         break;
                     case "date":
-                        stmt.setDate(i + 1, new Date(System.currentTimeMillis()));
+                        Long dateMin = param.getMin();
+                        Long dateMax = param.getMax();
+                        switch (distribution) {
+                            case "uniform":
+                                Random uniformRand = (Random) param.getGen();
+                                stmt.setDate(i + 1, new Date(uniformRand.nextLong(dateMin, dateMax)));
+                                break;
+                            case "binomial":
+                                Random binomialRandom = (Random) param.getGen();
+                                Long lVal;
+                                do {
+                                    lVal = Double.valueOf(dateMin + Math.abs(binomialRandom.nextGaussian()) * dateMax)
+                                            .longValue();
+                                } while (lVal > dateMax || lVal < dateMin);
+
+                                stmt.setDate(i + 1, new Date(lVal));
+                                break;
+                            case "zipf":
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                stmt.setDate(i + 1, new Date(zipfGen.nextLong()));
+                                break;
+                            case "scrambled":
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                stmt.setDate(i + 1, new Date(scramGen.nextLong()));
+                                break;
+                            default:
+                                throw new RuntimeException(
+                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                        }
                         break;
                     case "time":
-                        stmt.setTime(i + 1, new Time(System.currentTimeMillis()));
+                        Long timeMin = param.getMin();
+                        Long timeMax = param.getMax();
+                        switch (distribution) {
+                            case "uniform":
+                                Random uniformRand = (Random) param.getGen();
+                                stmt.setTime(i + 1, new Time(uniformRand.nextLong(timeMin, timeMax)));
+                                break;
+                            case "binomial":
+                                Random binomialRandom = (Random) param.getGen();
+                                Long lVal;
+                                do {
+                                    lVal = Double.valueOf(timeMin + Math.abs(binomialRandom.nextGaussian()) * timeMax)
+                                            .longValue();
+                                } while (lVal > timeMax || lVal < timeMin);
+
+                                stmt.setTime(i + 1, new Time(lVal));
+                                break;
+                            case "zipf":
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                stmt.setTime(i + 1, new Time(zipfGen.nextLong()));
+                                break;
+                            case "scrambled":
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                stmt.setTime(i + 1, new Time(scramGen.nextLong()));
+                                break;
+                            default:
+                                throw new RuntimeException(
+                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                        }
                         break;
-                        */
                     default:
-                        throw new RuntimeException("No suitable distribution found: " + distribution);
+                        throw new RuntimeException(
+                                "Support for distributions for the type: " + paramType + " is current not implemented");
                 }
-
             } else {
                 try {
                     Object val = param.getValue();
@@ -180,8 +295,8 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                 }
             }
         }
-        System.out.println(stmt.toString());
         return stmt;
+
     }
 
     public abstract QueryTemplateInfo getQueryTemplateInfo();

From 573967c58b85948f385b502d450a273115a7aec4 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Wed, 29 Nov 2023 15:40:16 +0100
Subject: [PATCH 09/24] Renamings and Documentation

---
 config/postgres/sample_templated_config.xml   |  2 +-
 .../api/templates/TemplateType.java           | 63 ++++++------
 .../api/templates/TemplatesType.java          | 21 ++--
 .../api/templates/TypesType.java              | 17 ++--
 .../api/templates/ValuesType.java             | 21 ++--
 .../benchmarks/templated/README.md            | 47 ++++++++-
 .../templated/TemplatedBenchmark.java         | 22 ++---
 .../templated/procedures/GenericQuery.java    | 56 +++++------
 .../templated/util/ComplexValue.java          | 82 ---------------
 .../templated/util/GenericQueryOperation.java |  7 +-
 .../templated/util/TemplatedValue.java        | 99 +++++++++++++++++++
 11 files changed, 252 insertions(+), 185 deletions(-)
 delete mode 100644 src/main/java/com/oltpbenchmark/benchmarks/templated/util/ComplexValue.java
 create mode 100644 src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java

diff --git a/config/postgres/sample_templated_config.xml b/config/postgres/sample_templated_config.xml
index 9ab417941..0e09ffc9c 100644
--- a/config/postgres/sample_templated_config.xml
+++ b/config/postgres/sample_templated_config.xml
@@ -6,7 +6,7 @@
     <driver>org.postgresql.Driver</driver>
     <url>jdbc:postgresql://localhost:5432/benchbase?sslmode=disable&amp;ApplicationName=templated&amp;reWriteBatchedInserts=true</url>
     <username>admin</username>
-    <password>password</password>
+    <password>admin</password>
     <isolation>TRANSACTION_SERIALIZABLE</isolation>
     <batchsize>128</batchsize>
 
diff --git a/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java b/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
index 6a6cae997..26b6116be 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
@@ -15,26 +15,26 @@
  *
  */
 
- //
+//
 // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
 // See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
 // Any modifications to this file will be lost upon recompilation of the source schema. 
 // Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
-
 package com.oltpbenchmark.api.templates;
 
 import java.util.ArrayList;
 import java.util.List;
 import jakarta.xml.bind.annotation.*;
 
-
-
 /**
- * <p>Java class for templateType complex type.
+ * <p>
+ * Java class for templateType complex type.
  * 
- * <p>The following schema fragment specifies the expected content contained within this class.
+ * <p>
+ * The following schema fragment specifies the expected content contained within
+ * this class.
  * 
  * <pre>
  * &lt;complexType name="templateType"&gt;
@@ -55,9 +55,9 @@
  */
 @XmlAccessorType(XmlAccessType.FIELD)
 @XmlType(name = "templateType", propOrder = {
-    "query",
-    "types",
-    "values"
+        "query",
+        "types",
+        "values"
 })
 public class TemplateType {
 
@@ -74,9 +74,9 @@ public class TemplateType {
      * Gets the value of the query property.
      * 
      * @return
-     *     possible object is
-     *     {@link String }
-     *     
+     *         possible object is
+     *         {@link String }
+     * 
      */
     public String getQuery() {
         return query;
@@ -86,9 +86,9 @@ public String getQuery() {
      * Sets the value of the query property.
      * 
      * @param value
-     *     allowed object is
-     *     {@link String }
-     *     
+     *              allowed object is
+     *              {@link String }
+     * 
      */
     public void setQuery(String value) {
         this.query = value;
@@ -98,21 +98,21 @@ public void setQuery(String value) {
      * Gets the value of the types property.
      * 
      * @return
-     *     possible object is
-     *     {@link TypesType }
-     *     
+     *         possible object is
+     *         {@link TypesType }
+     * 
      */
     public TypesType getTypes() {
-        return types;
+        return this.types;
     }
 
     /**
      * Sets the value of the types property.
      * 
      * @param value
-     *     allowed object is
-     *     {@link TypesType }
-     *     
+     *              allowed object is
+     *              {@link TypesType }
+     * 
      */
     public void setTypes(TypesType value) {
         this.types = value;
@@ -129,8 +129,9 @@ public void setTypes(TypesType value) {
      * 
      * <p>
      * For example, to add a new item, do as follows:
+     * 
      * <pre>
-     *    getValues().add(newItem);
+     * getValues().add(newItem);
      * </pre>
      * 
      * 
@@ -141,8 +142,8 @@ public void setTypes(TypesType value) {
      * 
      */
     public List<ValuesType> getValues() {
-        if (values == null) {
-            values = new ArrayList<ValuesType>();
+        if (this.values == null) {
+            this.values = new ArrayList<ValuesType>();
         }
         return this.values;
     }
@@ -151,9 +152,9 @@ public List<ValuesType> getValues() {
      * Gets the value of the name property.
      * 
      * @return
-     *     possible object is
-     *     {@link String }
-     *     
+     *         possible object is
+     *         {@link String }
+     * 
      */
     public String getName() {
         return name;
@@ -163,9 +164,9 @@ public String getName() {
      * Sets the value of the name property.
      * 
      * @param value
-     *     allowed object is
-     *     {@link String }
-     *     
+     *              allowed object is
+     *              {@link String }
+     * 
      */
     public void setName(String value) {
         this.name = value;
diff --git a/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java b/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
index c0d573cce..40d71291e 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
@@ -15,26 +15,26 @@
  *
  */
 
- //
+//
 // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
 // See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
 // Any modifications to this file will be lost upon recompilation of the source schema. 
 // Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
-
 package com.oltpbenchmark.api.templates;
 
 import java.util.ArrayList;
 import java.util.List;
 import jakarta.xml.bind.annotation.*;
 
-
-
 /**
- * <p>Java class for templatesType complex type.
+ * <p>
+ * Java class for templatesType complex type.
  * 
- * <p>The following schema fragment specifies the expected content contained within this class.
+ * <p>
+ * The following schema fragment specifies the expected content contained within
+ * this class.
  * 
  * <pre>
  * &lt;complexType name="templatesType"&gt;
@@ -52,7 +52,7 @@
  */
 @XmlAccessorType(XmlAccessType.FIELD)
 @XmlType(name = "templatesType", propOrder = {
-    "template"
+        "template"
 })
 public class TemplatesType {
 
@@ -70,8 +70,9 @@ public class TemplatesType {
      * 
      * <p>
      * For example, to add a new item, do as follows:
+     * 
      * <pre>
-     *    getTemplate().add(newItem);
+     * getTemplate().add(newItem);
      * </pre>
      * 
      * 
@@ -82,8 +83,8 @@ public class TemplatesType {
      * 
      */
     public List<TemplateType> getTemplate() {
-        if (template == null) {
-            template = new ArrayList<TemplateType>();
+        if (this.template == null) {
+            this.template = new ArrayList<TemplateType>();
         }
         return this.template;
     }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/TypesType.java b/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
index 68405ed61..28ff0f284 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
@@ -22,7 +22,6 @@
 // Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
-
 package com.oltpbenchmark.api.templates;
 
 import java.util.ArrayList;
@@ -30,9 +29,12 @@
 import jakarta.xml.bind.annotation.*;
 
 /**
- * <p>Java class for typesType complex type.
+ * <p>
+ * Java class for typesType complex type.
  * 
- * <p>The following schema fragment specifies the expected content contained within this class.
+ * <p>
+ * The following schema fragment specifies the expected content contained within
+ * this class.
  * 
  * <pre>
  * &lt;complexType name="typesType"&gt;
@@ -50,7 +52,7 @@
  */
 @XmlAccessorType(XmlAccessType.FIELD)
 @XmlType(name = "typesType", propOrder = {
-    "type"
+        "type"
 })
 public class TypesType {
 
@@ -68,8 +70,9 @@ public class TypesType {
      * 
      * <p>
      * For example, to add a new item, do as follows:
+     * 
      * <pre>
-     *    getType().add(newItem);
+     * getType().add(newItem);
      * </pre>
      * 
      * 
@@ -80,8 +83,8 @@ public class TypesType {
      * 
      */
     public List<String> getType() {
-        if (type == null) {
-            type = new ArrayList<String>();
+        if (this.type == null) {
+            this.type = new ArrayList<>();
         }
         return this.type;
     }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java b/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
index 2c5f97e12..9062e23e7 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
@@ -15,26 +15,26 @@
  *
  */
 
- //
+//
 // This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.3.0.1 
 // See <a href="https://javaee.github.io/jaxb-v2/">https://javaee.github.io/jaxb-v2/</a> 
 // Any modifications to this file will be lost upon recompilation of the source schema. 
 // Generated on: 2023.11.16 at 08:29:59 AM UTC 
 //
 
-
 package com.oltpbenchmark.api.templates;
 
 import java.util.ArrayList;
 import java.util.List;
 import jakarta.xml.bind.annotation.*;
 
-
-
 /**
- * <p>Java class for valuesType complex type.
+ * <p>
+ * Java class for valuesType complex type.
  * 
- * <p>The following schema fragment specifies the expected content contained within this class.
+ * <p>
+ * The following schema fragment specifies the expected content contained within
+ * this class.
  * 
  * <pre>
  * &lt;complexType name="valuesType"&gt;
@@ -52,7 +52,7 @@
  */
 @XmlAccessorType(XmlAccessType.FIELD)
 @XmlType(name = "valuesType", propOrder = {
-    "value"
+        "value"
 })
 public class ValuesType {
 
@@ -70,8 +70,9 @@ public class ValuesType {
      * 
      * <p>
      * For example, to add a new item, do as follows:
+     * 
      * <pre>
-     *    getValue().add(newItem);
+     * getValue().add(newItem);
      * </pre>
      * 
      * 
@@ -82,8 +83,8 @@ public class ValuesType {
      * 
      */
     public List<ValueType> getValue() {
-        if (value == null) {
-            value = new ArrayList<ValueType>();
+        if (this.value == null) {
+            this.value = new ArrayList<ValueType>();
         }
         return this.value;
     }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
index 38d919f69..c4004c84b 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
@@ -34,7 +34,8 @@ The file path for the XML template has to be defined in the workload configurati
 
 An example configuration can be found in [`config/sqlserver/sample_template_config.xml`](../../../../../../../config/sqlserver/sample_templated_config.xml).
 
-> Since the templated benchmark is meant to flexibly support a myriad of different database schemas, it doesn't *currently* support the `init` and `load` phases.
+> Since the templated benchmark is meant to flexibly support a myriad of different database schemas, it doesn't _currently_ support the `init` and `load` phases.
+
 <!-- TODO: Add support for init/load phases? -->
 
 The example can be executed if a loaded TPC-C instance is used as JDBC endpoint.
@@ -54,3 +55,47 @@ java -jar benchbase.jar -b templated -c config/sqlserver/sample_templated_config
 ```
 
 > For additional examples, please refer to the build pipeline definition in the [`maven.yml`](../../../../../../../.github/workflows/maven.yml#L423) Github Actions workflow file.
+
+## Value Distributions
+
+In order to support more variety in templated queries, it is possible to use a whole distribution of values instead of a single static value in a templated query
+
+Each time the query is run, a different value will substitute the `?`.
+
+```xml
+<templates>
+    <template name="MyTemplate">
+        <query><![CDATA[SELECT * FROM MyTable WHERE id = ?]]></query>
+        <types>
+            <type>INTEGER</type>
+        </types>
+        <values>
+            <value dist="uniform" min="0" max="1000" seed="1"/>
+        </values>
+         <values>
+            <value dist="zipf" max="1000" seed="1"/>
+        </values>
+    </template>
+    <!-- ... -->
+<templates>
+```
+
+The distributions are dependent on the type of the value. Currently, the following type-distributions pairs are supported:
+| Type | uniform | binomial | zipfian | scrambled zipfian |
+|---|:---:|:---:|:---:|:---:|
+| INTEGER | X | X | X | X |
+| FLOAT / REAL | X | X|- | - |
+| BIGINT | X | X | X | X |
+| VARCHAR / STRING | X | -| -| -|
+| TIMESTAMP | X | X |X |X |
+| DATE | X | X| X| X|
+| TIME | X |X | X| X|
+
+The following properties can be set on the value:
+
+-   dist _The distribution of the values_
+-   min _The minimum value the generator can produce. Defaults to 0_
+-   max _The maximum value the generator can produce. Defaults to 1_
+-   seed _A seed for the generator to ensure consistency_
+
+For Timestamps, Dates and Times, the min and max values must be converted to a long (milliseconds)
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index 0c0f44c6b..133f36d92 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
@@ -49,7 +49,7 @@
 import com.oltpbenchmark.api.templates.ValueType;
 import com.oltpbenchmark.benchmarks.templated.procedures.GenericQuery;
 import com.oltpbenchmark.benchmarks.templated.procedures.GenericQuery.QueryTemplateInfo;
-import com.oltpbenchmark.benchmarks.templated.util.ComplexValue;
+import com.oltpbenchmark.benchmarks.templated.util.TemplatedValue;
 import com.oltpbenchmark.benchmarks.templated.util.GenericQueryOperation;
 import com.oltpbenchmark.benchmarks.templated.util.TraceTransactionGenerator;
 
@@ -126,7 +126,7 @@ protected List<Worker<? extends BenchmarkModule>> makeWorkersImpl() {
                 List<GenericQueryOperation> list = new ArrayList<>();
                 String[] paramsTypes = info.getParamsTypes();
 
-                ComplexValue[] params = info.getParamsValues();
+                TemplatedValue[] params = info.getParamsValues();
                 int paramsLen = params.length;
                 int typesLen = paramsTypes.length;
 
@@ -137,7 +137,7 @@ protected List<Worker<? extends BenchmarkModule>> makeWorkersImpl() {
                 } else {
                     int numSplits = paramsLen / typesLen;
                     for (int j = 0; j < numSplits; j += 1) {
-                        ComplexValue[] subset = Arrays.copyOfRange(params, j * typesLen, j * typesLen + typesLen);
+                        TemplatedValue[] subset = Arrays.copyOfRange(params, j * typesLen, j * typesLen + typesLen);
                         assert subset.length == typesLen;
                         list.add(new GenericQueryOperation(subset));
                     }
@@ -189,7 +189,7 @@ private CustomClassLoader loadQueryTemplates(String file) {
 
                 for (ValuesType paramValue : template.getValues()) {
                     for (ValueType value : paramValue.getValue()) {
-                        b.addParamsValues(new ComplexValue(value.getDist(), value.getMin(), value.getMax(),
+                        b.addParamsValues(new TemplatedValue(value.getDist(), value.getMin(), value.getMax(),
                                 value.getSeed(), value.getValue()));
                     }
                 }
@@ -205,20 +205,20 @@ public final class %s extends %s {
                                 return ImmutableQueryTemplateInfo.builder()
                                         .query(new %s(\"%s\"))
                                         .paramsTypes(new String[] {%s})
-                                        .paramsValues(new ComplexValue[] {%s})
+                                        .paramsValues(new TemplatedValue[] {%s})
                                         .build();
                             }
                         }
                         """.formatted(
                         GenericQuery.class.getPackageName(),
-                        ComplexValue.class.getCanonicalName(),
+                        TemplatedValue.class.getCanonicalName(),
                         qt.getName(),
                         GenericQuery.class.getCanonicalName(),
                         QueryTemplateInfo.class.getCanonicalName(),
                         SQLStmt.class.getCanonicalName(),
                         StringEscapeUtils.escapeJava(qt.getQuery()),
                         getParamsString(qt.getParamsTypes()),
-                        buildComplexValueString(qt.getParamsValues()));
+                        buildTemplatedValueString(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();
@@ -242,10 +242,10 @@ private String getParamsString(List<String> params) {
         return result.isEmpty() ? "" : result.substring(0, result.length() - 1);
     }
 
-    private String buildComplexValueString(List<ComplexValue> params) {
+    private String buildTemplatedValueString(List<TemplatedValue> params) {
         String result = "";
-        for (ComplexValue param : params) {
-            result += "new ComplexValue("
+        for (TemplatedValue param : params) {
+            result += "new TemplatedValue("
                     + "\"" + param.getDist() + "\"" + ","
                     + "\"" + param.getMin() + "\"" + ","
                     + "\"" + param.getMax() + "\"" + ","
@@ -303,7 +303,7 @@ default List<String> getParamsTypes() {
 
         /** Potential query parameter values. */
         @Value.Default
-        default List<ComplexValue> getParamsValues() {
+        default List<TemplatedValue> getParamsValues() {
             return List.of();
         }
     }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 81fa4d319..ad12ed69a 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -33,7 +33,7 @@
 
 import com.oltpbenchmark.api.Procedure;
 import com.oltpbenchmark.api.SQLStmt;
-import com.oltpbenchmark.benchmarks.templated.util.ComplexValue;
+import com.oltpbenchmark.benchmarks.templated.util.TemplatedValue;
 import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
 import com.oltpbenchmark.distributions.ZipfianGenerator;
 import com.oltpbenchmark.util.TextGenerator;
@@ -43,7 +43,7 @@ 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<ComplexValue> params)
+    public void run(Connection conn, List<TemplatedValue> params)
             throws SQLException {
         try (PreparedStatement stmt = getStatement(conn, params);
                 ResultSet rs = stmt.executeQuery()) {
@@ -67,14 +67,14 @@ public void run(Connection conn) throws SQLException {
         conn.commit();
     }
 
-    public PreparedStatement getStatement(Connection conn, List<ComplexValue> params) throws SQLException {
+    public PreparedStatement getStatement(Connection conn, List<TemplatedValue> params) throws SQLException {
         QueryTemplateInfo queryTemplateInfo = this.getQueryTemplateInfo();
 
         PreparedStatement stmt = this.getPreparedStatement(conn, queryTemplateInfo.getQuery());
         String[] paramsTypes = queryTemplateInfo.getParamsTypes();
         for (int i = 0; i < paramsTypes.length; i++) {
 
-            ComplexValue param = params.get(i);
+            TemplatedValue param = params.get(i);
             boolean hasDist = param.getDist().length() > 0;
             boolean hasValue = param.getValue().length() > 0;
 
@@ -92,11 +92,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                         switch (distribution) {
 
                             case "uniform":
-                                Random uniformRand = (Random) param.getGen();
+                                Random uniformRand = (Random) param.getGenerator();
                                 stmt.setInt(i + 1, uniformRand.nextInt(min, max));
                                 break;
                             case "binomial":
-                                Random binomialRandom = (Random) param.getGen();
+                                Random binomialRandom = (Random) param.getGenerator();
                                 int bVal;
                                 do {
                                     bVal = (int) (min + Math.abs(binomialRandom.nextGaussian()) * max);
@@ -105,11 +105,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                                 stmt.setInt(i + 1, bVal);
                                 break;
                             case "zipf":
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setInt(i + 1, zipfGen.nextInt());
                                 break;
                             case "scrambled":
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setInt(i + 1, scramGen.nextInt());
                                 break;
                             default:
@@ -124,11 +124,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                         switch (distribution) {
 
                             case "uniform":
-                                Random uniformRand = (Random) param.getGen();
+                                Random uniformRand = (Random) param.getGenerator();
                                 stmt.setFloat(i + 1, uniformRand.nextFloat(minF, maxF));
                                 break;
                             case "binomial":
-                                Random binomialRandom = (Random) param.getGen();
+                                Random binomialRandom = (Random) param.getGenerator();
                                 float fVal;
                                 do {
                                     fVal = (float) (minF + Math.abs(binomialRandom.nextGaussian()) * maxF);
@@ -147,11 +147,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                         switch (distribution) {
 
                             case "uniform":
-                                Random uniformRand = (Random) param.getGen();
+                                Random uniformRand = (Random) param.getGenerator();
                                 stmt.setLong(i + 1, uniformRand.nextLong(minL, maxL));
                                 break;
                             case "binomial":
-                                Random binomialRandom = (Random) param.getGen();
+                                Random binomialRandom = (Random) param.getGenerator();
                                 Long lVal;
                                 do {
                                     lVal = Double.valueOf(minL + Math.abs(binomialRandom.nextGaussian()) * maxL)
@@ -161,11 +161,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                                 stmt.setLong(i + 1, lVal);
                                 break;
                             case "zipf":
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setLong(i + 1, zipfGen.nextLong());
                                 break;
                             case "scrambled":
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setLong(i + 1, scramGen.nextLong());
                                 break;
                             default:
@@ -177,7 +177,7 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                     case "string":
                         switch (distribution) {
                             case "uniform":
-                                Random strRandom = (Random) param.getGen();
+                                Random strRandom = (Random) param.getGenerator();
                                 stmt.setString(i + 1, TextGenerator.randomStr(strRandom, param.getMax().intValue()));
                                 break;
                             default:
@@ -190,11 +190,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                         Long stampMax = param.getMax();
                         switch (distribution) {
                             case "uniform":
-                                Random uniformRand = (Random) param.getGen();
+                                Random uniformRand = (Random) param.getGenerator();
                                 stmt.setTimestamp(i + 1, new Timestamp(uniformRand.nextLong(stampMin, stampMax)));
                                 break;
                             case "binomial":
-                                Random binomialRandom = (Random) param.getGen();
+                                Random binomialRandom = (Random) param.getGenerator();
                                 Long lVal;
                                 do {
                                     lVal = Double.valueOf(stampMin + Math.abs(binomialRandom.nextGaussian()) * stampMax)
@@ -204,11 +204,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                                 stmt.setTimestamp(i + 1, new Timestamp(lVal));
                                 break;
                             case "zipf":
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setTimestamp(i + 1, new Timestamp(zipfGen.nextLong()));
                                 break;
                             case "scrambled":
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setTimestamp(i + 1, new Timestamp(scramGen.nextLong()));
                                 break;
                             default:
@@ -221,11 +221,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                         Long dateMax = param.getMax();
                         switch (distribution) {
                             case "uniform":
-                                Random uniformRand = (Random) param.getGen();
+                                Random uniformRand = (Random) param.getGenerator();
                                 stmt.setDate(i + 1, new Date(uniformRand.nextLong(dateMin, dateMax)));
                                 break;
                             case "binomial":
-                                Random binomialRandom = (Random) param.getGen();
+                                Random binomialRandom = (Random) param.getGenerator();
                                 Long lVal;
                                 do {
                                     lVal = Double.valueOf(dateMin + Math.abs(binomialRandom.nextGaussian()) * dateMax)
@@ -235,11 +235,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                                 stmt.setDate(i + 1, new Date(lVal));
                                 break;
                             case "zipf":
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setDate(i + 1, new Date(zipfGen.nextLong()));
                                 break;
                             case "scrambled":
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setDate(i + 1, new Date(scramGen.nextLong()));
                                 break;
                             default:
@@ -252,11 +252,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                         Long timeMax = param.getMax();
                         switch (distribution) {
                             case "uniform":
-                                Random uniformRand = (Random) param.getGen();
+                                Random uniformRand = (Random) param.getGenerator();
                                 stmt.setTime(i + 1, new Time(uniformRand.nextLong(timeMin, timeMax)));
                                 break;
                             case "binomial":
-                                Random binomialRandom = (Random) param.getGen();
+                                Random binomialRandom = (Random) param.getGenerator();
                                 Long lVal;
                                 do {
                                     lVal = Double.valueOf(timeMin + Math.abs(binomialRandom.nextGaussian()) * timeMax)
@@ -266,11 +266,11 @@ public PreparedStatement getStatement(Connection conn, List<ComplexValue> params
                                 stmt.setTime(i + 1, new Time(lVal));
                                 break;
                             case "zipf":
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGen();
+                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setTime(i + 1, new Time(zipfGen.nextLong()));
                                 break;
                             case "scrambled":
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGen();
+                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setTime(i + 1, new Time(scramGen.nextLong()));
                                 break;
                             default:
@@ -311,7 +311,7 @@ public interface QueryTemplateInfo {
         String[] getParamsTypes();
 
         /** Potential query parameter values. */
-        ComplexValue[] getParamsValues();
+        TemplatedValue[] getParamsValues();
     }
 
 }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ComplexValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ComplexValue.java
deleted file mode 100644
index bf1a5585d..000000000
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ComplexValue.java
+++ /dev/null
@@ -1,82 +0,0 @@
-package com.oltpbenchmark.benchmarks.templated.util;
-
-import java.util.Random;
-
-import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
-import com.oltpbenchmark.distributions.ZipfianGenerator;
-
-public class ComplexValue {
-    String dist;
-    Long min;
-    Long max;
-    Long seed;
-    String value;
-    String minS;
-    String maxS;
-
-    public final Object randGen;
-
-
-    public ComplexValue(String dist, String min, String max, String seed, String value) {
-        this.dist = dist == null ? "" : dist;
-        this.min = min == null ? 0 : Long.parseLong(min);
-        this.max = max == null ? 1 : Long.parseLong(max);
-        this.seed = seed == null ? 0 : Long.parseLong(seed);
-        this.value = value;
-        this.randGen = createGen(dist,this.min,this.max,this.seed);
-        this.minS = min;
-        this.maxS = max;
-    }
-
-    private Object createGen(String distribution, Long min, Long max, Long seed) {
-
-        if(distribution == null || distribution.length() < 1) return null;
-
-        switch (distribution) {
-            case "uniform":
-            case "binomial":
-                return new Random(seed);
-            case "zipf":
-                return new ZipfianGenerator(new Random(seed),min,max);
-            case "scrambled":
-                return new ScrambledZipfianGenerator(min,max);
-            default:
-                throw new RuntimeException(
-                "The distribution: '" + distribution + "' is not supported. Currently supported are 'zipf' | 'scrambled' | 'normal' | 'uniform'");
-        }
-
-    }
-
-
-    public String getDist(){
-        return dist;
-    }
-
-    public Long getMin(){
-        return min;
-    }
-
-    public Long getMax(){
-        return max;
-    }
-
-    public Long getSeed(){
-        return seed;
-    }
-
-    public String getValue(){
-        return value;
-    }
-
-    public String getMinString(){
-        return this.minS;
-    }
-
-    public String getMaxString(){
-        return this.maxS;
-    }
-
-    public Object getGen(){
-        return this.randGen;
-    }
-}
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
index 7c570926a..50080c75a 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
@@ -26,15 +26,14 @@
  */
 public class GenericQueryOperation extends Operation {
 
-    public final List<ComplexValue> params;
-  
+    public final List<TemplatedValue> params;
 
-    public GenericQueryOperation(ComplexValue[] params) {
+    public GenericQueryOperation(TemplatedValue[] params) {
         super();
         this.params = Arrays.asList(params);
     }
 
-    public List<ComplexValue> getParams() {
+    public List<TemplatedValue> getParams() {
         return params;
     }
 }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
new file mode 100644
index 000000000..7864e3c4d
--- /dev/null
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -0,0 +1,99 @@
+package com.oltpbenchmark.benchmarks.templated.util;
+
+import java.util.Random;
+
+import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
+import com.oltpbenchmark.distributions.ZipfianGenerator;
+
+public class TemplatedValue {
+    String dist;
+    Long min;
+    Long max;
+    Long seed;
+    String value;
+    String minS;
+    String maxS;
+
+    public final Object generatorObject;
+
+    /**
+     * 
+     * @param dist  The desired value distribution
+     * @param min   Minimum value. Default is 0
+     * @param max   Maximum value. Default is 1
+     * @param seed  The seed for the random generator. Default is 0
+     * @param value Value that is used if no distribution is given
+     */
+    public TemplatedValue(String dist, String min, String max, String seed, String value) {
+        this.dist = dist == null ? "" : dist;
+        this.min = min == null ? 0 : Long.parseLong(min);
+        this.max = max == null ? 1 : Long.parseLong(max);
+        this.seed = seed == null ? 0 : Long.parseLong(seed);
+        this.value = value;
+        this.generatorObject = createGenerator(dist, this.min, this.max, this.seed);
+
+        this.minS = min;
+        this.maxS = max;
+    }
+
+    /**
+     * 
+     * @param distribution The distribution that drives the generator
+     * @param min          Minimum value the generator will produce
+     * @param max          Maximum value the generator will produce
+     * @param seed         A seed for the generator
+     * @return
+     */
+    private Object createGenerator(String distribution, Long min, Long max, Long seed) {
+
+        if (distribution == null || distribution.length() < 1)
+            return null;
+
+        switch (distribution) {
+            case "uniform":
+            case "binomial":
+                return new Random(seed);
+            case "zipf":
+                return new ZipfianGenerator(new Random(seed), min, max);
+            case "scrambled":
+                return new ScrambledZipfianGenerator(min, max);
+            default:
+                throw new RuntimeException(
+                        "The distribution: '" + distribution
+                                + "' is not supported. Currently supported are 'zipf' | 'scrambled' | 'normal' | 'uniform'");
+        }
+
+    }
+
+    public String getDist() {
+        return dist;
+    }
+
+    public Long getMin() {
+        return min;
+    }
+
+    public Long getMax() {
+        return max;
+    }
+
+    public Long getSeed() {
+        return seed;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    public String getMinString() {
+        return this.minS;
+    }
+
+    public String getMaxString() {
+        return this.maxS;
+    }
+
+    public Object getGenerator() {
+        return this.generatorObject;
+    }
+}

From c12e60af88a232049aeca0d8f72f29d8d117f792 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Thu, 30 Nov 2023 10:17:37 +0100
Subject: [PATCH 10/24] Enum, More Documentation

---
 config/postgres/sample_templated_config.xml   |  2 +-
 .../templated/TemplatedBenchmark.java         |  2 +-
 .../templated/procedures/GenericQuery.java    | 51 ++++++++++---------
 .../templated/util/TemplatedValue.java        | 35 +++++++++----
 .../templated/util/ValueGenerator.java        |  8 +++
 5 files changed, 60 insertions(+), 38 deletions(-)
 create mode 100644 src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java

diff --git a/config/postgres/sample_templated_config.xml b/config/postgres/sample_templated_config.xml
index 0e09ffc9c..9ab417941 100644
--- a/config/postgres/sample_templated_config.xml
+++ b/config/postgres/sample_templated_config.xml
@@ -6,7 +6,7 @@
     <driver>org.postgresql.Driver</driver>
     <url>jdbc:postgresql://localhost:5432/benchbase?sslmode=disable&amp;ApplicationName=templated&amp;reWriteBatchedInserts=true</url>
     <username>admin</username>
-    <password>admin</password>
+    <password>password</password>
     <isolation>TRANSACTION_SERIALIZABLE</isolation>
     <batchsize>128</batchsize>
 
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index 133f36d92..5dbc2a67f 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
@@ -246,7 +246,7 @@ private String buildTemplatedValueString(List<TemplatedValue> params) {
         String result = "";
         for (TemplatedValue param : params) {
             result += "new TemplatedValue("
-                    + "\"" + param.getDist() + "\"" + ","
+                    + "\"" + param.getDistribution() + "\"" + ","
                     + "\"" + param.getMin() + "\"" + ","
                     + "\"" + param.getMax() + "\"" + ","
                     + "\"" + param.getSeed() + "\"" + ","
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index ad12ed69a..f8bac3369 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -34,6 +34,7 @@
 import com.oltpbenchmark.api.Procedure;
 import com.oltpbenchmark.api.SQLStmt;
 import com.oltpbenchmark.benchmarks.templated.util.TemplatedValue;
+import com.oltpbenchmark.benchmarks.templated.util.ValueGenerator;
 import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
 import com.oltpbenchmark.distributions.ZipfianGenerator;
 import com.oltpbenchmark.util.TextGenerator;
@@ -75,14 +76,14 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
         for (int i = 0; i < paramsTypes.length; i++) {
 
             TemplatedValue param = params.get(i);
-            boolean hasDist = param.getDist().length() > 0;
+            boolean hasDist = param.getDistribution() != null;
             boolean hasValue = param.getValue().length() > 0;
 
             if ((!hasDist && !hasValue) || paramsTypes[i].equalsIgnoreCase("NULL")) {
                 stmt.setNull(i + 1, Types.NULL);
 
             } else if (hasDist) {
-                String distribution = param.getDist();
+                ValueGenerator distribution = param.getDistribution();
                 String paramType = paramsTypes[i].toLowerCase();
                 switch (paramType) {
                     case "integer":
@@ -91,11 +92,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
 
                         switch (distribution) {
 
-                            case "uniform":
+                            case UNIFORM:
                                 Random uniformRand = (Random) param.getGenerator();
                                 stmt.setInt(i + 1, uniformRand.nextInt(min, max));
                                 break;
-                            case "binomial":
+                            case BINOMIAL:
                                 Random binomialRandom = (Random) param.getGenerator();
                                 int bVal;
                                 do {
@@ -104,11 +105,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
 
                                 stmt.setInt(i + 1, bVal);
                                 break;
-                            case "zipf":
+                            case ZIPFIAN:
                                 ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setInt(i + 1, zipfGen.nextInt());
                                 break;
-                            case "scrambled":
+                            case SCRAMBLED:
                                 ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setInt(i + 1, scramGen.nextInt());
                                 break;
@@ -123,11 +124,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                         float maxF = Float.parseFloat(param.getMaxString());
                         switch (distribution) {
 
-                            case "uniform":
+                            case UNIFORM:
                                 Random uniformRand = (Random) param.getGenerator();
                                 stmt.setFloat(i + 1, uniformRand.nextFloat(minF, maxF));
                                 break;
-                            case "binomial":
+                            case BINOMIAL:
                                 Random binomialRandom = (Random) param.getGenerator();
                                 float fVal;
                                 do {
@@ -146,11 +147,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                         Long maxL = param.getMax();
                         switch (distribution) {
 
-                            case "uniform":
+                            case UNIFORM:
                                 Random uniformRand = (Random) param.getGenerator();
                                 stmt.setLong(i + 1, uniformRand.nextLong(minL, maxL));
                                 break;
-                            case "binomial":
+                            case BINOMIAL:
                                 Random binomialRandom = (Random) param.getGenerator();
                                 Long lVal;
                                 do {
@@ -160,11 +161,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
 
                                 stmt.setLong(i + 1, lVal);
                                 break;
-                            case "zipf":
+                            case ZIPFIAN:
                                 ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setLong(i + 1, zipfGen.nextLong());
                                 break;
-                            case "scrambled":
+                            case SCRAMBLED:
                                 ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setLong(i + 1, scramGen.nextLong());
                                 break;
@@ -176,7 +177,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                     case "varchar":
                     case "string":
                         switch (distribution) {
-                            case "uniform":
+                            case UNIFORM:
                                 Random strRandom = (Random) param.getGenerator();
                                 stmt.setString(i + 1, TextGenerator.randomStr(strRandom, param.getMax().intValue()));
                                 break;
@@ -189,11 +190,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                         Long stampMin = param.getMin();
                         Long stampMax = param.getMax();
                         switch (distribution) {
-                            case "uniform":
+                            case UNIFORM:
                                 Random uniformRand = (Random) param.getGenerator();
                                 stmt.setTimestamp(i + 1, new Timestamp(uniformRand.nextLong(stampMin, stampMax)));
                                 break;
-                            case "binomial":
+                            case BINOMIAL:
                                 Random binomialRandom = (Random) param.getGenerator();
                                 Long lVal;
                                 do {
@@ -203,11 +204,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
 
                                 stmt.setTimestamp(i + 1, new Timestamp(lVal));
                                 break;
-                            case "zipf":
+                            case ZIPFIAN:
                                 ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setTimestamp(i + 1, new Timestamp(zipfGen.nextLong()));
                                 break;
-                            case "scrambled":
+                            case SCRAMBLED:
                                 ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setTimestamp(i + 1, new Timestamp(scramGen.nextLong()));
                                 break;
@@ -220,11 +221,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                         Long dateMin = param.getMin();
                         Long dateMax = param.getMax();
                         switch (distribution) {
-                            case "uniform":
+                            case UNIFORM:
                                 Random uniformRand = (Random) param.getGenerator();
                                 stmt.setDate(i + 1, new Date(uniformRand.nextLong(dateMin, dateMax)));
                                 break;
-                            case "binomial":
+                            case BINOMIAL:
                                 Random binomialRandom = (Random) param.getGenerator();
                                 Long lVal;
                                 do {
@@ -234,11 +235,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
 
                                 stmt.setDate(i + 1, new Date(lVal));
                                 break;
-                            case "zipf":
+                            case ZIPFIAN:
                                 ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setDate(i + 1, new Date(zipfGen.nextLong()));
                                 break;
-                            case "scrambled":
+                            case SCRAMBLED:
                                 ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setDate(i + 1, new Date(scramGen.nextLong()));
                                 break;
@@ -251,11 +252,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                         Long timeMin = param.getMin();
                         Long timeMax = param.getMax();
                         switch (distribution) {
-                            case "uniform":
+                            case UNIFORM:
                                 Random uniformRand = (Random) param.getGenerator();
                                 stmt.setTime(i + 1, new Time(uniformRand.nextLong(timeMin, timeMax)));
                                 break;
-                            case "binomial":
+                            case BINOMIAL:
                                 Random binomialRandom = (Random) param.getGenerator();
                                 Long lVal;
                                 do {
@@ -265,11 +266,11 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
 
                                 stmt.setTime(i + 1, new Time(lVal));
                                 break;
-                            case "zipf":
+                            case ZIPFIAN:
                                 ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
                                 stmt.setTime(i + 1, new Time(zipfGen.nextLong()));
                                 break;
-                            case "scrambled":
+                            case SCRAMBLED:
                                 ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
                                 stmt.setTime(i + 1, new Time(scramGen.nextLong()));
                                 break;
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
index 7864e3c4d..cb88a90e4 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -5,8 +5,13 @@
 import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
 import com.oltpbenchmark.distributions.ZipfianGenerator;
 
+/**
+ * This class is used to store information about the values
+ * used in templated benchmarks. It can hold static values but also
+ * generators for value distributions
+ */
 public class TemplatedValue {
-    String dist;
+    ValueGenerator distribution;
     Long min;
     Long max;
     Long seed;
@@ -25,11 +30,11 @@ public class TemplatedValue {
      * @param value Value that is used if no distribution is given
      */
     public TemplatedValue(String dist, String min, String max, String seed, String value) {
-        this.dist = dist == null ? "" : dist;
         this.min = min == null ? 0 : Long.parseLong(min);
         this.max = max == null ? 1 : Long.parseLong(max);
         this.seed = seed == null ? 0 : Long.parseLong(seed);
         this.value = value;
+
         this.generatorObject = createGenerator(dist, this.min, this.max, this.seed);
 
         this.minS = min;
@@ -46,43 +51,51 @@ public TemplatedValue(String dist, String min, String max, String seed, String v
      */
     private Object createGenerator(String distribution, Long min, Long max, Long seed) {
 
-        if (distribution == null || distribution.length() < 1)
+        if (distribution == null || distribution.equals("null") || distribution.length() < 1)
             return null;
 
-        switch (distribution) {
+        switch (distribution.toLowerCase()) {
             case "uniform":
+                this.distribution = ValueGenerator.UNIFORM;
+                return new Random(seed);
             case "binomial":
+            case "normal":
+                this.distribution = ValueGenerator.BINOMIAL;
                 return new Random(seed);
             case "zipf":
+            case "zipfian":
+                this.distribution = ValueGenerator.ZIPFIAN;
                 return new ZipfianGenerator(new Random(seed), min, max);
             case "scrambled":
+            case "scramzipf":
+                this.distribution = ValueGenerator.SCRAMBLED;
                 return new ScrambledZipfianGenerator(min, max);
             default:
                 throw new RuntimeException(
                         "The distribution: '" + distribution
-                                + "' is not supported. Currently supported are 'zipf' | 'scrambled' | 'normal' | 'uniform'");
+                                + "' is not supported. Currently supported are 'uniform' | 'binomial' | 'zipfian' | 'scrambled'");
         }
 
     }
 
-    public String getDist() {
-        return dist;
+    public ValueGenerator getDistribution() {
+        return this.distribution;
     }
 
     public Long getMin() {
-        return min;
+        return this.min;
     }
 
     public Long getMax() {
-        return max;
+        return this.max;
     }
 
     public Long getSeed() {
-        return seed;
+        return this.seed;
     }
 
     public String getValue() {
-        return value;
+        return this.value;
     }
 
     public String getMinString() {
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java
new file mode 100644
index 000000000..2fcec9c7e
--- /dev/null
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java
@@ -0,0 +1,8 @@
+package com.oltpbenchmark.benchmarks.templated.util;
+
+public enum ValueGenerator {
+    UNIFORM,
+    BINOMIAL,
+    ZIPFIAN,
+    SCRAMBLED
+}

From 51f0f1dee4e8c5742c694937960483d1b9baf4ef Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Mon, 4 Dec 2023 15:24:01 +0100
Subject: [PATCH 11/24] Renamed autogenerated methods, readme format

---
 .../api/templates/TemplateType.java           |  2 +-
 .../api/templates/TemplatesType.java          |  2 +-
 .../api/templates/TypesType.java              |  2 +-
 .../api/templates/ValuesType.java             |  2 +-
 .../benchmarks/templated/README.md            | 27 +++++++++----------
 .../templated/TemplatedBenchmark.java         |  8 +++---
 6 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java b/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
index 26b6116be..d66505f05 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
@@ -141,7 +141,7 @@ public void setTypes(TypesType value) {
      * 
      * 
      */
-    public List<ValuesType> getValues() {
+    public List<ValuesType> getValuesList() {
         if (this.values == null) {
             this.values = new ArrayList<ValuesType>();
         }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java b/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
index 40d71291e..add09d932 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
@@ -82,7 +82,7 @@ public class TemplatesType {
      * 
      * 
      */
-    public List<TemplateType> getTemplate() {
+    public List<TemplateType> getTemplateList() {
         if (this.template == null) {
             this.template = new ArrayList<TemplateType>();
         }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/TypesType.java b/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
index 28ff0f284..e386ffc0f 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
@@ -82,7 +82,7 @@ public class TypesType {
      * 
      * 
      */
-    public List<String> getType() {
+    public List<String> getTypeList() {
         if (this.type == null) {
             this.type = new ArrayList<>();
         }
diff --git a/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java b/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
index 9062e23e7..e6b010908 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
@@ -82,7 +82,7 @@ public class ValuesType {
      * 
      * 
      */
-    public List<ValueType> getValue() {
+    public List<ValueType> getValueList() {
         if (this.value == null) {
             this.value = new ArrayList<ValueType>();
         }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
index c4004c84b..e8fe5446c 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
@@ -81,21 +81,20 @@ Each time the query is run, a different value will substitute the `?`.
 ```
 
 The distributions are dependent on the type of the value. Currently, the following type-distributions pairs are supported:
-| Type | uniform | binomial | zipfian | scrambled zipfian |
-|---|:---:|:---:|:---:|:---:|
-| INTEGER | X | X | X | X |
-| FLOAT / REAL | X | X|- | - |
-| BIGINT | X | X | X | X |
-| VARCHAR / STRING | X | -| -| -|
-| TIMESTAMP | X | X |X |X |
-| DATE | X | X| X| X|
-| TIME | X |X | X| X|
-
+| Type             | uniform | binomial | zipfian | scrambled zipfian |
+| ---------------- | :-----: | :------: | :-----: | :---------------: |
+| INTEGER          |    X    |    X     |    X    |         X         |
+| FLOAT / REAL     |    X    |    X     |    -    |         -         |
+| BIGINT           |    X    |    X     |    X    |         X         |
+| VARCHAR / STRING |    X    |    -     |    -    |         -         |
+| TIMESTAMP        |    X    |    X     |    X    |         X         |
+| DATE             |    X    |    X     |    X    |         X         |
+| TIME             |    X    |    X     |    X    |         X         |
 The following properties can be set on the value:
 
--   dist _The distribution of the values_
--   min _The minimum value the generator can produce. Defaults to 0_
--   max _The maximum value the generator can produce. Defaults to 1_
--   seed _A seed for the generator to ensure consistency_
+-   `dist`: The distribution of the values
+-   `min`: The minimum value the generator can produce. Defaults to 0
+-   `max`: The maximum value the generator can produce. Defaults to 1
+-   `seed`: A seed for the generator to ensure consistency
 
 For Timestamps, Dates and Times, the min and max values must be converted to a long (milliseconds)
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index 5dbc2a67f..cf17dfd8c 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
@@ -181,14 +181,14 @@ private CustomClassLoader loadQueryTemplates(String file) {
             JAXBElement<TemplatesType> result = unmarshaller.unmarshal(streamSource, TemplatesType.class);
             TemplatesType templates = result.getValue();
 
-            for (TemplateType template : templates.getTemplate()) {
+            for (TemplateType template : templates.getTemplateList()) {
                 ImmutableParsedQueryTemplate.Builder b = ImmutableParsedQueryTemplate.builder();
                 b.name(template.getName());
                 b.query(template.getQuery());
-                b.paramsTypes(template.getTypes().getType());
+                b.paramsTypes(template.getTypes().getTypeList());
 
-                for (ValuesType paramValue : template.getValues()) {
-                    for (ValueType value : paramValue.getValue()) {
+                for (ValuesType paramValue : template.getValuesList()) {
+                    for (ValueType value : paramValue.getValueList()) {
                         b.addParamsValues(new TemplatedValue(value.getDist(), value.getMin(), value.getMax(),
                                 value.getSeed(), value.getValue()));
                     }

From 38747aeae900ee3b79f6b61a93a352ef3d8782cf Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Thu, 7 Dec 2023 15:27:36 +0100
Subject: [PATCH 12/24] Testing increased, size reduction of massive switch
 statement

---
 data/templated/example.xml                    |  18 +-
 .../templated/procedures/GenericQuery.java    | 168 ++++--------------
 .../templated/util/GenericQueryOperation.java |   3 +-
 .../templated/util/TemplatedValue.java        |  64 ++++++-
 4 files changed, 105 insertions(+), 148 deletions(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index c48917d4e..9d6ceeacf 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -64,19 +64,19 @@
     <template name="UpdateItemPrice">
       <query><![CDATA[UPDATE item SET i_price = i_price + 1 WHERE i_price < ?]]></query>
       <types>
-         <type>FLOAT</type>
+         <type>INTEGER</type>
       </types>
       <values>
-         <value>2.1</value>
+         <value dist="zipf" min="10" max="40">2.1</value>
       </values>
    </template>
    <template name="DeleteItem">
-      <query><![CDATA[DELETE FROM item WHERE i_price > ?]]></query>
+      <query><![CDATA[DELETE FROM oorder WHERE o_entry_d < ?]]></query>
       <types>
-         <type>FLOAT</type>
+         <type>TIMESTAMP</type>
       </types>
       <values>
-         <value>255.0</value>
+         <value dist="scrambled" min="1000" max="300000"></value>
       </values>
    </template>
    <template name="InsertItem">
@@ -90,10 +90,10 @@
       </types>
       <values>
          <value>100001</value>
-         <value>Testname</value>
-         <value>255.1</value>
-         <value>Testdata</value>
-         <value>1</value>
+         <value dist="uniform" min="0" max="5" />
+         <value dist="binomial" min="0" max="2" />
+         <value dist="uniform" min="0" max="10" />
+         <value dist="zipf" min="0" max="10" />
       </values>
    </template>
 </templates>
\ No newline at end of file
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 5beb6e681..aeaac79d4 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -103,202 +103,104 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                 String paramType = paramsTypes[i].toLowerCase();
                 switch (paramType) {
                     case "integer":
-                        int min = param.getMin().intValue();
-                        int max = param.getMax().intValue();
-
+                        int generatedInt;
                         switch (distribution) {
-
                             case UNIFORM:
-                                Random uniformRand = (Random) param.getGenerator();
-                                stmt.setInt(i + 1, uniformRand.nextInt(min, max));
+                                generatedInt = param.getNextLongUniform().intValue();
                                 break;
                             case BINOMIAL:
-                                Random binomialRandom = (Random) param.getGenerator();
-                                int bVal;
-                                do {
-                                    bVal = (int) (min + Math.abs(binomialRandom.nextGaussian()) * max);
-                                } while (bVal > max || bVal < min);
-
-                                stmt.setInt(i + 1, bVal);
+                                generatedInt = param.getNextLongBinomial().intValue();
                                 break;
                             case ZIPFIAN:
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
-                                stmt.setInt(i + 1, zipfGen.nextInt());
+                                generatedInt = param.getNextLongZipf().intValue();
                                 break;
                             case SCRAMBLED:
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
-                                stmt.setInt(i + 1, scramGen.nextInt());
+                                generatedInt = param.getNextLongScrambled().intValue();
                                 break;
                             default:
-                                throw new RuntimeException(
-                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                                throw param.createRuntimeException(paramType);
                         }
+                        stmt.setInt(i + 1, generatedInt);
                         break;
                     case "float":
                     case "real":
-                        float minF = Float.parseFloat(param.getMinString());
-                        float maxF = Float.parseFloat(param.getMaxString());
+                        float generatedFloat;
                         switch (distribution) {
-
                             case UNIFORM:
-                                Random uniformRand = (Random) param.getGenerator();
-                                stmt.setFloat(i + 1, uniformRand.nextFloat(minF, maxF));
+                                generatedFloat = param.getNextFloatUniform();
                                 break;
                             case BINOMIAL:
-                                Random binomialRandom = (Random) param.getGenerator();
-                                float fVal;
-                                do {
-                                    fVal = (float) (minF + Math.abs(binomialRandom.nextGaussian()) * maxF);
-                                } while (fVal > maxF || fVal < minF);
-
-                                stmt.setFloat(i + 1, fVal);
+                                generatedFloat = param.getNextFloatBinomial();
                                 break;
                             default:
-                                throw new RuntimeException(
-                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                                throw param.createRuntimeException(paramType);
                         }
+                        stmt.setFloat(i + 1, generatedFloat);
                         break;
                     case "bigint":
-                        Long minL = param.getMin();
-                        Long maxL = param.getMax();
+                        Long generatedLong;
                         switch (distribution) {
 
                             case UNIFORM:
-                                Random uniformRand = (Random) param.getGenerator();
-                                stmt.setLong(i + 1, uniformRand.nextLong(minL, maxL));
+                                generatedLong = param.getNextLongUniform();
                                 break;
                             case BINOMIAL:
-                                Random binomialRandom = (Random) param.getGenerator();
-                                Long lVal;
-                                do {
-                                    lVal = Double.valueOf(minL + Math.abs(binomialRandom.nextGaussian()) * maxL)
-                                            .longValue();
-                                } while (lVal > maxL || lVal < minL);
-
-                                stmt.setLong(i + 1, lVal);
+                                generatedLong = param.getNextLongBinomial();
                                 break;
                             case ZIPFIAN:
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
-                                stmt.setLong(i + 1, zipfGen.nextLong());
+                                generatedLong = param.getNextLongZipf();
                                 break;
                             case SCRAMBLED:
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
-                                stmt.setLong(i + 1, scramGen.nextLong());
+                               generatedLong = param.getNextLongScrambled();
                                 break;
                             default:
-                                throw new RuntimeException(
-                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                                throw param.createRuntimeException(paramType);
                         }
+                        stmt.setLong(i+1, generatedLong);
                         break;
                     case "varchar":
                     case "string":
                         switch (distribution) {
                             case UNIFORM:
-                                Random strRandom = (Random) param.getGenerator();
-                                stmt.setString(i + 1, TextGenerator.randomStr(strRandom, param.getMax().intValue()));
+                                stmt.setString(i + 1,param.getNextString());
                                 break;
                             default:
-                                throw new RuntimeException(
-                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                                throw param.createRuntimeException(paramType);
                         }
                         break;
                     case "timestamp":
-                        Long stampMin = param.getMin();
-                        Long stampMax = param.getMax();
-                        switch (distribution) {
-                            case UNIFORM:
-                                Random uniformRand = (Random) param.getGenerator();
-                                stmt.setTimestamp(i + 1, new Timestamp(uniformRand.nextLong(stampMin, stampMax)));
-                                break;
-                            case BINOMIAL:
-                                Random binomialRandom = (Random) param.getGenerator();
-                                Long lVal;
-                                do {
-                                    lVal = Double.valueOf(stampMin + Math.abs(binomialRandom.nextGaussian()) * stampMax)
-                                            .longValue();
-                                } while (lVal > stampMax || lVal < stampMin);
-
-                                stmt.setTimestamp(i + 1, new Timestamp(lVal));
-                                break;
-                            case ZIPFIAN:
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
-                                stmt.setTimestamp(i + 1, new Timestamp(zipfGen.nextLong()));
-                                break;
-                            case SCRAMBLED:
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
-                                stmt.setTimestamp(i + 1, new Timestamp(scramGen.nextLong()));
-                                break;
-                            default:
-                                throw new RuntimeException(
-                                        "Distribution: " + distribution + " not supported for type: " + paramType);
-                        }
-                        break;
                     case "date":
-                        Long dateMin = param.getMin();
-                        Long dateMax = param.getMax();
-                        switch (distribution) {
-                            case UNIFORM:
-                                Random uniformRand = (Random) param.getGenerator();
-                                stmt.setDate(i + 1, new Date(uniformRand.nextLong(dateMin, dateMax)));
-                                break;
-                            case BINOMIAL:
-                                Random binomialRandom = (Random) param.getGenerator();
-                                Long lVal;
-                                do {
-                                    lVal = Double.valueOf(dateMin + Math.abs(binomialRandom.nextGaussian()) * dateMax)
-                                            .longValue();
-                                } while (lVal > dateMax || lVal < dateMin);
-
-                                stmt.setDate(i + 1, new Date(lVal));
-                                break;
-                            case ZIPFIAN:
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
-                                stmt.setDate(i + 1, new Date(zipfGen.nextLong()));
-                                break;
-                            case SCRAMBLED:
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
-                                stmt.setDate(i + 1, new Date(scramGen.nextLong()));
-                                break;
-                            default:
-                                throw new RuntimeException(
-                                        "Distribution: " + distribution + " not supported for type: " + paramType);
-                        }
-                        break;
                     case "time":
-                        Long timeMin = param.getMin();
-                        Long timeMax = param.getMax();
+                        Long generatedTimestamp;
                         switch (distribution) {
                             case UNIFORM:
-                                Random uniformRand = (Random) param.getGenerator();
-                                stmt.setTime(i + 1, new Time(uniformRand.nextLong(timeMin, timeMax)));
+                                generatedTimestamp = param.getNextLongUniform();
                                 break;
                             case BINOMIAL:
-                                Random binomialRandom = (Random) param.getGenerator();
-                                Long lVal;
-                                do {
-                                    lVal = Double.valueOf(timeMin + Math.abs(binomialRandom.nextGaussian()) * timeMax)
-                                            .longValue();
-                                } while (lVal > timeMax || lVal < timeMin);
-
-                                stmt.setTime(i + 1, new Time(lVal));
+                                generatedTimestamp = param.getNextLongBinomial();
                                 break;
                             case ZIPFIAN:
-                                ZipfianGenerator zipfGen = (ZipfianGenerator) param.getGenerator();
-                                stmt.setTime(i + 1, new Time(zipfGen.nextLong()));
+                                generatedTimestamp = param.getNextLongZipf();
                                 break;
                             case SCRAMBLED:
-                                ScrambledZipfianGenerator scramGen = (ScrambledZipfianGenerator) param.getGenerator();
-                                stmt.setTime(i + 1, new Time(scramGen.nextLong()));
+                                generatedTimestamp = param.getNextLongScrambled();
                                 break;
                             default:
-                                throw new RuntimeException(
-                                        "Distribution: " + distribution + " not supported for type: " + paramType);
+                               throw param.createRuntimeException(paramType);
+                        }
+                        if(paramType.equals("timestamp")){
+                            stmt.setTimestamp(i+1, new Timestamp(generatedTimestamp));
+                        } else if(paramType.equals("date")){
+                            stmt.setDate(i+1, new Date(generatedTimestamp));
+                        } else {
+                            stmt.setTime(i+1,new Time(generatedTimestamp));
                         }
                         break;
                     default:
                         throw new RuntimeException(
                                 "Support for distributions for the type: " + paramType + " is current not implemented");
                 }
+                
             } else {
                 try {
                     Object val = param.getValue();
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
index 50080c75a..29daa77c3 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
@@ -17,6 +17,7 @@
 package com.oltpbenchmark.benchmarks.templated.util;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import com.oltpbenchmark.api.Operation;
@@ -30,7 +31,7 @@ public class GenericQueryOperation extends Operation {
 
     public GenericQueryOperation(TemplatedValue[] params) {
         super();
-        this.params = Arrays.asList(params);
+        this.params = Collections.unmodifiableList(Arrays.asList(params));
     }
 
     public List<TemplatedValue> getParams() {
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
index cb88a90e4..45d39bffb 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -4,6 +4,7 @@
 
 import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
 import com.oltpbenchmark.distributions.ZipfianGenerator;
+import com.oltpbenchmark.util.TextGenerator;
 
 /**
  * This class is used to store information about the values
@@ -23,20 +24,21 @@ public class TemplatedValue {
 
     /**
      * 
-     * @param dist  The desired value distribution
+     * @param distribution  The desired value distribution
      * @param min   Minimum value. Default is 0
      * @param max   Maximum value. Default is 1
      * @param seed  The seed for the random generator. Default is 0
      * @param value Value that is used if no distribution is given
      */
-    public TemplatedValue(String dist, String min, String max, String seed, String value) {
+    public TemplatedValue(String distribution, String min, String max, String seed, String value) {
         this.min = min == null ? 0 : Long.parseLong(min);
         this.max = max == null ? 1 : Long.parseLong(max);
         this.seed = seed == null ? 0 : Long.parseLong(seed);
         this.value = value;
 
-        this.generatorObject = createGenerator(dist, this.min, this.max, this.seed);
+        this.generatorObject = createGenerator(distribution, this.min, this.max, this.seed);
 
+        //String values are kept for the construction of Floating Point bounds
         this.minS = min;
         this.maxS = max;
     }
@@ -51,9 +53,10 @@ public TemplatedValue(String dist, String min, String max, String seed, String v
      */
     private Object createGenerator(String distribution, Long min, Long max, Long seed) {
 
-        if (distribution == null || distribution.equals("null") || distribution.length() < 1)
+        if (distribution == null || distribution.equals("null") || distribution.length() < 1){
             return null;
-
+        }
+            
         switch (distribution.toLowerCase()) {
             case "uniform":
                 this.distribution = ValueGenerator.UNIFORM;
@@ -109,4 +112,55 @@ public String getMaxString() {
     public Object getGenerator() {
         return this.generatorObject;
     }
+
+    public Long getNextLongBinomial(){
+        Random binomialGenerator = (Random) this.generatorObject;
+        Long generatedValue;
+        do {
+            generatedValue = Double.valueOf(this.min + Math.abs(binomialGenerator.nextGaussian()) * this.max).longValue();
+        } while (generatedValue > max || generatedValue < min); 
+
+        return generatedValue;
+    }
+
+    public Long getNextLongUniform(){
+        Random uniformGenerator = (Random) this.generatorObject;
+        return uniformGenerator.nextLong(this.min, this.max);
+    }
+
+    public Long getNextLongZipf(){
+        ZipfianGenerator zipfianGenerator = (ZipfianGenerator) this.generatorObject;
+        return zipfianGenerator.nextLong();
+    }
+
+    public Long getNextLongScrambled(){
+        ScrambledZipfianGenerator scrambledGenerator = (ScrambledZipfianGenerator) this.generatorObject;
+        return scrambledGenerator.nextLong();
+    }
+
+    public String getNextString(){
+        Random stringGenerator = (Random) this.generatorObject;
+        return TextGenerator.randomStr(stringGenerator, this.max.intValue());
+    }
+
+    public Float getNextFloatUniform(){
+        Random floatGenerator = (Random) this.generatorObject;
+        return floatGenerator.nextFloat(Float.parseFloat(this.minS), Float.parseFloat(this.maxS));
+    }
+
+    public Float getNextFloatBinomial(){
+        Float minF = Float.parseFloat(this.minS);
+        Float maxF = Float.parseFloat(this.maxS);
+        Random floatGenerator = (Random) this.generatorObject;
+        Float generatedFloat;
+        do {
+            generatedFloat = (float) (minF + Math.abs(floatGenerator.nextGaussian()) * maxF);
+        } while (generatedFloat > maxF || generatedFloat < minF);
+
+        return generatedFloat;
+    }
+
+    public RuntimeException createRuntimeException(String paramType){
+        return new RuntimeException("Distribution: " + this.distribution + " not supported for type: " + paramType);
+    }
 }

From 961d5c41521281af5cb3b4ae79ae11d4489f3715 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Wed, 17 Jan 2024 14:07:47 +0100
Subject: [PATCH 13/24] Lightweight constructor added

---
 .../templated/TemplatedBenchmark.java         | 66 +++++++++++--------
 .../templated/procedures/GenericQuery.java    |  2 +-
 .../templated/util/TemplatedValue.java        | 39 +++++++----
 3 files changed, 63 insertions(+), 44 deletions(-)

diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index 11851bc4e..9e9d32397 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
@@ -190,13 +190,16 @@ private CustomClassLoader loadQueryTemplates(String file) {
 
         for (ValuesType paramValue : template.getValuesList()) {
           for (ValueType value : paramValue.getValueList()) {
-            b.addParamsValues(
-                new TemplatedValue(
-                    value.getDist(),
-                    value.getMin(),
-                    value.getMax(),
-                    value.getSeed(),
-                    value.getValue()));
+            /* Lightweight constructor used if no distribution is present */
+            if (value.getDist() == null
+                || value.getDist().length() < 1
+                || value.getDist().equals("null")) {
+              b.addParamsValues(new TemplatedValue(value.getValue()));
+            } else {
+              b.addParamsValues(
+                  new TemplatedValue(
+                      value.getDist(), value.getMin(), value.getMax(), value.getSeed()));
+            }
           }
         }
 
@@ -253,28 +256,33 @@ private String getParamsString(List<String> params) {
   private String buildTemplatedValueString(List<TemplatedValue> params) {
     String result = "";
     for (TemplatedValue param : params) {
-      result +=
-          "new TemplatedValue("
-              + "\""
-              + param.getDistribution()
-              + "\""
-              + ","
-              + "\""
-              + param.getMin()
-              + "\""
-              + ","
-              + "\""
-              + param.getMax()
-              + "\""
-              + ","
-              + "\""
-              + param.getSeed()
-              + "\""
-              + ","
-              + "\""
-              + StringEscapeUtils.escapeJava(param.getValue())
-              + "\""
-              + "),";
+      if (param.getDistribution() != null) {
+        result +=
+            "new TemplatedValue("
+                + "\""
+                + param.getDistribution()
+                + "\""
+                + ","
+                + "\""
+                + param.getMin()
+                + "\""
+                + ","
+                + "\""
+                + param.getMax()
+                + "\""
+                + ","
+                + "\""
+                + param.getSeed()
+                + "\""
+                + "),";
+      } else {
+        result +=
+            "new TemplatedValue("
+                + "\""
+                + StringEscapeUtils.escapeJava(param.getValue())
+                + "\""
+                + "),";
+      }
     }
     return result.isEmpty() ? "" : result.substring(0, result.length() - 1);
   }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index ee9c6962e..da622c8a3 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -91,7 +91,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
 
       TemplatedValue param = params.get(i);
       boolean hasDist = param.getDistribution() != null;
-      boolean hasValue = param.getValue().length() > 0;
+      boolean hasValue = param.getValue() != null;
 
       if ((!hasDist && !hasValue) || paramsTypes[i].equalsIgnoreCase("NULL")) {
         stmt.setNull(i + 1, Types.NULL);
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
index 5a86c0fe6..dc5ca2ef1 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -17,8 +17,14 @@ public class TemplatedValue {
   String value;
   String minS;
   String maxS;
+  Object generatorObject;
 
-  public final Object generatorObject;
+  /**
+   * @param value Value that is used if no distribution is given
+   */
+  public TemplatedValue(String value) {
+    this.value = value;
+  }
 
   /**
    * @param distribution The desired value distribution
@@ -27,11 +33,24 @@ public class TemplatedValue {
    * @param seed The seed for the random generator. Default is 0
    * @param value Value that is used if no distribution is given
    */
-  public TemplatedValue(String distribution, String min, String max, String seed, String value) {
-    this.min = min == null ? 0 : Long.parseLong(min);
-    this.max = max == null ? 1 : Long.parseLong(max);
-    this.seed = seed == null ? 0 : Long.parseLong(seed);
-    this.value = value;
+  public TemplatedValue(String distribution, String min, String max, String seed) {
+    try {
+      this.min = Long.parseLong(min);
+    } catch (Exception e) {
+      this.min = 0L;
+    }
+
+    try {
+      this.max = Long.parseLong(max);
+    } catch (Exception e) {
+      this.max = 1L;
+    }
+
+    try {
+      this.seed = Long.parseLong(seed);
+    } catch (Exception e) {
+      this.seed = 0L;
+    }
 
     this.generatorObject = createGenerator(distribution, this.min, this.max, this.seed);
 
@@ -97,14 +116,6 @@ public String getValue() {
     return this.value;
   }
 
-  public String getMinString() {
-    return this.minS;
-  }
-
-  public String getMaxString() {
-    return this.maxS;
-  }
-
   public Object getGenerator() {
     return this.generatorObject;
   }

From 5454f526370fffbcde30bee665b971f860976211 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Tue, 23 Jan 2024 13:48:37 +0100
Subject: [PATCH 14/24] Insert statment modification

---
 .../cockroachdb/sample_templated_config.xml   |  4 +---
 config/mariadb/sample_templated_config.xml    |  4 +---
 config/mysql/sample_templated_config.xml      |  4 +---
 config/oracle/sample_templated_config.xml     |  4 +---
 config/postgres/sample_templated_config.xml   |  4 +---
 config/sqlite/sample_templated_config.xml     |  4 +---
 config/sqlserver/sample_templated_config.xml  |  4 +---
 data/templated/example.xml                    | 24 +++++++++++--------
 8 files changed, 21 insertions(+), 31 deletions(-)

diff --git a/config/cockroachdb/sample_templated_config.xml b/config/cockroachdb/sample_templated_config.xml
index 8f0e31630..b7dca724e 100644
--- a/config/cockroachdb/sample_templated_config.xml
+++ b/config/cockroachdb/sample_templated_config.xml
@@ -24,7 +24,7 @@
         <work>
             <time>10</time>
             <rate>100</rate>
-            <weights>20,20,10,10,10,10,10<!-- FIXME: ,10 --></weights>
+            <weights>20,20,10,10,10,10,10,10</weights>
         </work>
     </works>
 
@@ -51,10 +51,8 @@
         <transactiontype>
             <name>DeleteItem</name>
         </transactiontype>
-        <!-- FIXME:
         <transactiontype>
             <name>InsertItem</name>
         </transactiontype>
-        -->
     </transactiontypes>
 </parameters>
diff --git a/config/mariadb/sample_templated_config.xml b/config/mariadb/sample_templated_config.xml
index 1f74ac859..ac836639f 100644
--- a/config/mariadb/sample_templated_config.xml
+++ b/config/mariadb/sample_templated_config.xml
@@ -25,7 +25,7 @@
         <work>
             <time>10</time>
             <rate>100</rate>
-            <weights>20,20,10,10,10,10,10<!-- FIXME: ,10 --></weights>
+            <weights>20,20,10,10,10,10,10,10</weights>
         </work>
     </works>
 
@@ -52,10 +52,8 @@
         <transactiontype>
             <name>DeleteItem</name>
         </transactiontype>
-        <!-- FIXME:
         <transactiontype>
             <name>InsertItem</name>
         </transactiontype>
-        -->
     </transactiontypes>
 </parameters>
diff --git a/config/mysql/sample_templated_config.xml b/config/mysql/sample_templated_config.xml
index c58efb0de..db54cd1d8 100644
--- a/config/mysql/sample_templated_config.xml
+++ b/config/mysql/sample_templated_config.xml
@@ -25,7 +25,7 @@
         <work>
             <time>10</time>
             <rate>100</rate>
-            <weights>20,20,10,10,10,10,10<!-- FIXME: ,10 --></weights>
+            <weights>20,20,10,10,10,10,10,10</weights>
         </work>
     </works>
 
@@ -52,10 +52,8 @@
         <transactiontype>
             <name>DeleteItem</name>
         </transactiontype>
-        <!-- FIXME:
         <transactiontype>
             <name>InsertItem</name>
         </transactiontype>
-        -->
     </transactiontypes>
 </parameters>
diff --git a/config/oracle/sample_templated_config.xml b/config/oracle/sample_templated_config.xml
index 57a828487..a10605fee 100644
--- a/config/oracle/sample_templated_config.xml
+++ b/config/oracle/sample_templated_config.xml
@@ -25,7 +25,7 @@
         <work>
             <time>10</time>
             <rate>100</rate>
-            <weights>20,20,10,10,10,10,10<!-- FIXME: ,10 --></weights>
+            <weights>20,20,10,10,10,10,10,10</weights>
         </work>
     </works>
 
@@ -52,10 +52,8 @@
         <transactiontype>
             <name>DeleteItem</name>
         </transactiontype>
-        <!-- FIXME:
         <transactiontype>
             <name>InsertItem</name>
         </transactiontype>
-        -->
     </transactiontypes>
 </parameters>
diff --git a/config/postgres/sample_templated_config.xml b/config/postgres/sample_templated_config.xml
index 25cc68739..51a701d58 100644
--- a/config/postgres/sample_templated_config.xml
+++ b/config/postgres/sample_templated_config.xml
@@ -25,7 +25,7 @@
         <work>
             <time>10</time>
             <rate>100</rate>
-            <weights>20,20,10,10,10,10,10<!-- FIXME: ,10 --></weights>
+            <weights>20,20,10,10,10,10,10,10</weights>
         </work>
     </works>
 
@@ -52,10 +52,8 @@
         <transactiontype>
             <name>DeleteItem</name>
         </transactiontype>
-        <!-- FIXME:
         <transactiontype>
             <name>InsertItem</name>
         </transactiontype>
-        -->
     </transactiontypes>
 </parameters>
diff --git a/config/sqlite/sample_templated_config.xml b/config/sqlite/sample_templated_config.xml
index 8b2c8ecbf..a3b5b5f7f 100644
--- a/config/sqlite/sample_templated_config.xml
+++ b/config/sqlite/sample_templated_config.xml
@@ -22,7 +22,7 @@
         <work>
             <time>10</time>
             <rate>100</rate>
-            <weights>20,20,10,10,10,10,10<!-- FIXME: ,10 --></weights>
+            <weights>20,20,10,10,10,10,10,10</weights>
         </work>
     </works>
 
@@ -49,10 +49,8 @@
         <transactiontype>
             <name>DeleteItem</name>
         </transactiontype>
-        <!-- FIXME:
         <transactiontype>
             <name>InsertItem</name>
         </transactiontype>
-        -->
     </transactiontypes>
 </parameters>
diff --git a/config/sqlserver/sample_templated_config.xml b/config/sqlserver/sample_templated_config.xml
index 1899addae..37a418d44 100644
--- a/config/sqlserver/sample_templated_config.xml
+++ b/config/sqlserver/sample_templated_config.xml
@@ -25,7 +25,7 @@
         <work>
             <time>10</time>
             <rate>100</rate>
-            <weights>20,20,10,10,10,10,10<!-- FIXME: ,10 --></weights>
+            <weights>20,20,10,10,10,10,10,10</weights>
         </work>
     </works>
 
@@ -52,10 +52,8 @@
         <transactiontype>
             <name>DeleteItem</name>
         </transactiontype>
-        <!-- FIXME:
         <transactiontype>
             <name>InsertItem</name>
         </transactiontype>
-        -->
     </transactiontypes>
 </parameters>
diff --git a/data/templated/example.xml b/data/templated/example.xml
index f48489f04..7d82b726c 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -79,23 +79,27 @@
          <value dist="scrambled" min="1000" max="300000"></value>
       </values>
    </template>
-   <!-- FIXME: This results in primary key failures due to duplicate keys.
    <template name="InsertItem">
-      <query><![CDATA[INSERT INTO item VALUES(?,?,?,?,?)]]></query>
+      <query><![CDATA[INSERT INTO history VALUES(?,?,?,?,?,?,?,?)]]></query>
       <types>
          <type>INTEGER</type>
-         <type>VARCHAR</type>
+         <type>INTEGER</type>
+         <type>INTEGER</type>
+         <type>INTEGER</type>
+         <type>INTEGER</type>
+         <type>TIMESTAMP</type>
          <type>FLOAT</type>
          <type>VARCHAR</type>
-         <type>INTEGER</type>
       </types>
       <values>
-         <value>100001</value>
-         <value dist="uniform" min="0" max="5" />
-         <value dist="binomial" min="0" max="2" />
-         <value dist="uniform" min="0" max="10" />
-         <value dist="zipf" min="0" max="10" />
+         <value dist="uniform" min="1" max="3000"/>
+         <value dist="binomial" min="1" max="10"/>
+         <value dist="zipf" min="1" seed="10"/>
+         <value dist="scrambled" min="1" max="10" seed="2"/>
+         <value>1</value>
+         <value dist="uniform" min="1674477220000" max="1706013220000"/>
+         <value dist="normal" min="0.5" max="12.5"/>
+         <value dist="uniform" max="23"/>
       </values>
    </template>
-   -->
 </templates>
\ No newline at end of file

From 06d3f39ddd9790c7f55677b28ada57bd93abae42 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Wed, 24 Jan 2024 08:22:07 +0100
Subject: [PATCH 15/24] Min-Max check

---
 .../benchmarks/templated/util/TemplatedValue.java           | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
index dc5ca2ef1..81897b1af 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -29,7 +29,7 @@ public TemplatedValue(String value) {
   /**
    * @param distribution The desired value distribution
    * @param min Minimum value. Default is 0
-   * @param max Maximum value. Default is 1
+   * @param max Maximum value. Default is min + 1
    * @param seed The seed for the random generator. Default is 0
    * @param value Value that is used if no distribution is given
    */
@@ -43,9 +43,11 @@ public TemplatedValue(String distribution, String min, String max, String seed)
     try {
       this.max = Long.parseLong(max);
     } catch (Exception e) {
-      this.max = 1L;
+      this.max = this.min + 1L;
     }
 
+    assert this.max > this.min;
+
     try {
       this.seed = Long.parseLong(seed);
     } catch (Exception e) {

From 949c93db0f044eb264ab90fe7429f0d7eae92c8b Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Wed, 24 Jan 2024 08:41:08 +0100
Subject: [PATCH 16/24] Changed distributions due to FK contraints

---
 data/templated/example.xml | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index 7d82b726c..138ef57db 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -9,11 +9,11 @@
          <type>INTEGER</type>
       </types>
       <values>
-         <value>3</value>
-         <value>4</value>
+         <value dist="uniform" min="1" max="3" />
+         <value dist="zipf" min="1"/>
       </values>
        <values>
-         <value>5</value>
+         <value dist="scrambled" seed="999"/>
          <value>6</value>
       </values>
    </template>
@@ -53,8 +53,8 @@
          <type>FLOAT</type>
       </types>
       <values>
-         <value>10</value>
-         <value>10.49</value>
+         <value dist="normal" min="10" max="12.5"/>
+         <valu dist="uniform" min="15.1" max="20.0"/>
       </values>
       <values>
          <value>10.50</value>
@@ -92,10 +92,10 @@
          <type>VARCHAR</type>
       </types>
       <values>
-         <value dist="uniform" min="1" max="3000"/>
-         <value dist="binomial" min="1" max="10"/>
-         <value dist="zipf" min="1" seed="10"/>
-         <value dist="scrambled" min="1" max="10" seed="2"/>
+         <value>1</value>
+         <value>1</value>
+         <value>1</value>
+         <value>1</value>
          <value>1</value>
          <value dist="uniform" min="1674477220000" max="1706013220000"/>
          <value dist="normal" min="0.5" max="12.5"/>

From 19fad84b91c37d19e795c6c43ad5a89022d5a2eb Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Wed, 24 Jan 2024 08:48:14 +0100
Subject: [PATCH 17/24] Typo

---
 data/templated/example.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index 138ef57db..96d9f76c9 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -54,7 +54,7 @@
       </types>
       <values>
          <value dist="normal" min="10" max="12.5"/>
-         <valu dist="uniform" min="15.1" max="20.0"/>
+         <valuw dist="uniform" min="15.1" max="20.0"/>
       </values>
       <values>
          <value>10.50</value>

From c9dc450e4be1bfc4301e669bcf3541c8841bf84c Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Wed, 24 Jan 2024 08:57:49 +0100
Subject: [PATCH 18/24] Typo 2, build checked

---
 data/templated/example.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index 96d9f76c9..2e16a8be6 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -9,7 +9,7 @@
          <type>INTEGER</type>
       </types>
       <values>
-         <value dist="uniform" min="1" max="3" />
+         <value dist="uniform" min="1" max="3"/>
          <value dist="zipf" min="1"/>
       </values>
        <values>
@@ -54,7 +54,7 @@
       </types>
       <values>
          <value dist="normal" min="10" max="12.5"/>
-         <valuw dist="uniform" min="15.1" max="20.0"/>
+         <value dist="uniform" min="15.1" max="20.0"/>
       </values>
       <values>
          <value>10.50</value>

From ee8f4c110d8a5e1347c295c743f726b74bcf1e30 Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Thu, 25 Jan 2024 14:27:47 +0100
Subject: [PATCH 19/24] Enums, removal of aliases, nits

---
 data/templated/example.xml                    | 19 +++++++---
 .../templated/procedures/GenericQuery.java    | 35 +++++++++----------
 .../templated/util/TemplatedValue.java        | 32 ++++++++++-------
 .../templated/util/ValueGenerator.java        |  2 +-
 .../oltpbenchmark/util/JDBCSupportedType.java | 21 +++++++++++
 5 files changed, 72 insertions(+), 37 deletions(-)
 create mode 100644 src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java

diff --git a/data/templated/example.xml b/data/templated/example.xml
index 2e16a8be6..ec8425936 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -10,11 +10,11 @@
       </types>
       <values>
          <value dist="uniform" min="1" max="3"/>
-         <value dist="zipf" min="1"/>
+         <value dist="zipfian" min="1"/>
       </values>
        <values>
          <value dist="scrambled" seed="999"/>
-         <value>6</value>
+         <value dist="normal" min="1" max="3" seed="1"/>
       </values>
    </template>
    <template name="GetCust">
@@ -33,8 +33,8 @@
          <type>INTEGER</type>
       </types>
       <values>
+        <value>1</value>
         <value />
-        <value>8</value>
       </values>
    </template>
    <template name="GetWarehouse">
@@ -54,7 +54,7 @@
       </types>
       <values>
          <value dist="normal" min="10" max="12.5"/>
-         <value dist="uniform" min="15.1" max="20.0"/>
+         <value dist="uniform" min="15.1"/>
       </values>
       <values>
          <value>10.50</value>
@@ -67,7 +67,7 @@
          <type>INTEGER</type>
       </types>
       <values>
-         <value dist="zipf" min="10" max="40">2.1</value>
+         <value dist="zipfian" min="10" max="40">2.1</value>
       </values>
    </template>
    <template name="DeleteItem">
@@ -76,6 +76,15 @@
          <type>TIMESTAMP</type>
       </types>
       <values>
+         <value dist="uniform" min="1000" max="300000"></value>
+      </values>
+       <values>
+         <value dist="normal" min="1000" max="300000"></value>
+      </values>
+       <values>
+         <value dist="zipfian" min="1000" max="300000"></value>
+      </values>
+       <values>
          <value dist="scrambled" min="1000" max="300000"></value>
       </values>
    </template>
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index da622c8a3..813aba8a9 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -20,6 +20,7 @@
 import com.oltpbenchmark.api.SQLStmt;
 import com.oltpbenchmark.benchmarks.templated.util.TemplatedValue;
 import com.oltpbenchmark.benchmarks.templated.util.ValueGenerator;
+import com.oltpbenchmark.util.JDBCSupportedType;
 import java.sql.Connection;
 import java.sql.Date;
 import java.sql.PreparedStatement;
@@ -95,18 +96,17 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
 
       if ((!hasDist && !hasValue) || paramsTypes[i].equalsIgnoreCase("NULL")) {
         stmt.setNull(i + 1, Types.NULL);
-
       } else if (hasDist) {
         ValueGenerator distribution = param.getDistribution();
-        String paramType = paramsTypes[i].toLowerCase();
+        JDBCSupportedType paramType = JDBCSupportedType.valueOf(paramsTypes[i].toUpperCase());
         switch (paramType) {
-          case "integer":
+          case INTEGER:
             int generatedInt;
             switch (distribution) {
               case UNIFORM:
                 generatedInt = param.getNextLongUniform().intValue();
                 break;
-              case BINOMIAL:
+              case NORMAL:
                 generatedInt = param.getNextLongBinomial().intValue();
                 break;
               case ZIPFIAN:
@@ -120,14 +120,14 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
             }
             stmt.setInt(i + 1, generatedInt);
             break;
-          case "float":
-          case "real":
+          case FLOAT:
+          case REAL:
             float generatedFloat;
             switch (distribution) {
               case UNIFORM:
                 generatedFloat = param.getNextFloatUniform();
                 break;
-              case BINOMIAL:
+              case NORMAL:
                 generatedFloat = param.getNextFloatBinomial();
                 break;
               default:
@@ -135,13 +135,13 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
             }
             stmt.setFloat(i + 1, generatedFloat);
             break;
-          case "bigint":
+          case BIGINT:
             Long generatedLong;
             switch (distribution) {
               case UNIFORM:
                 generatedLong = param.getNextLongUniform();
                 break;
-              case BINOMIAL:
+              case NORMAL:
                 generatedLong = param.getNextLongBinomial();
                 break;
               case ZIPFIAN:
@@ -155,8 +155,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
             }
             stmt.setLong(i + 1, generatedLong);
             break;
-          case "varchar":
-          case "string":
+          case VARCHAR:
             switch (distribution) {
               case UNIFORM:
                 stmt.setString(i + 1, param.getNextString());
@@ -165,15 +164,15 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                 throw param.createRuntimeException(paramType);
             }
             break;
-          case "timestamp":
-          case "date":
-          case "time":
+          case TIMESTAMP:
+          case DATE:
+          case TIME:
             Long generatedTimestamp;
             switch (distribution) {
               case UNIFORM:
                 generatedTimestamp = param.getNextLongUniform();
                 break;
-              case BINOMIAL:
+              case NORMAL:
                 generatedTimestamp = param.getNextLongBinomial();
                 break;
               case ZIPFIAN:
@@ -185,9 +184,9 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
               default:
                 throw param.createRuntimeException(paramType);
             }
-            if (paramType.equals("timestamp")) {
+            if (paramType == JDBCSupportedType.TIMESTAMP) {
               stmt.setTimestamp(i + 1, new Timestamp(generatedTimestamp));
-            } else if (paramType.equals("date")) {
+            } else if (paramType == JDBCSupportedType.DATE) {
               stmt.setDate(i + 1, new Date(generatedTimestamp));
             } else {
               stmt.setTime(i + 1, new Time(generatedTimestamp));
@@ -197,7 +196,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
             throw new RuntimeException(
                 "Support for distributions for the type: "
                     + paramType
-                    + " is current not implemented");
+                    + " is not currently implemented");
         }
 
       } else {
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
index 81897b1af..e630ec53b 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -2,6 +2,7 @@
 
 import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
 import com.oltpbenchmark.distributions.ZipfianGenerator;
+import com.oltpbenchmark.util.JDBCSupportedType;
 import com.oltpbenchmark.util.TextGenerator;
 import java.util.Random;
 
@@ -23,7 +24,11 @@ public class TemplatedValue {
    * @param value Value that is used if no distribution is given
    */
   public TemplatedValue(String value) {
-    this.value = value;
+    if (value.equals("null") || value.length() < 1) {
+      this.value = null;
+    } else {
+      this.value = value;
+    }
   }
 
   /**
@@ -59,6 +64,8 @@ public TemplatedValue(String distribution, String min, String max, String seed)
     // String values are kept for the construction of Floating Point bounds
     this.minS = min;
     this.maxS = max;
+
+    this.value = null;
   }
 
   /**
@@ -74,27 +81,26 @@ private Object createGenerator(String distribution, Long min, Long max, Long see
       return null;
     }
 
-    switch (distribution.toLowerCase()) {
-      case "uniform":
+    this.distribution = ValueGenerator.valueOf(distribution.toUpperCase());
+
+    switch (this.distribution) {
+      case UNIFORM:
         this.distribution = ValueGenerator.UNIFORM;
         return new Random(seed);
-      case "binomial":
-      case "normal":
-        this.distribution = ValueGenerator.BINOMIAL;
+      case NORMAL:
+        this.distribution = ValueGenerator.NORMAL;
         return new Random(seed);
-      case "zipf":
-      case "zipfian":
+      case ZIPFIAN:
         this.distribution = ValueGenerator.ZIPFIAN;
         return new ZipfianGenerator(new Random(seed), min, max);
-      case "scrambled":
-      case "scramzipf":
+      case SCRAMBLED:
         this.distribution = ValueGenerator.SCRAMBLED;
         return new ScrambledZipfianGenerator(min, max);
       default:
         throw new RuntimeException(
             "The distribution: '"
                 + distribution
-                + "' is not supported. Currently supported are 'uniform' | 'binomial' | 'zipfian' | 'scrambled'");
+                + "' is not supported. Currently supported are 'uniform' | 'normal' | 'zipfian' | 'scrambled'");
     }
   }
 
@@ -171,8 +177,8 @@ public Float getNextFloatBinomial() {
     return generatedFloat;
   }
 
-  public RuntimeException createRuntimeException(String paramType) {
+  public RuntimeException createRuntimeException(JDBCSupportedType paramType) {
     return new RuntimeException(
-        "Distribution: " + this.distribution + " not supported for type: " + paramType);
+        "Distribution: " + this.distribution + " not supported for type: " + paramType.toString());
   }
 }
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java
index 5f554b989..c49b663b7 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java
@@ -2,7 +2,7 @@
 
 public enum ValueGenerator {
   UNIFORM,
-  BINOMIAL,
+  NORMAL,
   ZIPFIAN,
   SCRAMBLED
 }
diff --git a/src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java b/src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java
new file mode 100644
index 000000000..edd7bad39
--- /dev/null
+++ b/src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java
@@ -0,0 +1,21 @@
+package com.oltpbenchmark.util;
+
+public enum JDBCSupportedType {
+  BIGINT,
+  BIT,
+  BLOB,
+  CHAR,
+  CLOB,
+  DATE,
+  DECIMAL,
+  DOUBLE,
+  FLOAT,
+  INTEGER,
+  NUMERIC,
+  REAL,
+  SMALLINT,
+  TIME,
+  TIMESTAMP,
+  TINYINT,
+  VARCHAR
+}

From 0235de774e6b6909a2ee5369f32617f96096825e Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Thu, 25 Jan 2024 14:48:00 +0100
Subject: [PATCH 20/24] Adapted description

---
 .../benchmarks/templated/README.md            | 22 ++++++++++++++++---
 .../templated/procedures/GenericQuery.java    |  5 +++--
 .../oltpbenchmark/util/JDBCSupportedType.java |  1 +
 3 files changed, 23 insertions(+), 5 deletions(-)

diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
index e8fe5446c..2f474000f 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
@@ -81,12 +81,12 @@ Each time the query is run, a different value will substitute the `?`.
 ```
 
 The distributions are dependent on the type of the value. Currently, the following type-distributions pairs are supported:
-| Type             | uniform | binomial | zipfian | scrambled zipfian |
+| Type             | uniform | binomial | zipfian | scrambled |
 | ---------------- | :-----: | :------: | :-----: | :---------------: |
 | INTEGER          |    X    |    X     |    X    |         X         |
 | FLOAT / REAL     |    X    |    X     |    -    |         -         |
 | BIGINT           |    X    |    X     |    X    |         X         |
-| VARCHAR / STRING |    X    |    -     |    -    |         -         |
+| VARCHAR          |    X    |    -     |    -    |         -         |
 | TIMESTAMP        |    X    |    X     |    X    |         X         |
 | DATE             |    X    |    X     |    X    |         X         |
 | TIME             |    X    |    X     |    X    |         X         |
@@ -97,4 +97,20 @@ The following properties can be set on the value:
 -   `max`: The maximum value the generator can produce. Defaults to 1
 -   `seed`: A seed for the generator to ensure consistency
 
-For Timestamps, Dates and Times, the min and max values must be converted to a long (milliseconds)
+*NOTE:* For `Timestamp`, `Date`, and `Time` types, the min and max values must be converted to UNIX time (milliseconds).
+The value is interpreted as the milliseconds since January 1, 1970, 00:00:00 GMT/UTC.
+```xml
+<value 
+    dist="uniform" 
+    min="1674477220000" // Mon Jan 23 2023 12:33:40 
+    max="1706013220000" // Tue Jan 23 2024 12:33:40 
+    seed="0"
+/>
+```
+To get the current UNIX time in milliseconds, use the following bash command:
+```bash
+date +%s%3N
+```
+or use a web services like [www.currentmillis.com](www.currentmillis.com)
+
+
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 813aba8a9..1afb00466 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -94,11 +94,12 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
       boolean hasDist = param.getDistribution() != null;
       boolean hasValue = param.getValue() != null;
 
-      if ((!hasDist && !hasValue) || paramsTypes[i].equalsIgnoreCase("NULL")) {
+      JDBCSupportedType paramType = JDBCSupportedType.valueOf(paramsTypes[i].toUpperCase());
+
+      if ((!hasDist && !hasValue) || paramType == JDBCSupportedType.NULL) {
         stmt.setNull(i + 1, Types.NULL);
       } else if (hasDist) {
         ValueGenerator distribution = param.getDistribution();
-        JDBCSupportedType paramType = JDBCSupportedType.valueOf(paramsTypes[i].toUpperCase());
         switch (paramType) {
           case INTEGER:
             int generatedInt;
diff --git a/src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java b/src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java
index edd7bad39..fb777dbc2 100644
--- a/src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java
+++ b/src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java
@@ -12,6 +12,7 @@ public enum JDBCSupportedType {
   FLOAT,
   INTEGER,
   NUMERIC,
+  NULL,
   REAL,
   SMALLINT,
   TIME,

From ad94565962b52709c305a36b383668a6d8e3357a Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Wed, 20 Mar 2024 16:51:54 +0100
Subject: [PATCH 21/24] Templated Values with type information

---
 data/templated/example.xml                    |  10 +-
 .../benchmarks/templated/README.md            |  14 +-
 .../templated/TemplatedBenchmark.java         |  16 +-
 .../templated/procedures/GenericQuery.java    |  10 +-
 .../templated/util/TemplatedValue.java        | 154 ++++++++++++++----
 5 files changed, 151 insertions(+), 53 deletions(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index ec8425936..be91ed493 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -10,10 +10,10 @@
       </types>
       <values>
          <value dist="uniform" min="1" max="3"/>
-         <value dist="zipfian" min="1"/>
+         <value dist="zipfian" min="1" max="2"/>
       </values>
        <values>
-         <value dist="scrambled" seed="999"/>
+         <value dist="scrambled" min="0" max="4" seed="999"/>
          <value dist="normal" min="1" max="3" seed="1"/>
       </values>
    </template>
@@ -54,7 +54,7 @@
       </types>
       <values>
          <value dist="normal" min="10" max="12.5"/>
-         <value dist="uniform" min="15.1"/>
+         <value dist="uniform" min="15.1" max="100.22"/>
       </values>
       <values>
          <value>10.50</value>
@@ -106,9 +106,9 @@
          <value>1</value>
          <value>1</value>
          <value>1</value>
-         <value dist="uniform" min="1674477220000" max="1706013220000"/>
+         <value dist="uniform" min="1999-12-12 01:01:55" max="1706013220000"/>
          <value dist="normal" min="0.5" max="12.5"/>
-         <value dist="uniform" max="23"/>
+         <value dist="uniform" min="0" max="23"/>
       </values>
    </template>
 </templates>
\ No newline at end of file
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
index 2f474000f..cbe6d939e 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
@@ -73,7 +73,7 @@ Each time the query is run, a different value will substitute the `?`.
             <value dist="uniform" min="0" max="1000" seed="1"/>
         </values>
          <values>
-            <value dist="zipf" max="1000" seed="1"/>
+            <value dist="zipf" min="0" max="1000" seed="1"/>
         </values>
     </template>
     <!-- ... -->
@@ -93,17 +93,17 @@ The distributions are dependent on the type of the value. Currently, the followi
 The following properties can be set on the value:
 
 -   `dist`: The distribution of the values
--   `min`: The minimum value the generator can produce. Defaults to 0
--   `max`: The maximum value the generator can produce. Defaults to 1
--   `seed`: A seed for the generator to ensure consistency
+-   `min`: The minimum value the generator can produce.
+-   `max`: The maximum value the generator can produce.
+-   `seed`: A seed for the generator to ensure consistency. Default is 0
 
-*NOTE:* For `Timestamp`, `Date`, and `Time` types, the min and max values must be converted to UNIX time (milliseconds).
+*NOTE:* For `Timestamp`, `Date`, and `Time` types, the min and max values must be converted to UNIX time (milliseconds) OR given as strings in the following format: (yyyy-MM-dd HH:mm:ss).
 The value is interpreted as the milliseconds since January 1, 1970, 00:00:00 GMT/UTC.
 ```xml
 <value 
     dist="uniform" 
-    min="1674477220000" // Mon Jan 23 2023 12:33:40 
-    max="1706013220000" // Tue Jan 23 2024 12:33:40 
+    min="2023-01-23 12:33:40" // Mon Jan 23 2023 12:33:40 
+    max="1706013220000"       // Tue Jan 23 2024 12:33:40 
     seed="0"
 />
 ```
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index 176e62a8f..38ae2c533 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
@@ -184,11 +184,14 @@ private CustomClassLoader loadQueryTemplates(String file) {
 
       for (TemplateType template : templates.getTemplateList()) {
         ImmutableParsedQueryTemplate.Builder b = ImmutableParsedQueryTemplate.builder();
+        List<String> templateTypes = template.getTypes().getTypeList();
+
         b.name(template.getName());
         b.query(template.getQuery());
-        b.paramsTypes(template.getTypes().getTypeList());
+        b.paramsTypes(templateTypes);
 
         for (ValuesType paramValue : template.getValuesList()) {
+          int typeIndex = 0;
           for (ValueType value : paramValue.getValueList()) {
             /* Lightweight constructor used if no distribution is present */
             if (value.getDist() == null
@@ -198,8 +201,13 @@ private CustomClassLoader loadQueryTemplates(String file) {
             } else {
               b.addParamsValues(
                   new TemplatedValue(
-                      value.getDist(), value.getMin(), value.getMax(), value.getSeed()));
+                      value.getDist(),
+                      value.getMin(),
+                      value.getMax(),
+                      value.getSeed(),
+                      templateTypes.get(typeIndex)));
             }
+            typeIndex++;
           }
         }
 
@@ -274,6 +282,10 @@ private String buildTemplatedValueString(List<TemplatedValue> params) {
                 + "\""
                 + param.getSeed()
                 + "\""
+                + ","
+                + "\""
+                + param.getValueType()
+                + "\""
                 + "),";
       } else {
         result +=
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
index 1afb00466..9c5ea67d0 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -117,7 +117,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                 generatedInt = param.getNextLongScrambled().intValue();
                 break;
               default:
-                throw param.createRuntimeException(paramType);
+                throw param.createRuntimeException();
             }
             stmt.setInt(i + 1, generatedInt);
             break;
@@ -132,7 +132,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                 generatedFloat = param.getNextFloatBinomial();
                 break;
               default:
-                throw param.createRuntimeException(paramType);
+                throw param.createRuntimeException();
             }
             stmt.setFloat(i + 1, generatedFloat);
             break;
@@ -152,7 +152,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                 generatedLong = param.getNextLongScrambled();
                 break;
               default:
-                throw param.createRuntimeException(paramType);
+                throw param.createRuntimeException();
             }
             stmt.setLong(i + 1, generatedLong);
             break;
@@ -162,7 +162,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                 stmt.setString(i + 1, param.getNextString());
                 break;
               default:
-                throw param.createRuntimeException(paramType);
+                throw param.createRuntimeException();
             }
             break;
           case TIMESTAMP:
@@ -183,7 +183,7 @@ public PreparedStatement getStatement(Connection conn, List<TemplatedValue> para
                 generatedTimestamp = param.getNextLongScrambled();
                 break;
               default:
-                throw param.createRuntimeException(paramType);
+                throw param.createRuntimeException();
             }
             if (paramType == JDBCSupportedType.TIMESTAMP) {
               stmt.setTimestamp(i + 1, new Timestamp(generatedTimestamp));
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
index e630ec53b..0be811da0 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -4,6 +4,8 @@
 import com.oltpbenchmark.distributions.ZipfianGenerator;
 import com.oltpbenchmark.util.JDBCSupportedType;
 import com.oltpbenchmark.util.TextGenerator;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
 import java.util.Random;
 
 /**
@@ -11,13 +13,15 @@
  * hold static values but also generators for value distributions
  */
 public class TemplatedValue {
+  static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
   ValueGenerator distribution;
   Long min;
   Long max;
   Long seed;
   String value;
-  String minS;
-  String maxS;
+  JDBCSupportedType valueType;
+  Float minF;
+  Float maxF;
   Object generatorObject;
 
   /**
@@ -33,41 +37,99 @@ public TemplatedValue(String value) {
 
   /**
    * @param distribution The desired value distribution
-   * @param min Minimum value. Default is 0
-   * @param max Maximum value. Default is min + 1
+   * @param min Minimum value
+   * @param max Maximum value
    * @param seed The seed for the random generator. Default is 0
    * @param value Value that is used if no distribution is given
    */
-  public TemplatedValue(String distribution, String min, String max, String seed) {
-    try {
-      this.min = Long.parseLong(min);
-    } catch (Exception e) {
-      this.min = 0L;
-    }
+  public TemplatedValue(
+      String distribution, String min, String max, String seed, String valueType) {
+    this.valueType = JDBCSupportedType.valueOf(valueType.toUpperCase());
 
-    try {
-      this.max = Long.parseLong(max);
-    } catch (Exception e) {
-      this.max = this.min + 1L;
+    switch (this.valueType) {
+      case DATE:
+      case TIME:
+      case TIMESTAMP:
+        this.min = parseDateTime(min);
+        this.max = parseDateTime(max);
+        assert this.max > this.min;
+        break;
+      case FLOAT:
+      case REAL:
+        this.minF = parseBoundaryFloat(min);
+        this.maxF = parseBoundaryFloat(max);
+        assert this.maxF > this.minF;
+        break;
+      default:
+        this.min = parseBoundary(min);
+        this.max = parseBoundary(max);
+        assert this.max > this.min;
+        break;
     }
 
-    assert this.max > this.min;
-
+    // Parse seed with fallback of 0L
     try {
       this.seed = Long.parseLong(seed);
-    } catch (Exception e) {
+    } catch (NumberFormatException e) {
       this.seed = 0L;
     }
 
-    this.generatorObject = createGenerator(distribution, this.min, this.max, this.seed);
+    assert this.seed >= 0L;
 
-    // String values are kept for the construction of Floating Point bounds
-    this.minS = min;
-    this.maxS = max;
+    this.generatorObject = createGenerator(distribution, this.min, this.max, this.seed);
 
     this.value = null;
   }
 
+  /**
+   * @param boundary A string signifying a numerical bondary
+   * @return The numerical value parsed to a Long
+   */
+  private Long parseBoundary(String boundary) {
+    Long lBound;
+    try {
+      lBound = Long.parseLong(boundary);
+    } catch (NumberFormatException e) {
+      throw new RuntimeException(
+          String.format("Error occurred while trying to parse %s to a Long", boundary));
+    }
+    return lBound;
+  }
+
+  /**
+   * @param boundary A string signifying a numerical bondary
+   * @return The numerical value parsed to a float
+   */
+  private Float parseBoundaryFloat(String boundary) {
+    Float fBound;
+    try {
+      fBound = Float.parseFloat(boundary);
+    } catch (NumberFormatException e) {
+      throw new RuntimeException(
+          String.format("Error occurred while trying to parse %s to a Float", boundary));
+    }
+    return fBound;
+  }
+
+  /**
+   * @param timeSource A String in a specific time format (yyyy-MM-dd HH:mm:ss) or UNIX timestamp
+   * @return The UNIX timestamp of the value
+   */
+  private Long parseDateTime(String timeSource) {
+    long timestamp;
+    try {
+      timestamp = Long.parseLong(timeSource);
+    } catch (NumberFormatException ex) {
+      try {
+        timestamp = dateFormat.parse(timeSource).getTime();
+      } catch (ParseException e) {
+        throw new RuntimeException(
+            String.format("Error occurred while trying to parse date: %s", timeSource));
+      }
+    }
+    return timestamp;
+  }
+
   /**
    * @param distribution The distribution that drives the generator
    * @param min Minimum value the generator will produce
@@ -108,27 +170,35 @@ public ValueGenerator getDistribution() {
     return this.distribution;
   }
 
-  public Long getMin() {
-    return this.min;
+  public String getMin() {
+    return (this.min != null) ? this.min.toString() : this.minF.toString();
   }
 
-  public Long getMax() {
-    return this.max;
+  public String getMax() {
+    return (this.max != null) ? this.max.toString() : this.maxF.toString();
   }
 
-  public Long getSeed() {
-    return this.seed;
+  public String getSeed() {
+    return this.seed.toString();
   }
 
   public String getValue() {
     return this.value;
   }
 
+  public String getValueType() {
+    return this.valueType.toString();
+  }
+
   public Object getGenerator() {
     return this.generatorObject;
   }
 
   public Long getNextLongBinomial() {
+    assert !this.valueType.equals(JDBCSupportedType.REAL)
+        && !this.valueType.equals(JDBCSupportedType.FLOAT)
+        && !this.valueType.equals(JDBCSupportedType.VARCHAR)
+        && !this.valueType.equals(JDBCSupportedType.CHAR);
     Random binomialGenerator = (Random) this.generatorObject;
     Long generatedValue;
     do {
@@ -141,44 +211,60 @@ public Long getNextLongBinomial() {
   }
 
   public Long getNextLongUniform() {
+    assert !this.valueType.equals(JDBCSupportedType.REAL)
+        && !this.valueType.equals(JDBCSupportedType.FLOAT)
+        && !this.valueType.equals(JDBCSupportedType.VARCHAR)
+        && !this.valueType.equals(JDBCSupportedType.CHAR);
     Random uniformGenerator = (Random) this.generatorObject;
     return uniformGenerator.nextLong(this.min, this.max);
   }
 
   public Long getNextLongZipf() {
+    assert !this.valueType.equals(JDBCSupportedType.REAL)
+        && !this.valueType.equals(JDBCSupportedType.FLOAT)
+        && !this.valueType.equals(JDBCSupportedType.VARCHAR)
+        && !this.valueType.equals(JDBCSupportedType.CHAR);
     ZipfianGenerator zipfianGenerator = (ZipfianGenerator) this.generatorObject;
     return zipfianGenerator.nextLong();
   }
 
   public Long getNextLongScrambled() {
+    assert !this.valueType.equals(JDBCSupportedType.REAL)
+        && !this.valueType.equals(JDBCSupportedType.FLOAT)
+        && !this.valueType.equals(JDBCSupportedType.VARCHAR)
+        && !this.valueType.equals(JDBCSupportedType.CHAR);
     ScrambledZipfianGenerator scrambledGenerator = (ScrambledZipfianGenerator) this.generatorObject;
     return scrambledGenerator.nextLong();
   }
 
   public String getNextString() {
+    assert this.valueType.equals(JDBCSupportedType.VARCHAR)
+        || this.valueType.equals(JDBCSupportedType.CHAR);
     Random stringGenerator = (Random) this.generatorObject;
     return TextGenerator.randomStr(stringGenerator, this.max.intValue());
   }
 
   public Float getNextFloatUniform() {
+    assert this.valueType.equals(JDBCSupportedType.REAL)
+        || this.valueType.equals(JDBCSupportedType.FLOAT);
     Random floatGenerator = (Random) this.generatorObject;
-    return floatGenerator.nextFloat(Float.parseFloat(this.minS), Float.parseFloat(this.maxS));
+    return floatGenerator.nextFloat(this.minF, this.maxF);
   }
 
   public Float getNextFloatBinomial() {
-    Float minF = Float.parseFloat(this.minS);
-    Float maxF = Float.parseFloat(this.maxS);
+    assert this.valueType.equals(JDBCSupportedType.REAL)
+        || this.valueType.equals(JDBCSupportedType.FLOAT);
     Random floatGenerator = (Random) this.generatorObject;
     Float generatedFloat;
     do {
-      generatedFloat = (float) (minF + Math.abs(floatGenerator.nextGaussian()) * maxF);
-    } while (generatedFloat > maxF || generatedFloat < minF);
+      generatedFloat = (float) (this.minF + Math.abs(floatGenerator.nextGaussian()) * this.maxF);
+    } while (generatedFloat > this.maxF || generatedFloat < this.minF);
 
     return generatedFloat;
   }
 
-  public RuntimeException createRuntimeException(JDBCSupportedType paramType) {
+  public RuntimeException createRuntimeException() {
     return new RuntimeException(
-        "Distribution: " + this.distribution + " not supported for type: " + paramType.toString());
+        "Distribution: " + this.distribution + " not supported for type: " + getValueType());
   }
 }

From 556ff15266183bf9b08301f42ad3114661d2ac0d Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Thu, 21 Mar 2024 10:12:04 +0100
Subject: [PATCH 22/24] README cleanup + Assert pattern

---
 data/templated/example.xml                    |  4 +--
 .../benchmarks/templated/README.md            | 34 +++++++++++++-----
 .../templated/util/TemplatedValue.java        | 36 ++++++++++---------
 3 files changed, 48 insertions(+), 26 deletions(-)

diff --git a/data/templated/example.xml b/data/templated/example.xml
index be91ed493..e4c428b14 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -67,7 +67,7 @@
          <type>INTEGER</type>
       </types>
       <values>
-         <value dist="zipfian" min="10" max="40">2.1</value>
+         <value dist="zipfian" min="10" max="40">2</value>
       </values>
    </template>
    <template name="DeleteItem">
@@ -106,7 +106,7 @@
          <value>1</value>
          <value>1</value>
          <value>1</value>
-         <value dist="uniform" min="1999-12-12 01:01:55" max="1706013220000"/>
+         <value dist="uniform" min="1999-12-12 01:01:55" max="2000-12-12 04:04:44"/>
          <value dist="normal" min="0.5" max="12.5"/>
          <value dist="uniform" min="0" max="23"/>
       </values>
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
index cbe6d939e..1adc429e0 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
@@ -90,22 +90,40 @@ The distributions are dependent on the type of the value. Currently, the followi
 | TIMESTAMP        |    X    |    X     |    X    |         X         |
 | DATE             |    X    |    X     |    X    |         X         |
 | TIME             |    X    |    X     |    X    |         X         |
-The following properties can be set on the value:
 
--   `dist`: The distribution of the values
--   `min`: The minimum value the generator can produce.
--   `max`: The maximum value the generator can produce.
--   `seed`: A seed for the generator to ensure consistency. Default is 0
+The following properties can be set for templated distributions:
 
-*NOTE:* For `Timestamp`, `Date`, and `Time` types, the min and max values must be converted to UNIX time (milliseconds) OR given as strings in the following format: (yyyy-MM-dd HH:mm:ss).
-The value is interpreted as the milliseconds since January 1, 1970, 00:00:00 GMT/UTC.
+| Property | description                                    | required | default | 
+| -----    | ---------------------------------------------- | :------: | :-----: |
+| dist     | The distribution of the values                 | Yes      | -       |
+| min      | The minimum value the generator can produce    | Yes      | -       |
+| max      | The maximum value the generator can produce    | Yes      | -       |
+| seed     | A seed for the generator to ensure consistency | No       | 0       |
+
+
+### Timestamps, Dates and Time
+
+For `Timestamp`, `Date`, and `Time` types, the min and max values can be given as a Long value or string.
+- The Long value is interpreted as the milliseconds since January 1, 1970, 00:00:00 GMT/UTC.
+
+- The string value is interpreted as UTC timezone and must have the following format: (yyyy-MM-dd HH:mm:ss)
+
+#### Example
 ```xml
+<value 
+    dist="uniform" 
+    min="1674477220000" // Mon Jan 23 2023 12:33:40 
+    max="1706013220000" // Tue Jan 23 2024 12:33:40 
+    seed="0"
+/>
+
 <value 
     dist="uniform" 
     min="2023-01-23 12:33:40" // Mon Jan 23 2023 12:33:40 
-    max="1706013220000"       // Tue Jan 23 2024 12:33:40 
+    max="2024-01-23 12:33:40" // Tue Jan 23 2024 12:33:40 
     seed="0"
 />
+
 ```
 To get the current UNIX time in milliseconds, use the following bash command:
 ```bash
diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
index 0be811da0..d302ab1fc 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -195,10 +195,11 @@ public Object getGenerator() {
   }
 
   public Long getNextLongBinomial() {
-    assert !this.valueType.equals(JDBCSupportedType.REAL)
-        && !this.valueType.equals(JDBCSupportedType.FLOAT)
-        && !this.valueType.equals(JDBCSupportedType.VARCHAR)
-        && !this.valueType.equals(JDBCSupportedType.CHAR);
+    assert this.valueType.equals(JDBCSupportedType.INTEGER)
+        || this.valueType.equals(JDBCSupportedType.BIGINT)
+        || this.valueType.equals(JDBCSupportedType.DATE)
+        || this.valueType.equals(JDBCSupportedType.TIME)
+        || this.valueType.equals(JDBCSupportedType.TIMESTAMP);
     Random binomialGenerator = (Random) this.generatorObject;
     Long generatedValue;
     do {
@@ -211,28 +212,31 @@ public Long getNextLongBinomial() {
   }
 
   public Long getNextLongUniform() {
-    assert !this.valueType.equals(JDBCSupportedType.REAL)
-        && !this.valueType.equals(JDBCSupportedType.FLOAT)
-        && !this.valueType.equals(JDBCSupportedType.VARCHAR)
-        && !this.valueType.equals(JDBCSupportedType.CHAR);
+    assert this.valueType.equals(JDBCSupportedType.INTEGER)
+        || this.valueType.equals(JDBCSupportedType.BIGINT)
+        || this.valueType.equals(JDBCSupportedType.DATE)
+        || this.valueType.equals(JDBCSupportedType.TIME)
+        || this.valueType.equals(JDBCSupportedType.TIMESTAMP);
     Random uniformGenerator = (Random) this.generatorObject;
     return uniformGenerator.nextLong(this.min, this.max);
   }
 
   public Long getNextLongZipf() {
-    assert !this.valueType.equals(JDBCSupportedType.REAL)
-        && !this.valueType.equals(JDBCSupportedType.FLOAT)
-        && !this.valueType.equals(JDBCSupportedType.VARCHAR)
-        && !this.valueType.equals(JDBCSupportedType.CHAR);
+    assert this.valueType.equals(JDBCSupportedType.INTEGER)
+        || this.valueType.equals(JDBCSupportedType.BIGINT)
+        || this.valueType.equals(JDBCSupportedType.DATE)
+        || this.valueType.equals(JDBCSupportedType.TIME)
+        || this.valueType.equals(JDBCSupportedType.TIMESTAMP);
     ZipfianGenerator zipfianGenerator = (ZipfianGenerator) this.generatorObject;
     return zipfianGenerator.nextLong();
   }
 
   public Long getNextLongScrambled() {
-    assert !this.valueType.equals(JDBCSupportedType.REAL)
-        && !this.valueType.equals(JDBCSupportedType.FLOAT)
-        && !this.valueType.equals(JDBCSupportedType.VARCHAR)
-        && !this.valueType.equals(JDBCSupportedType.CHAR);
+    assert this.valueType.equals(JDBCSupportedType.INTEGER)
+        || this.valueType.equals(JDBCSupportedType.BIGINT)
+        || this.valueType.equals(JDBCSupportedType.DATE)
+        || this.valueType.equals(JDBCSupportedType.TIME)
+        || this.valueType.equals(JDBCSupportedType.TIMESTAMP);
     ScrambledZipfianGenerator scrambledGenerator = (ScrambledZipfianGenerator) this.generatorObject;
     return scrambledGenerator.nextLong();
   }

From c039d925f3bad5948d824a15e8b6a67eba4b6f2b Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Mon, 25 Mar 2024 11:36:55 +0100
Subject: [PATCH 23/24] README update for access pattern

---
 .../benchmarks/templated/README.md            | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
index 1adc429e0..3fef2a989 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
@@ -56,6 +56,30 @@ java -jar benchbase.jar -b templated -c config/sqlserver/sample_templated_config
 
 > For additional examples, please refer to the build pipeline definition in the [`maven.yml`](../../../../../../../.github/workflows/maven.yml#L423) Github Actions workflow file.
 
+### Value selection
+
+<!-- This can be expanded in the future to allow other access patterns -->
+The values are selected in **Round-Robin** fashion, giving the following access pattern for query 'Q1': 
+
+`V1 --> V2 --> V1 --> V2 ...`
+
+```xml
+<templates>
+    <template name="Q1">
+        <query><![CDATA[$SQLQuery]]></query>
+        <types>
+            <type>Type1</type>
+        </types>
+        <values>
+            <value>V1</value>
+        </values>
+        <values>
+            <value>V2</value>
+        </values>
+    </template>
+<templates>
+```
+
 ## Value Distributions
 
 In order to support more variety in templated queries, it is possible to use a whole distribution of values instead of a single static value in a templated query

From 5de536173cdc68bdaad0ca2449d3fd095d4ab20e Mon Sep 17 00:00:00 2001
From: Eric Enzler <enzlere@gmail.com>
Date: Mon, 25 Mar 2024 11:42:50 +0100
Subject: [PATCH 24/24] README adjustment showing a possible solution for value
 weighting

---
 src/main/java/com/oltpbenchmark/benchmarks/templated/README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
index 3fef2a989..865775349 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/README.md
@@ -80,6 +80,8 @@ The values are selected in **Round-Robin** fashion, giving the following access
 <templates>
 ```
 
+For now, more fine-grained control of the access pattern can be achieved by building a new query for each value and adjusting the weight of each query in the config file.
+
 ## Value Distributions
 
 In order to support more variety in templated queries, it is possible to use a whole distribution of values instead of a single static value in a templated query