From cc2cfa5ed6d8abeec111e11be78d7508d0efa90e Mon Sep 17 00:00:00 2001
From: Eric Enzler <92583189+ETHenzlere@users.noreply.github.com>
Date: Mon, 25 Mar 2024 12:30:49 -0400
Subject: [PATCH] Feat: Support for Distributions in Templated Workloads (#385)

PR adds support for various Numerical Distributions in templated
benchmarks

- Uniform
- Binomial
- Zipfian
- Scrambled

The distributions work not only for integers, but also different types
such as timestamps, long, float
A table of supported combinations can be found in the templated
benchmarks readme.

| 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|

Usage example:

```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" min="1" max="1000" seed="2"/>
        </values>
    </template>
    <!-- ... -->
<templates>
```
This PR is not a breaking change - One can still use a static value in
the templated queries.
`<value>10</value>`

In the future, I could see a breaking change that adds the datatype
directly to the values so the TemplatedValue can do the type handling
directly. `<value dist="uniform" type="integer">`. This would make type
checking easier and remove the need to store the original min/max values
as strings for all datatypes.

---------

Co-authored-by: Brian Kroth <bpkroth@users.noreply.github.com>
---
 data/templated/example.xml                    |  39 ++-
 .../api/templates/ObjectFactory.java          |  31 +-
 .../api/templates/TemplateType.java           |  93 ++++--
 .../api/templates/TemplatesType.java          |  45 +--
 .../api/templates/TypesType.java              |  36 ++-
 .../api/templates/ValueType.java              | 140 +++++++++
 .../api/templates/ValuesType.java             |  44 +--
 .../benchmarks/templated/README.md            | 106 ++++++-
 .../templated/TemplatedBenchmark.java         |  99 ++++++-
 .../templated/procedures/GenericQuery.java    | 134 ++++++++-
 .../templated/util/GenericQueryOperation.java |   6 +-
 .../templated/util/TemplatedValue.java        | 274 ++++++++++++++++++
 .../templated/util/ValueGenerator.java        |   8 +
 .../oltpbenchmark/util/JDBCSupportedType.java |  22 ++
 src/main/resources/templates.xsd              |  18 +-
 15 files changed, 971 insertions(+), 124 deletions(-)
 create mode 100644 src/main/java/com/oltpbenchmark/api/templates/ValueType.java
 create mode 100644 src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
 create mode 100644 src/main/java/com/oltpbenchmark/benchmarks/templated/util/ValueGenerator.java
 create mode 100644 src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java

diff --git a/data/templated/example.xml b/data/templated/example.xml
index 4051b8a7b..e4c428b14 100644
--- a/data/templated/example.xml
+++ b/data/templated/example.xml
@@ -9,12 +9,12 @@
          <type>INTEGER</type>
       </types>
       <values>
-         <value>3</value>
-         <value>4</value>
+         <value dist="uniform" min="1" max="3"/>
+         <value dist="zipfian" min="1" max="2"/>
       </values>
        <values>
-         <value>5</value>
-         <value>6</value>
+         <value dist="scrambled" min="0" max="4" seed="999"/>
+         <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">
@@ -53,8 +53,8 @@
          <type>FLOAT</type>
       </types>
       <values>
-         <value>10</value>
-         <value>10.49</value>
+         <value dist="normal" min="10" max="12.5"/>
+         <value dist="uniform" min="15.1" max="100.22"/>
       </values>
       <values>
          <value>10.50</value>
@@ -64,19 +64,28 @@
     <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="zipfian" min="10" max="40">2</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="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>
    <template name="InsertItem">
@@ -97,9 +106,9 @@
          <value>1</value>
          <value>1</value>
          <value>1</value>
-         <value>2022-10-10 11:30:30</value>
-         <value>1.0</value>
-         <value>Test</value>
+         <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>
    </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 3fa4c965d..36634ae2b 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/ObjectFactory.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/ObjectFactory.java
@@ -17,10 +17,10 @@
 
 //
 // 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>
+// 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;
@@ -32,7 +32,7 @@
 
 /**
  * This object contains factory methods for each Java content interface and Java element interface
- * generated in the com.oltpbenchmark.api.templates package.
+ * 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
@@ -46,10 +46,15 @@ public class ObjectFactory {
 
   /**
    * Create a new ObjectFactory that can be used to create new instances of schema derived classes
-   * for package: com.oltpbenchmark.api.templates
+   * 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,9 +70,19 @@ 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 427180c28..d5c59d276 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TemplateType.java
@@ -17,10 +17,10 @@
 
 //
 // 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>
+// 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;
@@ -30,21 +30,23 @@
 import java.util.List;
 
 /**
- * Java class for dialectType complex type.
+ * 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)
@@ -53,9 +55,6 @@
     propOrder = {"query", "types", "values"})
 public class TemplateType {
 
-  @XmlAttribute(required = true)
-  protected String name;
-
   @XmlElement(required = true)
   protected String query;
 
@@ -65,24 +64,63 @@ public class TemplateType {
   @XmlElement(required = true)
   protected List<ValuesType> values;
 
-  /** Gets the value of the query property. */
+  @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;
   }
 
-  /** Gets the value of the types property. */
+  /**
+   * 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;
   }
 
   /**
-   * 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 }
    */
-  public List<ValuesType> getValues() {
+  public List<ValuesType> getValuesList() {
     if (this.values == null) {
-      this.values = new ArrayList<>();
+      this.values = new ArrayList<ValuesType>();
     }
     return this.values;
   }
@@ -93,6 +131,15 @@ public List<ValuesType> getValues() {
    * @return possible object is {@link String }
    */
   public String getName() {
-    return name;
+    return this.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 4773c4986..cb8ad6d28 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TemplatesType.java
@@ -17,36 +17,33 @@
 
 //
 // 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>
+// 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 jakarta.xml.bind.annotation.*;
 import java.util.ArrayList;
 import java.util.List;
 
 /**
- * Java class for dialectsType complex type.
+ * 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)
@@ -59,13 +56,23 @@ 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 }
    */
   public List<TemplateType> getTemplateList() {
     if (this.template == null) {
-      this.template = new ArrayList<>();
+      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 6fec026c2..8c43e4b8e 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/TypesType.java
@@ -17,10 +17,10 @@
 
 //
 // 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>
+// 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;
@@ -30,20 +30,20 @@
 import java.util.List;
 
 /**
- * Java class for dialectType complex type.
+ * 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)
@@ -58,6 +58,16 @@ public class TypesType {
   /**
    * Gets the value of the type 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 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() {
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..07a2fa9ca
--- /dev/null
+++ b/src/main/java/com/oltpbenchmark/api/templates/ValueType.java
@@ -0,0 +1,140 @@
+//
+// 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.*;
+
+/**
+ * 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 6711ff53a..ee9bf4138 100644
--- a/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
+++ b/src/main/java/com/oltpbenchmark/api/templates/ValuesType.java
@@ -17,10 +17,10 @@
 
 //
 // 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>
+// 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;
@@ -30,20 +30,20 @@
 import java.util.List;
 
 /**
- * Java class for dialectType complex type.
+ * 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)
@@ -53,16 +53,26 @@
 public class ValuesType {
 
   @XmlElement(required = true)
-  protected List<String> value;
+  protected List<ValueType> value;
 
   /**
    * Gets the value of the value property.
    *
-   * <p>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() {
+  public List<ValueType> getValueList() {
     if (this.value == null) {
-      this.value = new ArrayList<>();
+      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..865775349 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,106 @@ 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>
+```
+
+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
+
+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" min="0" 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 |
+| ---------------- | :-----: | :------: | :-----: | :---------------: |
+| INTEGER          |    X    |    X     |    X    |         X         |
+| FLOAT / REAL     |    X    |    X     |    -    |         -         |
+| BIGINT           |    X    |    X     |    X    |         X         |
+| VARCHAR          |    X    |    -     |    -    |         -         |
+| TIMESTAMP        |    X    |    X     |    X    |         X         |
+| DATE             |    X    |    X     |    X    |         X         |
+| TIME             |    X    |    X     |    X    |         X         |
+
+The following properties can be set for templated distributions:
+
+| 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="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
+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/TemplatedBenchmark.java b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
index c92ccf767..38ae2c533 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/TemplatedBenchmark.java
@@ -25,18 +25,19 @@
 import com.oltpbenchmark.api.Worker;
 import com.oltpbenchmark.api.templates.TemplateType;
 import com.oltpbenchmark.api.templates.TemplatesType;
+import com.oltpbenchmark.api.templates.ValueType;
 import com.oltpbenchmark.api.templates.ValuesType;
 import com.oltpbenchmark.benchmarks.templated.procedures.GenericQuery;
 import com.oltpbenchmark.benchmarks.templated.procedures.GenericQuery.QueryTemplateInfo;
 import com.oltpbenchmark.benchmarks.templated.util.GenericQueryOperation;
+import com.oltpbenchmark.benchmarks.templated.util.TemplatedValue;
 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;
 import jakarta.xml.bind.Unmarshaller;
 import java.io.FileInputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -120,12 +121,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;
+
+        TemplatedValue[] params = info.getParamsValues();
+        int paramsLen = params.length;
+        int typesLen = paramsTypes.length;
+
+        assert (paramsLen % typesLen) == 0;
+
+        if (paramsLen == typesLen) {
           list.add(new GenericQueryOperation(params));
+        } else {
+          int numSplits = paramsLen / typesLen;
+          for (int j = 0; j < numSplits; j += 1) {
+            TemplatedValue[] 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));
       }
 
@@ -138,6 +152,7 @@ protected List<Worker<? extends BenchmarkModule>> makeWorkersImpl() {
     } catch (Exception e) {
       throw new IllegalStateException("Unable to create workers", e);
     }
+
     return workers;
   }
 
@@ -169,11 +184,31 @@ 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());
-        for (ValuesType paramValue : template.getValues()) {
-          b.addParamsValues(String.join(",", paramValue.getValueList()));
+        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
+                || 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(),
+                      templateTypes.get(typeIndex)));
+            }
+            typeIndex++;
+          }
         }
 
         ParsedQueryTemplate qt = b.build();
@@ -181,26 +216,28 @@ private CustomClassLoader loadQueryTemplates(String file) {
         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 TemplatedValue[] {%s})
                                         .build();
                             }
                         }
                         """
                 .formatted(
                     GenericQuery.class.getPackageName(),
+                    TemplatedValue.class.getCanonicalName(),
                     qt.getName(),
                     GenericQuery.class.getCanonicalName(),
                     QueryTemplateInfo.class.getCanonicalName(),
                     SQLStmt.class.getCanonicalName(),
                     StringEscapeUtils.escapeJava(qt.getQuery()),
                     getParamsString(qt.getParamsTypes()),
-                    getParamsString(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();
@@ -224,6 +261,44 @@ private String getParamsString(List<String> params) {
     return result.isEmpty() ? "" : result.substring(0, result.length() - 1);
   }
 
+  private String buildTemplatedValueString(List<TemplatedValue> params) {
+    String result = "";
+    for (TemplatedValue param : params) {
+      if (param.getDistribution() != null) {
+        result +=
+            "new TemplatedValue("
+                + "\""
+                + param.getDistribution()
+                + "\""
+                + ","
+                + "\""
+                + param.getMin()
+                + "\""
+                + ","
+                + "\""
+                + param.getMax()
+                + "\""
+                + ","
+                + "\""
+                + param.getSeed()
+                + "\""
+                + ","
+                + "\""
+                + param.getValueType()
+                + "\""
+                + "),";
+      } else {
+        result +=
+            "new TemplatedValue("
+                + "\""
+                + 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<>();
@@ -271,7 +346,7 @@ default List<String> getParamsTypes() {
 
     /** Potential query parameter values. */
     @Value.Default
-    default List<String> 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 e4ab9a2b1..9c5ea67d0 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/procedures/GenericQuery.java
@@ -18,10 +18,16 @@
 
 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.util.JDBCSupportedType;
 import java.sql.Connection;
+import java.sql.Date;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
 import java.sql.Types;
 import java.util.List;
 import org.immutables.value.Value;
@@ -33,7 +39,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<Object> params) throws SQLException {
+  public void run(Connection conn, List<TemplatedValue> params) throws SQLException {
 
     try (PreparedStatement stmt = getStatement(conn, params)) {
       boolean hasResultSet = stmt.execute();
@@ -76,24 +82,130 @@ 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<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++) {
-      if (paramsTypes[i].equalsIgnoreCase("NULL")) {
+
+      TemplatedValue param = params.get(i);
+      boolean hasDist = param.getDistribution() != null;
+      boolean hasValue = param.getValue() != 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();
+        switch (paramType) {
+          case INTEGER:
+            int generatedInt;
+            switch (distribution) {
+              case UNIFORM:
+                generatedInt = param.getNextLongUniform().intValue();
+                break;
+              case NORMAL:
+                generatedInt = param.getNextLongBinomial().intValue();
+                break;
+              case ZIPFIAN:
+                generatedInt = param.getNextLongZipf().intValue();
+                break;
+              case SCRAMBLED:
+                generatedInt = param.getNextLongScrambled().intValue();
+                break;
+              default:
+                throw param.createRuntimeException();
+            }
+            stmt.setInt(i + 1, generatedInt);
+            break;
+          case FLOAT:
+          case REAL:
+            float generatedFloat;
+            switch (distribution) {
+              case UNIFORM:
+                generatedFloat = param.getNextFloatUniform();
+                break;
+              case NORMAL:
+                generatedFloat = param.getNextFloatBinomial();
+                break;
+              default:
+                throw param.createRuntimeException();
+            }
+            stmt.setFloat(i + 1, generatedFloat);
+            break;
+          case BIGINT:
+            Long generatedLong;
+            switch (distribution) {
+              case UNIFORM:
+                generatedLong = param.getNextLongUniform();
+                break;
+              case NORMAL:
+                generatedLong = param.getNextLongBinomial();
+                break;
+              case ZIPFIAN:
+                generatedLong = param.getNextLongZipf();
+                break;
+              case SCRAMBLED:
+                generatedLong = param.getNextLongScrambled();
+                break;
+              default:
+                throw param.createRuntimeException();
+            }
+            stmt.setLong(i + 1, generatedLong);
+            break;
+          case VARCHAR:
+            switch (distribution) {
+              case UNIFORM:
+                stmt.setString(i + 1, param.getNextString());
+                break;
+              default:
+                throw param.createRuntimeException();
+            }
+            break;
+          case TIMESTAMP:
+          case DATE:
+          case TIME:
+            Long generatedTimestamp;
+            switch (distribution) {
+              case UNIFORM:
+                generatedTimestamp = param.getNextLongUniform();
+                break;
+              case NORMAL:
+                generatedTimestamp = param.getNextLongBinomial();
+                break;
+              case ZIPFIAN:
+                generatedTimestamp = param.getNextLongZipf();
+                break;
+              case SCRAMBLED:
+                generatedTimestamp = param.getNextLongScrambled();
+                break;
+              default:
+                throw param.createRuntimeException();
+            }
+            if (paramType == JDBCSupportedType.TIMESTAMP) {
+              stmt.setTimestamp(i + 1, new Timestamp(generatedTimestamp));
+            } else if (paramType == JDBCSupportedType.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 not currently implemented");
+        }
+
       } 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);
+          Object val = param.getValue();
           stmt.setObject(
               i + 1,
-              param,
+              val,
               Integer.parseInt(Types.class.getDeclaredField(paramsTypes[i]).get(null).toString()));
         } catch (Exception e) {
           e.printStackTrace();
@@ -101,7 +213,7 @@ public PreparedStatement getStatement(Connection conn, List<Object> params) thro
               "Error when setting parameters. Parameter type: "
                   + paramsTypes[i]
                   + ", parameter value: "
-                  + params.get(i));
+                  + param.getValue());
         }
       }
     }
@@ -120,6 +232,6 @@ public interface QueryTemplateInfo {
     String[] getParamsTypes();
 
     /** Potential query parameter values. */
-    String[] getParamsValues();
+    TemplatedValue[] getParamsValues();
   }
 }
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 2a1820fa0..fdabcc381 100644
--- a/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/GenericQueryOperation.java
@@ -24,14 +24,14 @@
 /** Immutable class containing information about transactions. */
 public class GenericQueryOperation extends Operation {
 
-  public final List<Object> params;
+  public final List<TemplatedValue> params;
 
-  public GenericQueryOperation(Object[] params) {
+  public GenericQueryOperation(TemplatedValue[] params) {
     super();
     this.params = Collections.unmodifiableList(Arrays.asList(params));
   }
 
-  public List<Object> 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..d302ab1fc
--- /dev/null
+++ b/src/main/java/com/oltpbenchmark/benchmarks/templated/util/TemplatedValue.java
@@ -0,0 +1,274 @@
+package com.oltpbenchmark.benchmarks.templated.util;
+
+import com.oltpbenchmark.distributions.ScrambledZipfianGenerator;
+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;
+
+/**
+ * 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 {
+  static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+  ValueGenerator distribution;
+  Long min;
+  Long max;
+  Long seed;
+  String value;
+  JDBCSupportedType valueType;
+  Float minF;
+  Float maxF;
+  Object generatorObject;
+
+  /**
+   * @param value Value that is used if no distribution is given
+   */
+  public TemplatedValue(String value) {
+    if (value.equals("null") || value.length() < 1) {
+      this.value = null;
+    } else {
+      this.value = value;
+    }
+  }
+
+  /**
+   * @param distribution The desired value distribution
+   * @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, String valueType) {
+    this.valueType = JDBCSupportedType.valueOf(valueType.toUpperCase());
+
+    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;
+    }
+
+    // Parse seed with fallback of 0L
+    try {
+      this.seed = Long.parseLong(seed);
+    } catch (NumberFormatException e) {
+      this.seed = 0L;
+    }
+
+    assert this.seed >= 0L;
+
+    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
+   * @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.equals("null") || distribution.length() < 1) {
+      return null;
+    }
+
+    this.distribution = ValueGenerator.valueOf(distribution.toUpperCase());
+
+    switch (this.distribution) {
+      case UNIFORM:
+        this.distribution = ValueGenerator.UNIFORM;
+        return new Random(seed);
+      case NORMAL:
+        this.distribution = ValueGenerator.NORMAL;
+        return new Random(seed);
+      case ZIPFIAN:
+        this.distribution = ValueGenerator.ZIPFIAN;
+        return new ZipfianGenerator(new Random(seed), min, max);
+      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' | 'normal' | 'zipfian' | 'scrambled'");
+    }
+  }
+
+  public ValueGenerator getDistribution() {
+    return this.distribution;
+  }
+
+  public String getMin() {
+    return (this.min != null) ? this.min.toString() : this.minF.toString();
+  }
+
+  public String getMax() {
+    return (this.max != null) ? this.max.toString() : this.maxF.toString();
+  }
+
+  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.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 {
+      generatedValue =
+          Double.valueOf(this.min + Math.abs(binomialGenerator.nextGaussian()) * this.max)
+              .longValue();
+    } while (generatedValue > max || generatedValue < min);
+
+    return generatedValue;
+  }
+
+  public Long getNextLongUniform() {
+    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.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.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();
+  }
+
+  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(this.minF, this.maxF);
+  }
+
+  public Float getNextFloatBinomial() {
+    assert this.valueType.equals(JDBCSupportedType.REAL)
+        || this.valueType.equals(JDBCSupportedType.FLOAT);
+    Random floatGenerator = (Random) this.generatorObject;
+    Float generatedFloat;
+    do {
+      generatedFloat = (float) (this.minF + Math.abs(floatGenerator.nextGaussian()) * this.maxF);
+    } while (generatedFloat > this.maxF || generatedFloat < this.minF);
+
+    return generatedFloat;
+  }
+
+  public RuntimeException createRuntimeException() {
+    return new RuntimeException(
+        "Distribution: " + this.distribution + " not supported for type: " + getValueType());
+  }
+}
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..c49b663b7
--- /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,
+  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..fb777dbc2
--- /dev/null
+++ b/src/main/java/com/oltpbenchmark/util/JDBCSupportedType.java
@@ -0,0 +1,22 @@
+package com.oltpbenchmark.util;
+
+public enum JDBCSupportedType {
+  BIGINT,
+  BIT,
+  BLOB,
+  CHAR,
+  CLOB,
+  DATE,
+  DECIMAL,
+  DOUBLE,
+  FLOAT,
+  INTEGER,
+  NUMERIC,
+  NULL,
+  REAL,
+  SMALLINT,
+  TIME,
+  TIMESTAMP,
+  TINYINT,
+  VARCHAR
+}
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>
+