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

[jOOQ/jOOQ#11254] More (unrelated) lambda-ification of internals

Browse Source
This commit is contained in:
Lukas Eder 2021-01-19 23:05:04 +01:00
parent 7606c434d4
commit e23f6b2a43
7 changed files with 31 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java
View File

@ -1132,17 +1132,7 @@ abstract class AbstractRecord extends AbstractStore implements Record {
@Override
public String toString() {
// [#3900] Nested records should generate different toString() behaviour
return ThreadGuard.run(RECORD_TOSTRING, new GuardedOperation<String>() {
@Override
public String unguarded() {
return asResult().toString();
}
@Override
public String guarded() {
return valuesRow().toString();
}
});
return ThreadGuard.run(RECORD_TOSTRING, () -> asResult().toString(), () -> valuesRow().toString());
}
@Override

9
jOOQ/src/main/java/org/jooq/impl/AbstractRoutine.java
View File

@ -340,14 +340,7 @@ public abstract class AbstractRoutine<T> extends AbstractNamed implements Routin
public final int execute(Configuration c) {
// Ensure that all depending Attachables are attached
Configuration previous = configuration();
try {
attach(c);
return execute();
}
finally {
attach(previous);
}
return Tools.attach(this, c, this::execute);
}
@Override

83
jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java
View File

@ -557,9 +557,8 @@ public class DefaultDSLContext extends AbstractScope implements DSLContext, Seri
@Override
public void attach(Collection<? extends Attachable> attachables) {
for (Attachable attachable : attachables) {
for (Attachable attachable : attachables)
attachable.attach(configuration());
}
}
// -------------------------------------------------------------------------
@ -4279,28 +4278,12 @@ public class DefaultDSLContext extends AbstractScope implements DSLContext, Seri
@Override
public <R extends Record> Result<R> fetch(ResultQuery<R> query) {
final Configuration previous = Tools.getConfiguration(query);
try {
query.attach(configuration());
return query.fetch();
}
finally {
query.attach(previous);
}
return Tools.attach(query, configuration(), query::fetch);
}
@Override
public <R extends Record> Cursor<R> fetchLazy(ResultQuery<R> query) {
final Configuration previous = Tools.getConfiguration(query);
try {
query.attach(configuration());
return query.fetchLazy();
}
finally {
query.attach(previous);
}
return Tools.attach(query, configuration(), query::fetchLazy);
}
@Override
@ -4318,54 +4301,22 @@ public class DefaultDSLContext extends AbstractScope implements DSLContext, Seri
@Override
public <R extends Record> Stream<R> fetchStream(ResultQuery<R> query) {
final Configuration previous = Tools.getConfiguration(query);
try {
query.attach(configuration());
return query.stream();
}
finally {
query.attach(previous);
}
return Tools.attach(query, configuration(), query::stream);
}
@Override
public <R extends Record> Results fetchMany(ResultQuery<R> query) {
final Configuration previous = Tools.getConfiguration(query);
try {
query.attach(configuration());
return query.fetchMany();
}
finally {
query.attach(previous);
}
return Tools.attach(query, configuration(), query::fetchMany);
}
@Override
public <R extends Record> R fetchOne(ResultQuery<R> query) {
final Configuration previous = Tools.getConfiguration(query);
try {
query.attach(configuration());
return query.fetchOne();
}
finally {
query.attach(previous);
}
return Tools.attach(query, configuration(), query::fetchOne);
}
@Override
public <R extends Record> R fetchSingle(ResultQuery<R> query) {
final Configuration previous = Tools.getConfiguration(query);
try {
query.attach(configuration());
return query.fetchSingle();
}
finally {
query.attach(previous);
}
return Tools.attach(query, configuration(), query::fetchSingle);
}
@Override
@ -4380,15 +4331,7 @@ public class DefaultDSLContext extends AbstractScope implements DSLContext, Seri
@Override
public <T, R extends Record1<T>> T fetchValue(ResultQuery<R> query) {
final Configuration previous = Tools.getConfiguration(query);
try {
query.attach(configuration());
return value1(fetchOne(query));
}
finally {
query.attach(previous);
}
return Tools.attach(query, configuration(), () -> value1(fetchOne(query)));
}
@Override
@ -4495,15 +4438,7 @@ public class DefaultDSLContext extends AbstractScope implements DSLContext, Seri
@Override
public int execute(Query query) {
final Configuration previous = Tools.getConfiguration(query);
try {
query.attach(configuration());
return query.execute();
}
finally {
query.attach(previous);
}
return Tools.attach(query, configuration(), query::execute);
}
// -------------------------------------------------------------------------

1
jOOQ/src/main/java/org/jooq/impl/DiagnosticsConnection.java
View File

@ -76,7 +76,6 @@ final class DiagnosticsConnection extends DefaultConnection {
final Parser parser;
final DiagnosticsListeners listeners;
@SuppressWarnings("deprecation")
DiagnosticsConnection(Configuration configuration) {
super(configuration.connectionProvider().acquire());

114
jOOQ/src/main/java/org/jooq/impl/FutureResultImpl.java
View File

@ -1,114 +0,0 @@
/*
* 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.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.jooq.FutureResult;
import org.jooq.Record;
import org.jooq.Result;
/**
* @author Lukas Eder
*/
@Deprecated
final class FutureResultImpl<R extends Record> implements FutureResult<R> {
private final Future<Result<R>> future;
private final ExecutorService executor;
FutureResultImpl(Future<Result<R>> future) {
this(future, null);
}
FutureResultImpl(Future<Result<R>> future, ExecutorService executor) {
this.future = future;
this.executor = executor;
}
@Override
public boolean cancel(boolean mayInterruptIfRunning) {
try {
return future.cancel(mayInterruptIfRunning);
}
finally {
if (executor != null) {
executor.shutdownNow();
}
}
}
@Override
public boolean isCancelled() {
return future.isCancelled();
}
@Override
public boolean isDone() {
return future.isDone();
}
@Override
public Result<R> get() throws InterruptedException, ExecutionException {
try {
return future.get();
}
finally {
if (executor != null) {
executor.shutdownNow();
}
}
}
@Override
public Result<R> get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
try {
return future.get(timeout, unit);
}
finally {
if (executor != null) {
executor.shutdownNow();
}
}
}
}

24
jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java
View File

@ -782,7 +782,7 @@ final class LoaderImpl<R extends Record> implements
});
}
private final void executeSQL(Iterator<? extends Object[]> iterator, DSLContext ctx) throws SQLException {
private final void executeSQL(Iterator<? extends Object[]> iterator, DSLContext ctx) {
Object[] row = null;
BatchBindStep bind = null;
InsertQuery<R> insert = null;
@ -974,26 +974,12 @@ final class LoaderImpl<R extends Record> implements
}
}
private final void commit() throws SQLException {
Connection connection = configuration.connectionProvider().acquire();
try {
connection.commit();
}
finally {
configuration.connectionProvider().release(connection);
}
private final void commit() {
configuration.dsl().connection(Connection::commit);
}
private final void rollback() throws SQLException {
Connection connection = configuration.connectionProvider().acquire();
try {
connection.rollback();
}
finally {
configuration.connectionProvider().release(connection);
}
private final void rollback() {
configuration.dsl().connection(Connection::rollback);
}
/**

18
jOOQ/src/main/java/org/jooq/impl/Tools.java
View File

@ -1150,6 +1150,18 @@ final class Tools {
return configuration(configuration).settings();
}
static final <T> T attach(Attachable attachable, Configuration configuration, Supplier<T> supplier) {
Configuration previous = attachable.configuration();
try {
attachable.attach(configuration);
return supplier.get();
}
finally {
attachable.attach(previous);
}
}
static final boolean attachRecords(Configuration configuration) {
if (configuration != null) {
Settings settings = configuration.settings();
@ -3216,16 +3228,16 @@ final class Tools {
/**
* Run an operation using a guard.
*/
static final <V> V run(Guard guard, GuardedOperation<V> operation) {
static final <V> V run(Guard guard, Supplier<V> unguardedOperation, Supplier<V> guardedOperation) {
boolean unguarded = (guard.tl.get() == null);
if (unguarded)
guard.tl.set(Guard.class);
try {
if (unguarded)
return operation.unguarded();
return unguardedOperation.get();
else
return operation.guarded();
return guardedOperation.get();
}
finally {
if (unguarded)