Skip to content

GQLGW-5297-optimise-incremental-part-execution-for-defer-requests #4174

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
andimarek merged 6 commits into from
Nov 30, 2025
Merged

GQLGW-5297-optimise-incremental-part-execution-for-defer-requests #4174

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
dd8313b
GQLGW-5297-optimise-incremental-part-execution-for-defer-requests
llin2 Nov 16, 2025
7e8d69a
GQLGW-666-do-not-start-on-separate-thread
llin2 Nov 17, 2025
a5c458e
GQLGW-666-move-start-to-after-initial-fields-resolve-with-info
llin2 Nov 17, 2025
50169f0
GQLGW-5297-assert-on-result-and-remove-redundant-call
llin2 Nov 18, 2025
0f365b5
GQLGW-5297-add-unusual-config
llin2 Nov 19, 2025
18207de
GQLGW-5297-remove-start-defer-calls
llin2 Nov 19, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Prev Previous commit
Next Next commit
GQLGW-666-do-not-start-on-separate-thread
  • Loading branch information
@llin2
llin2 committed Nov 17, 2025
commit 7e8d69ac2d47046f7c3539c21c43d83bd006cae5
32 changes: 0 additions & 32 deletions src/main/java/graphql/execution/Execution.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,6 @@
import graphql.extensions.ExtensionsBuilder;
import graphql.incremental.DelayedIncrementalPartialResult;
import graphql.incremental.IncrementalExecutionResultImpl;
import graphql.execution.incremental.IncrementalExecutionContextKeys;
import graphql.language.Directive;
import graphql.language.Document;
import graphql.language.NodeUtil;
Expand All @@ -49,7 +48,6 @@
import static graphql.execution.ExecutionContextBuilder.newExecutionContextBuilder;
import static graphql.execution.ExecutionStepInfo.newExecutionStepInfo;
import static graphql.execution.ExecutionStrategyParameters.newParameters;
import static graphql.execution.incremental.IncrementalExecutionContextKeys.EAGER_DEFER_PUBLISHER;
import static graphql.execution.instrumentation.SimpleInstrumentationContext.nonNullCtx;
import static graphql.execution.instrumentation.dataloader.EmptyDataLoaderRegistryInstance.EMPTY_DATALOADER_REGISTRY;
import static java.util.concurrent.CompletableFuture.completedFuture;
Expand Down Expand Up @@ -220,27 +218,6 @@ private CompletableFuture<ExecutionResult> executeOperation(ExecutionContext exe
DataLoaderDispatchStrategy dataLoaderDispatchStrategy = createDataLoaderDispatchStrategy(executionContext, executionStrategy);
executionContext.setDataLoaderDispatcherStrategy(dataLoaderDispatchStrategy);
result = executionStrategy.execute(executionContext, parameters);

if (executionContext.hasIncrementalSupport() &&
executionContext.getGraphQLContext().getBoolean(IncrementalExecutionContextKeys.ENABLE_EAGER_DEFER_START, false)) {
final CompletableFuture<ExecutionResult> mainResult = result;
CompletableFuture.runAsync(() -> {
IncrementalCallState incrementalCallState = executionContext.getIncrementalCallState();
CompletableFuture.anyOf(incrementalCallState.getIncrementalCallsDetectedFuture(), mainResult).join();

if (incrementalCallState.getIncrementalCallsDetected()) {
InstrumentationReactiveResultsParameters resultsParameters = new InstrumentationReactiveResultsParameters(executionContext, InstrumentationReactiveResultsParameters.ResultType.DEFER);
InstrumentationContext<Void> ctx = nonNullCtx(executionContext.getInstrumentation().beginReactiveResults(resultsParameters, executionContext.getInstrumentationState()));
Publisher<DelayedIncrementalPartialResult> publisher = incrementalCallState.startDeferredCalls();
ctx.onDispatched();

publisher = ReactiveSupport.whenPublisherFinishes(publisher, throwable -> ctx.onCompleted(null, throwable));
executionContext.getGraphQLContext().put(EAGER_DEFER_PUBLISHER, publisher);

incrementalCallState.startDrainingNow();
}
});
}
} catch (NonNullableFieldWasNullException e) {
// this means it was non-null types all the way from an offending non-null type
// up to the root object type and there was a null value somewhere.
Expand Down Expand Up @@ -268,15 +245,6 @@ private CompletableFuture<ExecutionResult> executeOperation(ExecutionContext exe
*/
private CompletableFuture<ExecutionResult> incrementalSupport(ExecutionContext executionContext, CompletableFuture<ExecutionResult> result) {
return result.thenApply(er -> {
// If we've aready started the deferred publisher early, attach it now without re-instrumenting.
Object maybePublisher = executionContext.getGraphQLContext().get(EAGER_DEFER_PUBLISHER);
if (maybePublisher instanceof Publisher) {
Publisher<DelayedIncrementalPartialResult> publisher = (Publisher<DelayedIncrementalPartialResult>) maybePublisher;
return IncrementalExecutionResultImpl.fromExecutionResult(er)
.hasNext(true)
.incrementalItemPublisher(publisher)
.build();
}
IncrementalCallState incrementalCallState = executionContext.getIncrementalCallState();
if (incrementalCallState.getIncrementalCallsDetected()) {
InstrumentationReactiveResultsParameters parameters = new InstrumentationReactiveResultsParameters(executionContext, InstrumentationReactiveResultsParameters.ResultType.DEFER);
Expand Down
9 changes: 9 additions & 0 deletions src/main/java/graphql/execution/ExecutionStrategy.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,7 @@
import graphql.execution.directives.QueryDirectives;
import graphql.execution.directives.QueryDirectivesImpl;
import graphql.execution.incremental.DeferredExecutionSupport;
import graphql.execution.incremental.IncrementalExecutionContextKeys;
import graphql.execution.instrumentation.ExecuteObjectInstrumentationContext;
import graphql.execution.instrumentation.FieldFetchingInstrumentationContext;
import graphql.execution.instrumentation.Instrumentation;
Expand Down Expand Up @@ -309,6 +310,14 @@ DeferredExecutionSupport createDeferredExecutionSupport(ExecutionContext executi

executionContext.getIncrementalCallState().enqueue(deferredExecutionSupport.createCalls());

if (executionContext.hasIncrementalSupport()
&& deferredExecutionSupport.deferredFieldsCount() > 0
&& executionContext.getGraphQLContext().getBoolean(IncrementalExecutionContextKeys.ENABLE_EAGER_DEFER_START, false)) {

executionContext.getIncrementalCallState().startDeferredCalls();
executionContext.getIncrementalCallState().startDrainingNow();
}

// Only non-deferred fields should be considered for calculating the expected size of futures.
Async.CombinedBuilder<FieldValueInfo> futures = Async
.ofExpectedSize(fields.size() - deferredExecutionSupport.deferredFieldsCount());
Expand Down
15 changes: 0 additions & 15 deletions src/main/java/graphql/execution/incremental/IncrementalCallState.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,8 +16,6 @@
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;

import java.util.concurrent.CompletableFuture;

import static graphql.incremental.DelayedIncrementalPartialResultImpl.newIncrementalExecutionResult;

/**
Expand All @@ -32,9 +30,6 @@ public class IncrementalCallState {
private final AtomicInteger pendingCalls = new AtomicInteger();
private final LockKit.ReentrantLock publisherLock = new LockKit.ReentrantLock();

// Completed when the very first incremental call is detected/enqueued
private final CompletableFuture<Void> incrementalCallsDetectedFuture = new CompletableFuture<>();

@SuppressWarnings("FutureReturnValueIgnored")
private void drainIncrementalCalls() {
IncrementalCall<? extends IncrementalPayload> incrementalCall = incrementalCalls.poll();
Expand Down Expand Up @@ -81,9 +76,6 @@ public void enqueue(IncrementalCall<? extends IncrementalPayload> incrementalCal
incrementalCallsDetected.set(true);
incrementalCalls.offer(incrementalCall);
pendingCalls.incrementAndGet();
if (!incrementalCallsDetectedFuture.isDone()) {
incrementalCallsDetectedFuture.complete(null);
}
});
}

Expand All @@ -95,13 +87,6 @@ public boolean getIncrementalCallsDetected() {
return incrementalCallsDetected.get();
}

/**
* @return a future that completes when the first incremental call is detected.
*/
public CompletableFuture<Void> getIncrementalCallsDetectedFuture() {
return incrementalCallsDetectedFuture;
}

private Supplier<SingleSubscriberPublisher<DelayedIncrementalPartialResult>> createPublisher() {
// this will be created once and once only - any extra calls to .get() will return the previously created
// singleton object
Expand Down
7 changes: 0 additions & 7 deletions src/main/java/graphql/execution/incremental/IncrementalExecutionContextKeys.java
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,7 +1,6 @@
package graphql.execution.incremental;


import graphql.GraphQLContext;
import graphql.Internal;
import org.jspecify.annotations.NullMarked;

Expand All @@ -22,12 +21,6 @@ private IncrementalExecutionContextKeys() {
*/
public static final String ENABLE_EAGER_DEFER_START = "__GJ_enable_eager_defer_start";


/**
* Stores the Publisher<DelayedIncrementalPartialResult> used for incremental delivery when eager defer is enabled.
* Value type: org.reactivestreams.Publisher
*/
public static final String EAGER_DEFER_PUBLISHER = "__GJ_eager_defer_publisher";
}


@bbakerman bbakerman Nov 19, 2025

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We need to create a new entry in the unusual config - lets put it in

graphql.GraphQLUnusualConfiguration.IncrementalSupportConfig

        /**
         * This controls whether @defer field execution starts as early as possible.
         */
        @ExperimentalApi
        public IncrementalSupportConfig enableEarlyFieldExecution(boolean enable) {
            contextConfig.put(YOUR_KEY_HERE, enable);
            return this;
        }