[#915] Add <T1, T2, ..., T[N]> Table<Record[N]<T1, T2, ..., T[N]>>
Factory.values(Row[N]<T1, T2, ..., T[N]>...), to create ad-hoc tables from data - Updated generated Factory code
This commit is contained in:
Lukas Eder
parent
7798e1d303
commit
ae7aad93d5
@ -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());
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
|
||||
@ -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");
|
||||
}
|
||||
}
|
||||
@ -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();
|
||||
|
||||
@ -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
|
||||
// -------------------------------------------------------------------------
|
||||
|
||||
Loading…
Reference in New Issue
Block a user