diff --git a/jOOQ-test/src/org/jooq/test/_/testcases/ValuesConstructorTests.java b/jOOQ-test/src/org/jooq/test/_/testcases/ValuesConstructorTests.java
new file mode 100644
index 0000000000..154026d17e
--- /dev/null
+++ b/jOOQ-test/src/org/jooq/test/_/testcases/ValuesConstructorTests.java
@@ -0,0 +1,83 @@
+/**
+ * Copyright (c) 2009-2012, Lukas Eder, lukas.eder@gmail.com
+ * All rights reserved.
+ *
+ * This software is licensed to you under the Apache License, Version 2.0
+ * (the "License"); You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * . Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * . Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * . Neither the name "jOOQ" nor the names of its contributors may be
+ *   used to endorse or promote products derived from this software without
+ *   specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.jooq.test._.testcases;
+
+import java.sql.Date;
+
+import org.jooq.Record1;
+import org.jooq.Record2;
+import org.jooq.Record3;
+import org.jooq.Record6;
+import org.jooq.TableRecord;
+import org.jooq.UpdatableRecord;
+import org.jooq.test.BaseTest;
+import org.jooq.test.jOOQAbstractTest;
+
+import org.junit.Test;
+
+public class ValuesConstructorTests<
+    A    extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
+    AP,
+    B    extends UpdatableRecord<B>,
+    S    extends UpdatableRecord<S> & Record1<String>,
+    B2S  extends UpdatableRecord<B2S> & Record3<String, Integer, Integer>,
+    BS   extends UpdatableRecord<BS>,
+    L    extends TableRecord<L> & Record2<String, String>,
+    X    extends TableRecord<X>,
+    DATE extends UpdatableRecord<DATE>,
+    BOOL extends UpdatableRecord<BOOL>,
+    D    extends UpdatableRecord<D>,
+    T    extends UpdatableRecord<T>,
+    U    extends TableRecord<U>,
+    I    extends TableRecord<I>,
+    IPK  extends UpdatableRecord<IPK>,
+    T725 extends UpdatableRecord<T725>,
+    T639 extends UpdatableRecord<T639>,
+    T785 extends TableRecord<T785>>
+extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, I, IPK, T725, T639, T785> {
+
+    public ValuesConstructorTests(jOOQAbstractTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, I, IPK, T725, T639, T785> delegate) {
+        super(delegate);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void testValuesConstructor() throws Exception {
+//        Result<Record2<Integer, String>> r21 = create().selectFrom(values(row(1, "a"))).fetch();
+//
+//        assertEquals(1, r21.size());
+    }
+}
diff --git a/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java b/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java
index 3b073bcf2c..aed494fc70 100644
--- a/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java
+++ b/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java
@@ -127,6 +127,7 @@ import org.jooq.test._.testcases.SchemaAndMappingTests;
 import org.jooq.test._.testcases.SelectTests;
 import org.jooq.test._.testcases.StatementTests;
 import org.jooq.test._.testcases.ThreadSafetyTests;
+import org.jooq.test._.testcases.ValuesConstructorTests;
 import org.jooq.tools.JooqLogger;
 import org.jooq.tools.StopWatch;
 import org.jooq.tools.StringUtils;
@@ -1447,6 +1448,11 @@ public abstract class jOOQAbstractTest<
         new SelectTests(this).testComplexUnions();
     }
 
+    @Test
+    public void testValuesConstructor() throws Exception {
+        new ValuesConstructorTests(this).testValuesConstructor();
+    }
+
     @Test
     public void testOrderByInSubquery() throws Exception {
         new OrderByTests(this).testOrderByInSubquery();
diff --git a/jOOQ-tools/src/org/jooq/xtend/Factory.xtend b/jOOQ-tools/src/org/jooq/xtend/Factory.xtend
index 7dc10898cc..c56687c187 100644
--- a/jOOQ-tools/src/org/jooq/xtend/Factory.xtend
+++ b/jOOQ-tools/src/org/jooq/xtend/Factory.xtend
@@ -49,6 +49,7 @@ class Factory extends Generators {
         factory.generateSelectDistinct();
         factory.generateRowValue();
         factory.generateRowField();
+        factory.generateValues();
     }
     
     def generateSelect() {
@@ -208,4 +209,43 @@ class Factory extends Generators {
 
         insert("org.jooq.impl.Factory", out, "row-field");
     }
+    
+    def generateValues() {
+        val out = new StringBuilder();
+        
+        for (degree : (1..Constants::MAX_ROW_DEGREE)) {
+            out.append('''
+            
+                /**
+                 * Create a <code>VALUES()</code> expression of degree <code>«degree»</code>
+                 * <p>
+                 * The <code>VALUES()</code> constructor is a tool supported by some
+                 * databases to allow for constructing tables from constant values.
+                 * <p>
+                 * If a database doesn't support the <code>VALUES()</code> constructor, it
+                 * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+                 * expressions are equivalent:
+                 * <p>
+                 * <pre><code>
+                 * -- Using VALUES() constructor
+                 * VALUES(«field1_field2_fieldn(degree)»),
+                 *       («field1_field2_fieldn(degree)»),
+                 *       («field1_field2_fieldn(degree)»)
+                 *
+                 * -- Using UNION ALL
+                 * SELECT «field1_field2_fieldn(degree)» UNION ALL
+                 * SELECT «field1_field2_fieldn(degree)» UNION ALL
+                 * SELECT «field1_field2_fieldn(degree)»
+                 * </code></pre>
+                 */
+                «generatedMethod»
+                @Support
+                static <«TN(degree)»> Table<Record«degree»<«TN(degree)»>> values(Row«degree»<«TN(degree)»>... rows) {
+                    return new Values<Record«degree»<«TN(degree)»>>(rows);
+                }
+            ''');
+        }
+
+        insert("org.jooq.impl.Factory", out, "values");
+    }
 }
\ No newline at end of file
diff --git a/jOOQ-tools/src/org/jooq/xtend/Generators.xtend b/jOOQ-tools/src/org/jooq/xtend/Generators.xtend
index 89d59ebe1f..42a9381d40 100644
--- a/jOOQ-tools/src/org/jooq/xtend/Generators.xtend
+++ b/jOOQ-tools/src/org/jooq/xtend/Generators.xtend
@@ -79,15 +79,19 @@ abstract class Generators {
 		result.append("\n");
 		result.append(original.substring(original.indexOf(end)));
 		
-		write(className, result);
+		write(className, result, section);
 	}
 	
-    def write(String className, CharSequence contents) {
+	def write(String className, CharSequence contents) {
+		write(className, contents, null);
+	}
+	
+    def write(String className, CharSequence contents, String section) {
         val file = file(className);
         file.getParentFile().mkdirs();
     
         try {
-            System::out.println("Generating " + file);
+            System::out.println("Generating " + file + (if (section != null) (" (section: " + section + ")") else ""));
             val fw = new FileWriter(file);
             fw.append(contents);
             fw.flush();
diff --git a/jOOQ/src/main/java/org/jooq/impl/Factory.java b/jOOQ/src/main/java/org/jooq/impl/Factory.java
index 13ac318860..0d42a317a9 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Factory.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Factory.java
@@ -7510,42 +7510,625 @@ public class Factory {
     // [#915] TODO: These are experimental VALUES() table constructors
     // -------------------------------------------------------------------------
 
+// [jooq-tools] START [values]

+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>1</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1),
+     *       (field1),
+     *       (field1)
+     *
+     * -- Using UNION ALL
+     * SELECT field1 UNION ALL
+     * SELECT field1 UNION ALL
+     * SELECT field1
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
     static <T1> Table<Record1<T1>> values(Row1<T1>... rows) {
         return new Values<Record1<T1>>(rows);
     }
 
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>2</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2),
+     *       (field1, field2),
+     *       (field1, field2)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2 UNION ALL
+     * SELECT field1, field2 UNION ALL
+     * SELECT field1, field2
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
     static <T1, T2> Table<Record2<T1, T2>> values(Row2<T1, T2>... rows) {
         return new Values<Record2<T1, T2>>(rows);
     }
 
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>3</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3),
+     *       (field1, field2, field3),
+     *       (field1, field2, field3)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3 UNION ALL
+     * SELECT field1, field2, field3 UNION ALL
+     * SELECT field1, field2, field3
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
     static <T1, T2, T3> Table<Record3<T1, T2, T3>> values(Row3<T1, T2, T3>... rows) {
         return new Values<Record3<T1, T2, T3>>(rows);
     }
 
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>4</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, field4),
+     *       (field1, field2, field3, field4),
+     *       (field1, field2, field3, field4)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, field4 UNION ALL
+     * SELECT field1, field2, field3, field4 UNION ALL
+     * SELECT field1, field2, field3, field4
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
     static <T1, T2, T3, T4> Table<Record4<T1, T2, T3, T4>> values(Row4<T1, T2, T3, T4>... rows) {
         return new Values<Record4<T1, T2, T3, T4>>(rows);
     }
 
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>5</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, field4, field5),
+     *       (field1, field2, field3, field4, field5),
+     *       (field1, field2, field3, field4, field5)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, field4, field5 UNION ALL
+     * SELECT field1, field2, field3, field4, field5 UNION ALL
+     * SELECT field1, field2, field3, field4, field5
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
     static <T1, T2, T3, T4, T5> Table<Record5<T1, T2, T3, T4, T5>> values(Row5<T1, T2, T3, T4, T5>... rows) {
         return new Values<Record5<T1, T2, T3, T4, T5>>(rows);
     }
 
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>6</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field5, field6),
+     *       (field1, field2, field3, .., field5, field6),
+     *       (field1, field2, field3, .., field5, field6)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field5, field6 UNION ALL
+     * SELECT field1, field2, field3, .., field5, field6 UNION ALL
+     * SELECT field1, field2, field3, .., field5, field6
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
     static <T1, T2, T3, T4, T5, T6> Table<Record6<T1, T2, T3, T4, T5, T6>> values(Row6<T1, T2, T3, T4, T5, T6>... rows) {
         return new Values<Record6<T1, T2, T3, T4, T5, T6>>(rows);
     }
 
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>7</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field6, field7),
+     *       (field1, field2, field3, .., field6, field7),
+     *       (field1, field2, field3, .., field6, field7)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field6, field7 UNION ALL
+     * SELECT field1, field2, field3, .., field6, field7 UNION ALL
+     * SELECT field1, field2, field3, .., field6, field7
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
     static <T1, T2, T3, T4, T5, T6, T7> Table<Record7<T1, T2, T3, T4, T5, T6, T7>> values(Row7<T1, T2, T3, T4, T5, T6, T7>... rows) {
         return new Values<Record7<T1, T2, T3, T4, T5, T6, T7>>(rows);
     }
 
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>8</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field7, field8),
+     *       (field1, field2, field3, .., field7, field8),
+     *       (field1, field2, field3, .., field7, field8)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field7, field8 UNION ALL
+     * SELECT field1, field2, field3, .., field7, field8 UNION ALL
+     * SELECT field1, field2, field3, .., field7, field8
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
     static <T1, T2, T3, T4, T5, T6, T7, T8> Table<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> values(Row8<T1, T2, T3, T4, T5, T6, T7, T8>... rows) {
         return new Values<Record8<T1, T2, T3, T4, T5, T6, T7, T8>>(rows);
     }
 
-    static Table<Record> values(RowN... rows) {
-        return new Values<Record>(rows);
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>9</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field8, field9),
+     *       (field1, field2, field3, .., field8, field9),
+     *       (field1, field2, field3, .., field8, field9)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field8, field9 UNION ALL
+     * SELECT field1, field2, field3, .., field8, field9 UNION ALL
+     * SELECT field1, field2, field3, .., field8, field9
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9> Table<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> values(Row9<T1, T2, T3, T4, T5, T6, T7, T8, T9>... rows) {
+        return new Values<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>>(rows);
     }
 
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>10</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field9, field10),
+     *       (field1, field2, field3, .., field9, field10),
+     *       (field1, field2, field3, .., field9, field10)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field9, field10 UNION ALL
+     * SELECT field1, field2, field3, .., field9, field10 UNION ALL
+     * SELECT field1, field2, field3, .., field9, field10
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Table<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> values(Row10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>... rows) {
+        return new Values<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>11</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field10, field11),
+     *       (field1, field2, field3, .., field10, field11),
+     *       (field1, field2, field3, .., field10, field11)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field10, field11 UNION ALL
+     * SELECT field1, field2, field3, .., field10, field11 UNION ALL
+     * SELECT field1, field2, field3, .., field10, field11
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Table<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> values(Row11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>... rows) {
+        return new Values<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>12</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field11, field12),
+     *       (field1, field2, field3, .., field11, field12),
+     *       (field1, field2, field3, .., field11, field12)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field11, field12 UNION ALL
+     * SELECT field1, field2, field3, .., field11, field12 UNION ALL
+     * SELECT field1, field2, field3, .., field11, field12
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Table<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> values(Row12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>... rows) {
+        return new Values<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>13</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field12, field13),
+     *       (field1, field2, field3, .., field12, field13),
+     *       (field1, field2, field3, .., field12, field13)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field12, field13 UNION ALL
+     * SELECT field1, field2, field3, .., field12, field13 UNION ALL
+     * SELECT field1, field2, field3, .., field12, field13
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Table<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> values(Row13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>... rows) {
+        return new Values<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>14</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field13, field14),
+     *       (field1, field2, field3, .., field13, field14),
+     *       (field1, field2, field3, .., field13, field14)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field13, field14 UNION ALL
+     * SELECT field1, field2, field3, .., field13, field14 UNION ALL
+     * SELECT field1, field2, field3, .., field13, field14
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Table<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> values(Row14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>... rows) {
+        return new Values<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>15</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field14, field15),
+     *       (field1, field2, field3, .., field14, field15),
+     *       (field1, field2, field3, .., field14, field15)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field14, field15 UNION ALL
+     * SELECT field1, field2, field3, .., field14, field15 UNION ALL
+     * SELECT field1, field2, field3, .., field14, field15
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Table<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> values(Row15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>... rows) {
+        return new Values<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>16</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field15, field16),
+     *       (field1, field2, field3, .., field15, field16),
+     *       (field1, field2, field3, .., field15, field16)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field15, field16 UNION ALL
+     * SELECT field1, field2, field3, .., field15, field16 UNION ALL
+     * SELECT field1, field2, field3, .., field15, field16
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Table<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> values(Row16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>... rows) {
+        return new Values<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>17</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field16, field17),
+     *       (field1, field2, field3, .., field16, field17),
+     *       (field1, field2, field3, .., field16, field17)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field16, field17 UNION ALL
+     * SELECT field1, field2, field3, .., field16, field17 UNION ALL
+     * SELECT field1, field2, field3, .., field16, field17
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Table<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> values(Row17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>... rows) {
+        return new Values<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>18</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field17, field18),
+     *       (field1, field2, field3, .., field17, field18),
+     *       (field1, field2, field3, .., field17, field18)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field17, field18 UNION ALL
+     * SELECT field1, field2, field3, .., field17, field18 UNION ALL
+     * SELECT field1, field2, field3, .., field17, field18
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Table<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> values(Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>... rows) {
+        return new Values<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>19</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field18, field19),
+     *       (field1, field2, field3, .., field18, field19),
+     *       (field1, field2, field3, .., field18, field19)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field18, field19 UNION ALL
+     * SELECT field1, field2, field3, .., field18, field19 UNION ALL
+     * SELECT field1, field2, field3, .., field18, field19
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Table<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> values(Row19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>... rows) {
+        return new Values<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>20</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field19, field20),
+     *       (field1, field2, field3, .., field19, field20),
+     *       (field1, field2, field3, .., field19, field20)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field19, field20 UNION ALL
+     * SELECT field1, field2, field3, .., field19, field20 UNION ALL
+     * SELECT field1, field2, field3, .., field19, field20
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Table<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> values(Row20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>... rows) {
+        return new Values<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>21</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field20, field21),
+     *       (field1, field2, field3, .., field20, field21),
+     *       (field1, field2, field3, .., field20, field21)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field20, field21 UNION ALL
+     * SELECT field1, field2, field3, .., field20, field21 UNION ALL
+     * SELECT field1, field2, field3, .., field20, field21
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Table<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> values(Row21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>... rows) {
+        return new Values<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>>(rows);
+    }
+
+    /**
+     * Create a <code>VALUES()</code> expression of degree <code>22</code>
+     * <p>
+     * The <code>VALUES()</code> constructor is a tool supported by some
+     * databases to allow for constructing tables from constant values.
+     * <p>
+     * If a database doesn't support the <code>VALUES()</code> constructor, it
+     * can be simulated using <code>SELECT .. UNION ALL ..</code>. The following
+     * expressions are equivalent:
+     * <p>
+     * <pre><code>
+     * -- Using VALUES() constructor
+     * VALUES(field1, field2, field3, .., field21, field22),
+     *       (field1, field2, field3, .., field21, field22),
+     *       (field1, field2, field3, .., field21, field22)
+     *
+     * -- Using UNION ALL
+     * SELECT field1, field2, field3, .., field21, field22 UNION ALL
+     * SELECT field1, field2, field3, .., field21, field22 UNION ALL
+     * SELECT field1, field2, field3, .., field21, field22
+     * </code></pre>
+     */
+    @Generated("This method was generated using jOOQ-tools")
+    @Support
+    static <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Table<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> values(Row22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>... rows) {
+        return new Values<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>>(rows);
+    }
+
+// [jooq-tools] END [values]
+
     // -------------------------------------------------------------------------
     // XXX Literals
     // -------------------------------------------------------------------------