github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[jOOQ/jOOQ#11700] Support INSERT|UPDATE|DELETE .. RETURNING

Browse Source 
This includes:

- [jOOQ/jOOQ#11720] XResultStep<R> should not extend X<R> for X<R> =
Insert<R> | Update<R> | Delete<R>
- [jOOQ/jOOQ#11190] UPDATE .. RETURNING cannot be used reactively
- [jOOQ/jOOQ#3185] Remove Fetchable<R> again
This commit is contained in:
Lukas Eder 2021-03-30 11:03:47 +02:00
parent 33e87d9555
commit 8faaea0702
24 changed files with 5934 additions and 5811 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jOOQ/src/main/java/org/jooq/DeleteResultStep.java
View File

@ -76,6 +76,6 @@ package org.jooq;
*
* @author Lukas Eder
*/
public interface DeleteResultStep<R extends Record> extends Delete<R>, Fetchable<R> {
public interface DeleteResultStep<R extends Record> extends ResultQuery<R> {
}

4151
jOOQ/src/main/java/org/jooq/Fetchable.java
View File

File diff suppressed because it is too large Load Diff

2
jOOQ/src/main/java/org/jooq/InsertResultStep.java
View File

@ -87,6 +87,6 @@ package org.jooq;
*
* @author Lukas Eder
*/
public interface InsertResultStep<R extends Record> extends Insert<R>, Fetchable<R> {
public interface InsertResultStep<R extends Record> extends ResultQuery<R> {
}

4077
jOOQ/src/main/java/org/jooq/ResultQuery.java
View File

File diff suppressed because it is too large Load Diff

2
jOOQ/src/main/java/org/jooq/UpdateResultStep.java
View File

@ -79,6 +79,6 @@ package org.jooq;
*
* @author Lukas Eder
*/
public interface UpdateResultStep<R extends Record> extends Update<R>, Fetchable<R> {
public interface UpdateResultStep<R extends Record> extends ResultQuery<R> {
}

5
jOOQ/src/main/java/org/jooq/impl/AbstractDDLQuery.java
View File

@ -40,14 +40,9 @@ package org.jooq.impl;
import static org.jooq.impl.Keywords.K_CASCADE;
import static org.jooq.impl.Keywords.K_RESTRICT;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import org.jooq.Configuration;
import org.jooq.Context;
import org.jooq.DDLQuery;
import org.jooq.Field;
import org.jooq.Record;
/**
* @author Lukas Eder

6
jOOQ/src/main/java/org/jooq/impl/AbstractDMLQuery.java
View File

@ -1293,13 +1293,11 @@ abstract class AbstractDMLQuery<R extends Record> extends AbstractRowCountQuery
return null;
}
@Override
final Field<?>[] getFields(ResultSetMetaData rs) throws SQLException {
public final Field<?>[] getFields(ResultSetMetaData rs) throws SQLException {
return returningResolvedAsterisks.toArray(EMPTY_FIELD);
}
@Override
final Class<? extends Record> getRecordType() {
public final Class<? extends Record> getRecordType() {
return Tools.recordType(returningResolvedAsterisks.size());
}
}

19
jOOQ/src/main/java/org/jooq/impl/AbstractDelegatingRowCountQuery.java → jOOQ/src/main/java/org/jooq/impl/AbstractDelegatingDMLQuery.java
View File

@ -37,19 +37,15 @@
*/
package org.jooq.impl;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
// ...
import org.jooq.Fetchable;
import org.jooq.Field;
import org.jooq.Record;
import org.jooq.RowCountQuery;
/**
* @author Lukas Eder
*/
abstract class AbstractDelegatingRowCountQuery<R extends Record, Q extends AbstractRowCountQuery>
abstract class AbstractDelegatingDMLQuery<R extends Record, Q extends AbstractDMLQuery<R>>
extends AbstractDelegatingQuery<R, Q>
implements RowCountQuery {
@ -58,7 +54,7 @@ abstract class AbstractDelegatingRowCountQuery<R extends Record, Q extends Abstr
*/
private static final long serialVersionUID = 6710523592699040547L;
AbstractDelegatingRowCountQuery(Q delegate) {
AbstractDelegatingDMLQuery(Q delegate) {
super(delegate);
}
@ -75,15 +71,4 @@ abstract class AbstractDelegatingRowCountQuery<R extends Record, Q extends Abstr
public final void subscribe(org.reactivestreams.Subscriber<? super Integer> subscriber) {
getDelegate().subscribe(subscriber);
}
@Override
final Field<?>[] getFields(ResultSetMetaData rs) throws SQLException {
return getDelegate().getFields(rs);
}
@SuppressWarnings("unchecked")
@Override
final Class<? extends R> getRecordType() {
return (Class<? extends R>) getDelegate().getRecordType();
}
}

2
jOOQ/src/main/java/org/jooq/impl/AbstractDelegatingQuery.java
View File

@ -53,7 +53,7 @@ import org.jooq.conf.ParamType;
* @author Lukas Eder
*/
abstract class AbstractDelegatingQuery<R extends Record, Q extends Query>
extends AbstractFetchable<R>
extends AbstractQueryPart
implements Query {
/**

1237
jOOQ/src/main/java/org/jooq/impl/AbstractFetchable.java
View File

File diff suppressed because it is too large Load Diff

2
jOOQ/src/main/java/org/jooq/impl/AbstractQuery.java
View File

@ -90,7 +90,7 @@ import org.jooq.tools.JooqLogger;
/**
* @author Lukas Eder
*/
abstract class AbstractQuery<R extends Record> extends AbstractFetchable<R> implements Query {
abstract class AbstractQuery<R extends Record> extends AbstractQueryPart implements Query {
private static final long serialVersionUID = -8046199737354507547L;
private static final JooqLogger log = JooqLogger.getLogger(AbstractQuery.class);

174
jOOQ/src/main/java/org/jooq/impl/AbstractResultQuery.java
View File

@ -46,12 +46,10 @@ import static org.jooq.impl.Tools.consumeResultSets;
import static org.jooq.impl.Tools.executeStatementAndGetFirstResultSet;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collection;
import java.util.Set;
// ...
import org.jooq.Configuration;
import org.jooq.Cursor;
@ -89,23 +87,15 @@ import org.jooq.Results;
import org.jooq.SQLDialect;
import org.jooq.Table;
import org.jooq.conf.SettingsTools;
import org.jooq.impl.R2DBC.BlockingRecordSubscription;
import org.jooq.impl.R2DBC.ConnectionSubscriber;
import org.jooq.impl.R2DBC.QuerySubscription;
import org.jooq.impl.R2DBC.ResultSubscriber;
import org.jooq.tools.JooqLogger;
import org.jooq.tools.jdbc.MockResultSet;
import org.reactivestreams.Subscriber;
import io.r2dbc.spi.ConnectionFactory;
/**
* A query that returns a {@link Result}
*
* @author Lukas Eder
*/
abstract class AbstractResultQuery<R extends Record> extends AbstractQuery<R> implements ResultQuery<R> {
abstract class AbstractResultQuery<R extends Record> extends AbstractQuery<R> implements ResultQueryTrait<R> {
/**
* Generated UID
@ -321,25 +311,6 @@ abstract class AbstractResultQuery<R extends Record> extends AbstractQuery<R> im
return result;
}
@Override
public final void subscribe(Subscriber<? super R> subscriber) {
ConnectionFactory cf = configuration().connectionFactory();
if (!(cf instanceof NoConnectionFactory))
subscriber.onSubscribe(new QuerySubscription<>(this, subscriber, ResultSubscriber::new));
else
subscriber.onSubscribe(new BlockingRecordSubscription<>(this, subscriber));
}
@Override
public final Cursor<R> fetchLazy() {
@ -361,7 +332,7 @@ abstract class AbstractResultQuery<R extends Record> extends AbstractQuery<R> im
* jOOQ, then the cursor must not be auto-closed.
*/
@Override
final Cursor<R> fetchLazyNonAutoClosing() {
public final Cursor<R> fetchLazyNonAutoClosing() {
final boolean previousAutoClosing = autoclosing;
// [#3515] TODO: Avoid modifying a Query's per-execution state
@ -414,151 +385,10 @@ abstract class AbstractResultQuery<R extends Record> extends AbstractQuery<R> im
return (ResultQuery<X>) coerce(Arrays.asList(table.fields()));
}
@Override
public final ResultQuery<Record> coerce(Field<?>... fields) {
return coerce(Arrays.asList(fields));
}
@SuppressWarnings("unchecked")
@Override
public final ResultQuery<Record> coerce(Collection<? extends Field<?>> fields) {
this.coerceFields = fields;
return (ResultQuery<Record>) this;
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1> ResultQuery<Record1<T1>> coerce(Field<T1> field1) {
return (ResultQuery) coerce(new Field[] { field1 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2> ResultQuery<Record2<T1, T2>> coerce(Field<T1> field1, Field<T2> field2) {
return (ResultQuery) coerce(new Field[] { field1, field2 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3> ResultQuery<Record3<T1, T2, T3>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4> ResultQuery<Record4<T1, T2, T3, T4>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5> ResultQuery<Record5<T1, T2, T3, T4, T5>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6> ResultQuery<Record6<T1, T2, T3, T4, T5, T6>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7> ResultQuery<Record7<T1, T2, T3, T4, T5, T6, T7>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8> ResultQuery<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9> ResultQuery<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ResultQuery<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> ResultQuery<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> ResultQuery<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> ResultQuery<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> ResultQuery<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> ResultQuery<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> ResultQuery<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> ResultQuery<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> ResultQuery<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> ResultQuery<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> ResultQuery<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> ResultQuery<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 });
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> ResultQuery<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> coerce(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22) {
return (ResultQuery) coerce(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
}
}

15
jOOQ/src/main/java/org/jooq/impl/AbstractRowCountQuery.java
View File

@ -37,15 +37,10 @@
*/
package org.jooq.impl;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import org.jooq.Configuration;
import org.jooq.Field;
import org.jooq.Record;
import org.jooq.RowCountQuery;
import org.jooq.impl.R2DBC.BlockingRowCountSubscription;
import org.jooq.impl.R2DBC.ConnectionSubscriber;
import org.jooq.impl.R2DBC.QuerySubscription;
import org.jooq.impl.R2DBC.RowCountSubscriber;
@ -85,14 +80,4 @@ abstract class AbstractRowCountQuery extends AbstractQuery<Record> implements Ro
else
subscriber.onSubscribe(new BlockingRowCountSubscription(this, subscriber));
}
@Override
/* non-final */ Field<?>[] getFields(ResultSetMetaData rs) throws SQLException {
throw new UnsupportedOperationException();
}
@Override
/* non-final */ Class<? extends Record> getRecordType() {
throw new UnsupportedOperationException();
}
}

286
jOOQ/src/main/java/org/jooq/impl/DMLQueryAsResultQuery.java Normal file
View File

@ -0,0 +1,286 @@
/*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Other licenses:
* -----------------------------------------------------------------------------
* Commercial licenses for this work are available. These replace the above
* ASL 2.0 and offer limited warranties, support, maintenance, and commercial
* database integrations.
*
* For more information, please visit: http://www.jooq.org/licenses
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package org.jooq.impl;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import org.jooq.Configuration;
import org.jooq.Context;
import org.jooq.Delete;
import org.jooq.DeleteResultStep;
import org.jooq.Field;
import org.jooq.Insert;
import org.jooq.InsertResultStep;
import org.jooq.Name;
import org.jooq.Param;
import org.jooq.Record;
import org.jooq.Result;
import org.jooq.ResultQuery;
import org.jooq.Table;
import org.jooq.Update;
import org.jooq.UpdateResultStep;
import org.jooq.conf.ParamType;
import org.jooq.exception.DataAccessException;
import org.jooq.exception.DataTypeException;
/**
* A wrapped DML query ({@link Insert}, {@link Update}, {@link Delete}) that
* works like a {@link ResultQuery}.
*
* @author Lukas Eder
*/
final class DMLQueryAsResultQuery<R extends Record, Q extends AbstractDMLQuery<R>>
extends AbstractQueryPart
implements
ResultQueryTrait<R>,
DeleteResultStep<R>,
UpdateResultStep<R>,
InsertResultStep<R> {
/**
* Generated UID
*/
private static final long serialVersionUID = 1544514683289794225L;
private final Q delegate;
private final boolean returningResult;
private Table<?> coerceTable;
private Collection<? extends Field<?>> coerceFields;
DMLQueryAsResultQuery(Q delegate, boolean returningResult) {
this.delegate = delegate;
this.returningResult = returningResult;
}
// TODO: Refactor this coercion, share logic with AbstractResultQuery
@Override
public final Field<?>[] getFields(ResultSetMetaData rs) throws SQLException {
if (coerceFields != null && !coerceFields.isEmpty())
return coerceFields.toArray(Tools.EMPTY_FIELD);
else
return delegate.getFields(rs);
}
@Override
public final <X extends Record> ResultQuery<X> coerce(Table<X> table) {
this.coerceTable = table;
return (ResultQuery<X>) coerce(Arrays.asList(table.fields()));
}
@Override
public final ResultQuery<Record> coerce(Collection<? extends Field<?>> fields) {
this.coerceFields = fields;
return (ResultQuery<Record>) this;
}
@Override
public final Class<? extends R> getRecordType() {
if (coerceTable != null)
return (Class<? extends R>) coerceTable.getRecordType();
return (Class<? extends R>) delegate.getRecordType();
}
@Override
public final Result<R> fetch() {
delegate.execute();
return (Result<R>) (returningResult ? delegate.getResult() : delegate.getReturnedRecords());
}
@Override
public final int execute() throws DataAccessException {
return delegate.execute();
}
@Override
public final CompletionStage<Integer> executeAsync() {
return delegate.executeAsync();
}
@Override
public final CompletionStage<Integer> executeAsync(Executor executor) {
return delegate.executeAsync(executor);
}
@Override
public final boolean isExecutable() {
return delegate.isExecutable();
}
@Override
public final String getSQL() {
return delegate.getSQL();
}
@Override
public final String getSQL(ParamType paramType) {
return delegate.getSQL(paramType);
}
@Override
public final List<Object> getBindValues() {
return delegate.getBindValues();
}
@Override
public final Map<String, Param<?>> getParams() {
return delegate.getParams();
}
@Override
public final Param<?> getParam(String name) {
return delegate.getParam(name);
}
@Override
public final void close() throws DataAccessException {
delegate.close();
}
@Override
public final void cancel() throws DataAccessException {
delegate.cancel();
}
@Override
public final void attach(Configuration configuration) {
delegate.attach(configuration);
}
@Override
public final void detach() {
delegate.detach();
}
@Override
public final void accept(Context<?> ctx) {
delegate.accept(ctx);
}
@Override
public final Configuration configuration() {
return delegate.configuration();
}
@Override
public final Result<R> getResult() {
return null;
}
@Override
public final ResultQuery<R> bind(String param, Object value) throws IllegalArgumentException, DataTypeException {
delegate.bind(param, value);
return this;
}
@Override
public final ResultQuery<R> bind(int index, Object value) throws IllegalArgumentException, DataTypeException {
delegate.bind(index, value);
return this;
}
@Override
public final ResultQuery<R> poolable(boolean poolable) {
delegate.poolable(poolable);
return this;
}
@Override
public final ResultQuery<R> queryTimeout(int timeout) {
delegate.queryTimeout(timeout);
return this;
}
@Override
public final ResultQuery<R> keepStatement(boolean keepStatement) {
delegate.keepStatement(keepStatement);
return this;
}
@Override
public final ResultQuery<R> maxRows(int rows) {
return this;
}
@Override
public final ResultQuery<R> fetchSize(int rows) {
return this;
}
@Override
public final ResultQuery<R> resultSetConcurrency(int resultSetConcurrency) {
return this;
}
@Override
public final ResultQuery<R> resultSetType(int resultSetType) {
return this;
}
@Override
public final ResultQuery<R> resultSetHoldability(int resultSetHoldability) {
return this;
}
@Override
public final ResultQuery<R> intern(Field<?>... fields) {
return this;
}
@Override
public final ResultQuery<R> intern(int... fieldIndexes) {
return this;
}
@Override
public final ResultQuery<R> intern(String... fieldNames) {
return this;
}
@Override
public final ResultQuery<R> intern(Name... fieldNames) {
return this;
}
}

78
jOOQ/src/main/java/org/jooq/impl/DeleteImpl.java
View File

@ -41,10 +41,8 @@ import static org.jooq.impl.DSL.condition;
import static org.jooq.impl.DSL.exists;
import static org.jooq.impl.DSL.notExists;
import static org.jooq.impl.DSL.table;
import static org.jooq.impl.Tools.filterOne;
import java.util.Collection;
import java.util.Optional;
import org.jooq.Condition;
import org.jooq.Configuration;
@ -80,7 +78,6 @@ import org.jooq.Record6;
import org.jooq.Record7;
import org.jooq.Record8;
import org.jooq.Record9;
import org.jooq.Result;
import org.jooq.SQL;
import org.jooq.Select;
import org.jooq.SelectField;
@ -93,13 +90,12 @@ import org.jooq.TableLike;
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
final class DeleteImpl<R extends Record>
extends AbstractDelegatingRowCountQuery<R, DeleteQueryImpl<R>>
extends AbstractDelegatingDMLQuery<R, DeleteQueryImpl<R>>
implements
// Cascading interface implementations for Delete behaviour
DeleteUsingStep<R>,
DeleteConditionStep<R>,
DeleteResultStep<R> {
DeleteConditionStep<R> {
/**
* Generated UID
@ -339,154 +335,148 @@ final class DeleteImpl<R extends Record>
}
@Override
public final DeleteImpl<R> returning() {
public final DeleteResultStep<R> returning() {
getDelegate().setReturning();
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final DeleteImpl<R> returning(SelectFieldOrAsterisk... f) {
public final DeleteResultStep<R> returning(SelectFieldOrAsterisk... f) {
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final DeleteImpl<R> returning(Collection<? extends SelectFieldOrAsterisk> f) {
public final DeleteResultStep<R> returning(Collection<? extends SelectFieldOrAsterisk> f) {
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final DeleteImpl returningResult(SelectFieldOrAsterisk... f) {
public final DeleteResultStep<Record> returningResult(SelectFieldOrAsterisk... f) {
returningResult = true;
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery(getDelegate(), returningResult);
}
@Override
public final DeleteImpl returningResult(Collection<? extends SelectFieldOrAsterisk> f) {
public final DeleteResultStep<Record> returningResult(Collection<? extends SelectFieldOrAsterisk> f) {
returningResult = true;
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery(getDelegate(), returningResult);
}
@Override
public final <T1> DeleteResultStep<Record1<T1>> returningResult(SelectField<T1> field1) {
return returningResult(new SelectField[] { field1 });
return (DeleteResultStep) returningResult(new SelectField[] { field1 });
}
@Override
public final <T1, T2> DeleteResultStep<Record2<T1, T2>> returningResult(SelectField<T1> field1, SelectField<T2> field2) {
return returningResult(new SelectField[] { field1, field2 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2 });
}
@Override
public final <T1, T2, T3> DeleteResultStep<Record3<T1, T2, T3>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3) {
return returningResult(new SelectField[] { field1, field2, field3 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3 });
}
@Override
public final <T1, T2, T3, T4> DeleteResultStep<Record4<T1, T2, T3, T4>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4) {
return returningResult(new SelectField[] { field1, field2, field3, field4 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4 });
}
@Override
public final <T1, T2, T3, T4, T5> DeleteResultStep<Record5<T1, T2, T3, T4, T5>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5 });
}
@Override
public final <T1, T2, T3, T4, T5, T6> DeleteResultStep<Record6<T1, T2, T3, T4, T5, T6>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7> DeleteResultStep<Record7<T1, T2, T3, T4, T5, T6, T7>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8> DeleteResultStep<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9> DeleteResultStep<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> DeleteResultStep<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> DeleteResultStep<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> DeleteResultStep<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> DeleteResultStep<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> DeleteResultStep<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> DeleteResultStep<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> DeleteResultStep<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> DeleteResultStep<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> DeleteResultStep<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> DeleteResultStep<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> DeleteResultStep<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> DeleteResultStep<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> DeleteResultStep<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21, SelectField<T22> field22) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
return (DeleteResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
}
@Override
public final Result<R> fetch() {
getDelegate().execute();
return returningResult ? (Result<R>) getDelegate().getResult() : getDelegate().getReturnedRecords();
}
}

4
jOOQ/src/main/java/org/jooq/impl/FetchCount.java
View File

@ -75,12 +75,12 @@ final class FetchCount extends AbstractResultQuery<Record1<Integer>> {
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
final Class<? extends Record1<Integer>> getRecordType0() {
public final Class<? extends Record1<Integer>> getRecordType0() {
return (Class) RecordImpl1.class;
}
@Override
protected final Field<?>[] getFields(ResultSetMetaData rs) {
public final Field<?>[] getFields(ResultSetMetaData rs) {
return count;
}
}

124
jOOQ/src/main/java/org/jooq/impl/InsertImpl.java
View File

@ -61,14 +61,6 @@ import org.jooq.InsertResultStep;
import org.jooq.InsertSetMoreStep;
import org.jooq.InsertSetStep;
import org.jooq.InsertValuesStep1;
import org.jooq.InsertValuesStep2;
import org.jooq.InsertValuesStep3;
import org.jooq.InsertValuesStep4;
import org.jooq.InsertValuesStep5;
import org.jooq.InsertValuesStep6;
import org.jooq.InsertValuesStep7;
import org.jooq.InsertValuesStep8;
import org.jooq.InsertValuesStep9;
import org.jooq.InsertValuesStep10;
import org.jooq.InsertValuesStep11;
import org.jooq.InsertValuesStep12;
@ -79,23 +71,23 @@ import org.jooq.InsertValuesStep16;
import org.jooq.InsertValuesStep17;
import org.jooq.InsertValuesStep18;
import org.jooq.InsertValuesStep19;
import org.jooq.InsertValuesStep2;
import org.jooq.InsertValuesStep20;
import org.jooq.InsertValuesStep21;
import org.jooq.InsertValuesStep22;
import org.jooq.InsertValuesStep3;
import org.jooq.InsertValuesStep4;
import org.jooq.InsertValuesStep5;
import org.jooq.InsertValuesStep6;
import org.jooq.InsertValuesStep7;
import org.jooq.InsertValuesStep8;
import org.jooq.InsertValuesStep9;
import org.jooq.InsertValuesStepN;
import org.jooq.Name;
import org.jooq.Operator;
import org.jooq.QueryPart;
import org.jooq.Record;
import org.jooq.Record1;
import org.jooq.Record2;
import org.jooq.Record3;
import org.jooq.Record4;
import org.jooq.Record5;
import org.jooq.Record6;
import org.jooq.Record7;
import org.jooq.Record8;
import org.jooq.Record9;
import org.jooq.Record10;
import org.jooq.Record11;
import org.jooq.Record12;
@ -106,20 +98,19 @@ import org.jooq.Record16;
import org.jooq.Record17;
import org.jooq.Record18;
import org.jooq.Record19;
import org.jooq.Record2;
import org.jooq.Record20;
import org.jooq.Record21;
import org.jooq.Record22;
import org.jooq.Result;
import org.jooq.Record3;
import org.jooq.Record4;
import org.jooq.Record5;
import org.jooq.Record6;
import org.jooq.Record7;
import org.jooq.Record8;
import org.jooq.Record9;
import org.jooq.Row;
import org.jooq.Row1;
import org.jooq.Row2;
import org.jooq.Row3;
import org.jooq.Row4;
import org.jooq.Row5;
import org.jooq.Row6;
import org.jooq.Row7;
import org.jooq.Row8;
import org.jooq.Row9;
import org.jooq.Row10;
import org.jooq.Row11;
import org.jooq.Row12;
@ -130,9 +121,17 @@ import org.jooq.Row16;
import org.jooq.Row17;
import org.jooq.Row18;
import org.jooq.Row19;
import org.jooq.Row2;
import org.jooq.Row20;
import org.jooq.Row21;
import org.jooq.Row22;
import org.jooq.Row3;
import org.jooq.Row4;
import org.jooq.Row5;
import org.jooq.Row6;
import org.jooq.Row7;
import org.jooq.Row8;
import org.jooq.Row9;
import org.jooq.SQL;
import org.jooq.Select;
import org.jooq.SelectField;
@ -145,7 +144,7 @@ import org.jooq.UniqueKey;
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
final class InsertImpl<R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
extends AbstractDelegatingRowCountQuery<R, InsertQueryImpl<R>>
extends AbstractDelegatingDMLQuery<R, InsertQueryImpl<R>>
implements
// Cascading interface implementations for Insert behaviour
@ -176,8 +175,7 @@ final class InsertImpl<R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
InsertSetMoreStep<R>,
InsertOnDuplicateSetMoreStep<R>,
InsertOnConflictWhereIndexPredicateStep<R>,
InsertOnConflictConditionStep<R>,
InsertResultStep<R> {
InsertOnConflictConditionStep<R> {
/**
* Generated UID
@ -1393,172 +1391,166 @@ final class InsertImpl<R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
}
@Override
public final InsertImpl returning() {
public final InsertResultStep<R> returning() {
getDelegate().setReturning();
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final InsertImpl returning(SelectFieldOrAsterisk... f) {
public final InsertResultStep<R> returning(SelectFieldOrAsterisk... f) {
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final InsertImpl returning(Collection<? extends SelectFieldOrAsterisk> f) {
public final InsertResultStep<R> returning(Collection<? extends SelectFieldOrAsterisk> f) {
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final InsertImpl returningResult(SelectFieldOrAsterisk... f) {
public final InsertResultStep<Record> returningResult(SelectFieldOrAsterisk... f) {
returningResult = true;
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery(getDelegate(), returningResult);
}
@Override
public final InsertImpl returningResult(Collection<? extends SelectFieldOrAsterisk> f) {
public final InsertResultStep<Record> returningResult(Collection<? extends SelectFieldOrAsterisk> f) {
returningResult = true;
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery(getDelegate(), returningResult);
}
@Override
@SuppressWarnings("hiding")
public final <T1> InsertResultStep<Record1<T1>> returningResult(SelectField<T1> field1) {
return returningResult(new SelectField[] { field1 });
return (InsertResultStep) returningResult(new SelectField[] { field1 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2> InsertResultStep<Record2<T1, T2>> returningResult(SelectField<T1> field1, SelectField<T2> field2) {
return returningResult(new SelectField[] { field1, field2 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3> InsertResultStep<Record3<T1, T2, T3>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3) {
return returningResult(new SelectField[] { field1, field2, field3 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4> InsertResultStep<Record4<T1, T2, T3, T4>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4) {
return returningResult(new SelectField[] { field1, field2, field3, field4 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5> InsertResultStep<Record5<T1, T2, T3, T4, T5>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6> InsertResultStep<Record6<T1, T2, T3, T4, T5, T6>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7> InsertResultStep<Record7<T1, T2, T3, T4, T5, T6, T7>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8> InsertResultStep<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9> InsertResultStep<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> InsertResultStep<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> InsertResultStep<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> InsertResultStep<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> InsertResultStep<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> InsertResultStep<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> InsertResultStep<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> InsertResultStep<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> InsertResultStep<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> InsertResultStep<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> InsertResultStep<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> InsertResultStep<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> InsertResultStep<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 });
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 });
}
@Override
@SuppressWarnings("hiding")
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> InsertResultStep<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21, SelectField<T22> field22) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
}
@Override
public final Result<R> fetch() {
getDelegate().execute();
return returningResult ? (Result<R>) getDelegate().getResult() : getDelegate().getReturnedRecords();
return (InsertResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
}
}

31
jOOQ/src/main/java/org/jooq/impl/ParserImpl.java
View File

@ -171,7 +171,6 @@ import org.jooq.DSLContext;
import org.jooq.DataType;
import org.jooq.DatePart;
// ...
import org.jooq.Delete;
import org.jooq.DeleteLimitStep;
import org.jooq.DeleteOrderByStep;
import org.jooq.DeleteReturningStep;
@ -202,7 +201,6 @@ import org.jooq.GroupConcatSeparatorStep;
import org.jooq.GroupField;
// ...
import org.jooq.Index;
import org.jooq.Insert;
import org.jooq.InsertOnConflictDoUpdateStep;
import org.jooq.InsertOnConflictWhereIndexPredicateStep;
import org.jooq.InsertOnConflictWhereStep;
@ -280,7 +278,6 @@ import org.jooq.Truncate;
import org.jooq.TruncateCascadeStep;
import org.jooq.TruncateFinalStep;
import org.jooq.TruncateIdentityStep;
import org.jooq.Update;
import org.jooq.UpdateFromStep;
import org.jooq.UpdateLimitStep;
import org.jooq.UpdateOrderByStep;
@ -323,8 +320,6 @@ import org.jooq.types.Interval;
import org.jooq.types.YearToMonth;
import org.jooq.types.YearToSecond;
import org.jetbrains.annotations.NotNull;
/**
* @author Lukas Eder
*/
@ -1162,16 +1157,16 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
SelectQueryImpl<Record> rhs = degreeCheck(degree, parseQueryTerm(degree, null, null));
switch (combine) {
case UNION:
lhs = (SelectQueryImpl<Record>) lhs.union(rhs);
lhs = lhs.union(rhs);
break;
case UNION_ALL:
lhs = (SelectQueryImpl<Record>) lhs.unionAll(rhs);
lhs = lhs.unionAll(rhs);
break;
case EXCEPT:
lhs = (SelectQueryImpl<Record>) lhs.except(rhs);
lhs = lhs.except(rhs);
break;
case EXCEPT_ALL:
lhs = (SelectQueryImpl<Record>) lhs.exceptAll(rhs);
lhs = lhs.exceptAll(rhs);
break;
default:
throw internalError();
@ -1195,10 +1190,10 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
SelectQueryImpl<Record> rhs = degreeCheck(degree, parseQueryPrimary(degree, null));
switch (combine) {
case INTERSECT:
lhs = (SelectQueryImpl<Record>) lhs.intersect(rhs);
lhs = lhs.intersect(rhs);
break;
case INTERSECT_ALL:
lhs = (SelectQueryImpl<Record>) lhs.intersectAll(rhs);
lhs = lhs.intersectAll(rhs);
break;
default:
throw internalError();
@ -1716,7 +1711,7 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
return null;
}
private final Delete<?> parseDelete(WithImpl with) {
private final Query parseDelete(WithImpl with) {
parseKeyword("DELETE", "DEL");
Param<Long> limit = null;
@ -1750,12 +1745,10 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
DeleteReturningStep<?> s5 = (limit != null || parseKeywordIf("LIMIT"))
? s4.limit(limit != null ? limit : requireParam(parseParenthesisedUnsignedIntegerOrBindVariable()))
: s4;
Delete<?> s6 = parseKeywordIf("RETURNING") ? s5.returning(parseSelectList()) : s5;
return s6;
return parseKeywordIf("RETURNING") ? s5.returning(parseSelectList()) : s5;
}
private final Insert<?> parseInsert(WithImpl with) {
private final Query parseInsert(WithImpl with) {
scopeStart();
parseKeyword("INSERT", "INS");
parseKeywordIf("INTO");
@ -1902,7 +1895,7 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
}
}
private final Update<?> parseUpdate(WithImpl with) {
private final Query parseUpdate(WithImpl with) {
parseKeyword("UPDATE", "UPD");
Param<Long> limit = null;
@ -1958,9 +1951,7 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
UpdateReturningStep<?> s6 = (limit != null || parseKeywordIf("LIMIT"))
? s5.limit(limit != null ? limit : requireParam(parseParenthesisedUnsignedIntegerOrBindVariable()))
: s5;
Update<?> s7 = parseKeywordIf("RETURNING") ? s6.returning(parseSelectList()) : s6;
return s7;
return parseKeywordIf("RETURNING") ? s6.returning(parseSelectList()) : s6;
}
private final Map<Field<?>, Object> parseSetClauseList() {

37
jOOQ/src/main/java/org/jooq/impl/R2DBC.java
View File

@ -68,6 +68,7 @@ import org.jooq.Cursor;
import org.jooq.DataType;
import org.jooq.Field;
// ...
import org.jooq.Query;
import org.jooq.Record;
import org.jooq.SQLDialect;
import org.jooq.conf.Settings;
@ -100,10 +101,10 @@ final class R2DBC {
static final class SendResultUpstream<T> implements Subscriber<T> {
final QuerySubscription<T, ?, ?> upstream;
final QuerySubscription<T, ?> upstream;
Subscription subscription;
SendResultUpstream(QuerySubscription<T, ?, ?> upstream) {
SendResultUpstream(QuerySubscription<T, ?> upstream) {
this.upstream = upstream;
}
@ -136,9 +137,9 @@ final class R2DBC {
static final class RowCountSubscriber implements Subscriber<Result> {
final AbstractQuery<?> query;
final QuerySubscription<? super Integer, ?, ?> upstream;
final QuerySubscription<? super Integer, ?> upstream;
RowCountSubscriber(AbstractQuery<?> query, QuerySubscription<? super Integer, ?, ?> upstream) {
RowCountSubscriber(AbstractQuery<?> query, QuerySubscription<? super Integer, ?> upstream) {
this.query = query;
this.upstream = upstream;
}
@ -162,12 +163,12 @@ final class R2DBC {
public final void onComplete() {}
}
static final class ResultSubscriber<R extends Record, Q extends AbstractFetchable<R>> implements Subscriber<Result> {
static final class ResultSubscriber<R extends Record, Q extends ResultQueryTrait<R>> implements Subscriber<Result> {
final Q query;
final QuerySubscription<? super R, R, Q> upstream;
final Q query;
final QuerySubscription<? super R, Q> upstream;
ResultSubscriber(Q query, QuerySubscription<? super R, R, Q> upstream) {
ResultSubscriber(Q query, QuerySubscription<? super R, Q> upstream) {
this.query = query;
this.upstream = upstream;
}
@ -229,16 +230,16 @@ final class R2DBC {
public final void onComplete() {}
}
static final class ConnectionSubscriber<T, R extends Record, Q extends AbstractFetchable<R>> implements Subscriber<Connection> {
static final class ConnectionSubscriber<T, Q extends Query> implements Subscriber<Connection> {
final Q query;
final QuerySubscription<T, R, Q> upstream;
final BiFunction<Q, QuerySubscription<T, R, Q>, Subscriber<Result>> resultSubscriber;
final QuerySubscription<T, Q> upstream;
final BiFunction<Q, QuerySubscription<T, Q>, Subscriber<Result>> resultSubscriber;
ConnectionSubscriber(
Q query,
QuerySubscription<T, R, Q> upstream,
BiFunction<Q, QuerySubscription<T, R, Q>, Subscriber<Result>> resultSubscriber
QuerySubscription<T, Q> upstream,
BiFunction<Q, QuerySubscription<T, Q>, Subscriber<Result>> resultSubscriber
) {
this.query = query;
this.upstream = upstream;
@ -290,16 +291,16 @@ final class R2DBC {
public final void onComplete() {}
}
static final class QuerySubscription<T, R extends Record, Q extends AbstractFetchable<R>> implements Subscription {
static final class QuerySubscription<T, Q extends Query> implements Subscription {
final Subscriber<? super T> subscriber;
final AtomicLong requested;
final Publisher<? extends Connection> connection;
final ConnectionSubscriber<T, R, Q> connectionSubscriber;
final ConnectionSubscriber<T, Q> connectionSubscriber;
QuerySubscription(
Q query,
Subscriber<? super T> subscriber,
BiFunction<Q, QuerySubscription<T, R, Q>, Subscriber<Result>> resultSubscriber
BiFunction<Q, QuerySubscription<T, Q>, Subscriber<Result>> resultSubscriber
) {
this.subscriber = subscriber;
this.requested = new AtomicLong();
@ -838,12 +839,12 @@ final class R2DBC {
// -------------------------------------------------------------------------
static final class BlockingRecordSubscription<R extends Record> implements Subscription {
private final AbstractFetchable<R> query;
private final ResultQueryTrait<R> query;
private final Subscriber<? super R> subscriber;
private Cursor<R> c;
private ArrayDeque<R> buffer;
BlockingRecordSubscription(AbstractFetchable<R> query, Subscriber<? super R> subscriber) {
BlockingRecordSubscription(ResultQueryTrait<R> query, Subscriber<? super R> subscriber) {
this.query = query;
this.subscriber = subscriber;
}

1399
jOOQ/src/main/java/org/jooq/impl/ResultQueryTrait.java Normal file
View File

File diff suppressed because it is too large Load Diff

4
jOOQ/src/main/java/org/jooq/impl/SQLResultQuery.java
View File

@ -87,12 +87,12 @@ final class SQLResultQuery extends AbstractResultQuery<Record> {
}
@Override
final Class<? extends Record> getRecordType0() {
public final Class<? extends Record> getRecordType0() {
return RecordImplN.class;
}
@Override
protected final Field<?>[] getFields(ResultSetMetaData meta) {
public final Field<?>[] getFields(ResultSetMetaData meta) {
Collection<? extends Field<?>> coerce = coerce();
if (coerce != null && !coerce.isEmpty())

8
jOOQ/src/main/java/org/jooq/impl/SelectImpl.java
View File

@ -112,7 +112,6 @@ import org.jooq.SelectForUpdateOfStep;
// ...
// ...
// ...
import org.jooq.SelectFromStep;
import org.jooq.SelectHavingConditionStep;
import org.jooq.SelectIntoStep;
import org.jooq.SelectJoinStep;
@ -155,8 +154,6 @@ import org.jooq.TableLike;
// ...
import org.jooq.WindowDefinition;
import org.jetbrains.annotations.NotNull;
/**
* A wrapper for a {@link SelectQuery}
*
@ -166,6 +163,7 @@ import org.jetbrains.annotations.NotNull;
final class SelectImpl<R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>
extends AbstractDelegatingQuery<R, SelectQueryImpl<R>>
implements
ResultQueryTrait<R>,
// Cascading interface implementations for Select behaviour
SelectSelectStep<R>,
@ -2842,7 +2840,7 @@ implements
}
@Override
final Cursor<R> fetchLazyNonAutoClosing() {
public final Cursor<R> fetchLazyNonAutoClosing() {
return getDelegate().fetchLazyNonAutoClosing();
}
@ -3616,7 +3614,7 @@ implements
}
@Override
final Field<?>[] getFields(ResultSetMetaData rs) throws SQLException {
public final Field<?>[] getFields(ResultSetMetaData rs) throws SQLException {
return getDelegate().getFields(rs);
}
}

2
jOOQ/src/main/java/org/jooq/impl/SelectQueryImpl.java
View File

@ -832,7 +832,7 @@ final class SelectQueryImpl<R extends Record> extends AbstractResultQuery<R> imp
}
@Override
final Field<?>[] getFields(ResultSetMetaData meta) {
public final Field<?>[] getFields(ResultSetMetaData meta) {
Collection<? extends Field<?>> fields = coerce();
// [#1808] TODO: Restrict this field list, in case a restricting fetch()

78
jOOQ/src/main/java/org/jooq/impl/UpdateImpl.java
View File

@ -41,11 +41,9 @@ import static org.jooq.impl.DSL.condition;
import static org.jooq.impl.DSL.exists;
import static org.jooq.impl.DSL.notExists;
import static org.jooq.impl.DSL.table;
import static org.jooq.impl.Tools.filterOne;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import org.jooq.Condition;
import org.jooq.Configuration;
@ -78,7 +76,6 @@ import org.jooq.Record6;
import org.jooq.Record7;
import org.jooq.Record8;
import org.jooq.Record9;
import org.jooq.Result;
import org.jooq.Row1;
import org.jooq.Row10;
import org.jooq.Row11;
@ -123,14 +120,13 @@ import org.jooq.UpdateWhereStep;
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
final class UpdateImpl<R extends Record>
extends AbstractDelegatingRowCountQuery<R, UpdateQueryImpl<R>>
extends AbstractDelegatingDMLQuery<R, UpdateQueryImpl<R>>
implements
// Cascading interface implementations for Update behaviour
UpdateSetFirstStep<R>,
UpdateSetMoreStep<R>,
UpdateConditionStep<R>,
UpdateResultStep<R> {
UpdateConditionStep<R> {
/**
* Generated UID
@ -686,154 +682,148 @@ final class UpdateImpl<R extends Record>
}
@Override
public final UpdateImpl<R> returning() {
public final UpdateResultStep<R> returning() {
getDelegate().setReturning();
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final UpdateImpl<R> returning(SelectFieldOrAsterisk... f) {
public final UpdateResultStep<R> returning(SelectFieldOrAsterisk... f) {
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final UpdateImpl<R> returning(Collection<? extends SelectFieldOrAsterisk> f) {
public final UpdateResultStep<R> returning(Collection<? extends SelectFieldOrAsterisk> f) {
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery<>(getDelegate(), returningResult);
}
@Override
public final UpdateImpl returningResult(SelectFieldOrAsterisk... f) {
public final UpdateResultStep<Record> returningResult(SelectFieldOrAsterisk... f) {
returningResult = true;
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery(getDelegate(), returningResult);
}
@Override
public final UpdateImpl returningResult(Collection<? extends SelectFieldOrAsterisk> f) {
public final UpdateResultStep<Record> returningResult(Collection<? extends SelectFieldOrAsterisk> f) {
returningResult = true;
getDelegate().setReturning(f);
return this;
return new DMLQueryAsResultQuery(getDelegate(), returningResult);
}
@Override
public final <T1> UpdateResultStep<Record1<T1>> returningResult(SelectField<T1> field1) {
return returningResult(new SelectField[] { field1 });
return (UpdateResultStep) returningResult(new SelectField[] { field1 });
}
@Override
public final <T1, T2> UpdateResultStep<Record2<T1, T2>> returningResult(SelectField<T1> field1, SelectField<T2> field2) {
return returningResult(new SelectField[] { field1, field2 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2 });
}
@Override
public final <T1, T2, T3> UpdateResultStep<Record3<T1, T2, T3>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3) {
return returningResult(new SelectField[] { field1, field2, field3 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3 });
}
@Override
public final <T1, T2, T3, T4> UpdateResultStep<Record4<T1, T2, T3, T4>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4) {
return returningResult(new SelectField[] { field1, field2, field3, field4 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4 });
}
@Override
public final <T1, T2, T3, T4, T5> UpdateResultStep<Record5<T1, T2, T3, T4, T5>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5 });
}
@Override
public final <T1, T2, T3, T4, T5, T6> UpdateResultStep<Record6<T1, T2, T3, T4, T5, T6>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7> UpdateResultStep<Record7<T1, T2, T3, T4, T5, T6, T7>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8> UpdateResultStep<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9> UpdateResultStep<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> UpdateResultStep<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> UpdateResultStep<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> UpdateResultStep<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> UpdateResultStep<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> UpdateResultStep<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> UpdateResultStep<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> UpdateResultStep<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> UpdateResultStep<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> UpdateResultStep<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> UpdateResultStep<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> UpdateResultStep<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> UpdateResultStep<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21 });
}
@Override
public final <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> UpdateResultStep<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> returningResult(SelectField<T1> field1, SelectField<T2> field2, SelectField<T3> field3, SelectField<T4> field4, SelectField<T5> field5, SelectField<T6> field6, SelectField<T7> field7, SelectField<T8> field8, SelectField<T9> field9, SelectField<T10> field10, SelectField<T11> field11, SelectField<T12> field12, SelectField<T13> field13, SelectField<T14> field14, SelectField<T15> field15, SelectField<T16> field16, SelectField<T17> field17, SelectField<T18> field18, SelectField<T19> field19, SelectField<T20> field20, SelectField<T21> field21, SelectField<T22> field22) {
return returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
return (UpdateResultStep) returningResult(new SelectField[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
}
@Override
public final Result<R> fetch() {
getDelegate().execute();
return returningResult ? (Result<R>) getDelegate().getResult() : getDelegate().getReturnedRecords();
}
}