Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.neo4j.fabric.executor.FabricExecutor Maven / Gradle / Ivy
/*
* Copyright (c) "Neo4j"
* Neo4j Sweden AB [https://neo4j.com]
*
* This file is part of Neo4j.
*
* Neo4j is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see notifications = ConcurrentHashMap.newKeySet();
private final StatementLifecycle lifecycle;
private final Prefetcher prefetcher;
private final AccessMode accessMode;
private final NotificationConfiguration notificationConfiguration;
FabricStatementExecution(
FabricPlan plan,
FabricPlanner.PlannerInstance plannerInstance,
UseEvaluation.Instance useEvaluator,
MapValue queryParams,
AccessMode accessMode,
FabricTransaction.FabricExecutionContext ctx,
StatementLifecycle lifecycle,
FabricConfig.DataStream dataStreamConfig,
NotificationConfiguration notificationConfiguration) {
this.plan = plan;
this.plannerInstance = plannerInstance;
this.useEvaluator = useEvaluator;
this.queryParams = queryParams;
this.ctx = ctx;
this.lifecycle = lifecycle;
this.prefetcher = new Prefetcher(dataStreamConfig);
this.accessMode = accessMode;
this.notificationConfiguration = notificationConfiguration;
}
StatementResult run() {
var filteredNotifications = plan.notifications()
.filter(notificationConfiguration::includes)
.toList();
notifications.addAll(asJava(filteredNotifications));
lifecycle.startExecution(false);
var query = plan.query();
// EXPLAIN for multi-graph queries returns only fabric plan,
// because it is very hard to produce anything better without actually executing the query
if (plan.executionType() == FabricPlan.EXPLAIN() && plan.inCompositeContext()) {
lifecycle.endSuccess();
return StatementResults.create(
asJava(query.outputColumns()),
Flux.empty(),
Mono.just(new MergedSummary(Mono.just(plan.query().description()), statistics, notifications)),
Mono.just(EffectiveQueryType.queryExecutionType(plan, accessMode)));
} else {
FragmentResult fragmentResult = run(query, null);
List columns;
Flux records;
if (query.producesResults()) {
columns = asJava(query.outputColumns());
records = fragmentResult.records();
} else {
columns = Collections.emptyList();
records =
fragmentResult.records().then(Mono.empty()).flux();
}
Mono summary =
Mono.just(new MergedSummary(fragmentResult.planDescription(), statistics, notifications));
return StatementResults.create(
columns,
records.doOnComplete(lifecycle::endSuccess)
.doOnCancel(lifecycle::endSuccess)
.doOnError(lifecycle::endFailure),
summary,
fragmentResult.executionType());
}
}
FragmentResult run(Fragment fragment, Record argument) {
if (fragment instanceof Fragment.Init) {
return runInit();
} else if (fragment instanceof Fragment.Apply apply) {
if (apply.inTransactionsParameters().isEmpty()) {
return runApply(apply, argument);
} else {
return runCallInTransactions(apply, argument);
}
} else if (fragment instanceof Fragment.Union) {
return runUnion((Fragment.Union) fragment, argument);
} else if (fragment instanceof Fragment.Exec) {
return runExec((Fragment.Exec) fragment, argument);
} else {
throw notImplemented("Invalid query fragment", fragment);
}
}
FragmentResult runInit() {
return new FragmentResult(Flux.just(Records.empty()), Mono.empty(), Mono.empty());
}
FragmentResult runApply(Fragment.Apply apply, Record argument) {
FragmentResult input = run(apply.input(), argument);
Function> runInner =
apply.inner().outputColumns().isEmpty()
? (Record record) -> runAndProduceOnlyRecord(apply.inner(), record) // Unit subquery
: (Record record) -> runAndProduceJoinedResult(apply.inner(), record); // Returning subquery
Flux resultRecords = input.records().flatMap(runInner, dataStreamConfig.getConcurrency(), 1);
// TODO: merge executionType here for subqueries
// For now, just return global value as seen by fabric
Mono executionType = Mono.just(EffectiveQueryType.queryExecutionType(plan, accessMode));
return new FragmentResult(resultRecords, Mono.empty(), executionType);
}
private Flux runAndProduceJoinedResult(Fragment fragment, Record record) {
return run(fragment, record).records().map(outputRecord -> Records.join(record, outputRecord));
}
private Mono runAndProduceOnlyRecord(Fragment fragment, Record record) {
return run(fragment, record).records().then(Mono.just(record));
}
FragmentResult runUnion(Fragment.Union union, Record argument) {
FragmentResult lhs = run(union.lhs(), argument);
FragmentResult rhs = run(union.rhs(), argument);
Flux merged = Flux.merge(lhs.records(), rhs.records());
Mono executionType = mergeExecutionType(lhs.executionType(), rhs.executionType());
if (union.distinct()) {
return new FragmentResult(merged.distinct(), Mono.empty(), executionType);
} else {
return new FragmentResult(merged, Mono.empty(), executionType);
}
}
FragmentResult runExec(Fragment.Exec fragment, Record argument) {
return new StandardQueryExecutor(
fragment,
plannerInstance,
fabricWorkerExecutor,
ctx,
useEvaluator,
plan,
queryParams,
accessMode,
notifications,
lifecycle,
prefetcher,
queryRoutingMonitor,
statistics,
tracer(),
FabricStatementExecution.this::run)
.run(argument);
}
FragmentResult runCallInTransactions(Fragment.Apply fragment, Record argument) {
var resultRecords = new CallInTransactionsExecutor(
fragment,
plannerInstance,
fabricWorkerExecutor,
ctx,
useEvaluator,
plan,
queryParams,
accessMode,
notifications,
lifecycle,
prefetcher,
queryRoutingMonitor,
statistics,
tracer(),
FabricStatementExecution.this::run)
.run(argument);
Mono executionType = Mono.just(EffectiveQueryType.queryExecutionType(plan, accessMode));
return new FragmentResult(resultRecords, Mono.empty(), executionType);
}
SingleQueryFragmentExecutor.Tracer tracer() {
return new SingleQueryFragmentExecutor.Tracer() {
@Override
public SingleQueryFragmentExecutor.RecordTracer remoteQueryStart(
Location.Remote location, String queryString) {
return fragmentResult -> fragmentResult;
}
@Override
public SingleQueryFragmentExecutor.RecordTracer localQueryStart(
Location.Local location, FullyParsedQuery query) {
return fragmentResult -> fragmentResult;
}
};
}
private Mono mergeExecutionType(
Mono lhs, Mono rhs) {
return Mono.zip(lhs, rhs)
.map(both -> QueryTypes.merge(both.getT1(), both.getT2()))
.switchIfEmpty(lhs)
.switchIfEmpty(rhs);
}
private RuntimeException notImplemented(String msg, Object object) {
return notImplemented(msg, object.toString());
}
private RuntimeException notImplemented(String msg, String info) {
return new InvalidSemanticsException(msg + ": " + info);
}
}
private class FabricLoggingStatementExecution extends FabricStatementExecution {
private final AtomicInteger step;
private final InternalLog log;
FabricLoggingStatementExecution(
FabricPlan plan,
FabricPlanner.PlannerInstance plannerInstance,
UseEvaluation.Instance useEvaluator,
MapValue params,
AccessMode accessMode,
FabricTransaction.FabricExecutionContext ctx,
InternalLog log,
StatementLifecycle lifecycle,
FabricConfig.DataStream dataStreamConfig,
NotificationConfiguration notificationConfiguration) {
super(
plan,
plannerInstance,
useEvaluator,
params,
accessMode,
ctx,
lifecycle,
dataStreamConfig,
notificationConfiguration);
this.step = new AtomicInteger(0);
this.log = log;
}
SingleQueryFragmentExecutor.Tracer tracer() {
return new SingleQueryFragmentExecutor.Tracer() {
@Override
public SingleQueryFragmentExecutor.RecordTracer remoteQueryStart(
Location.Remote location, String queryString) {
String id = executionId();
trace(id, "remote " + nameString(location), compact(queryString));
return fragmentResult -> doTraceRecords(id, fragmentResult);
}
@Override
public SingleQueryFragmentExecutor.RecordTracer localQueryStart(
Location.Local location, FullyParsedQuery query) {
String id = executionId();
trace(id, "local " + nameString(location), compact(query.description()));
return fragmentResult -> doTraceRecords(id, fragmentResult);
}
};
}
private static String nameString(Location location) {
var namespace = location.databaseReference().namespace().map(NormalizedDatabaseName::name).stream();
var name = Stream.of(location.databaseReference().alias().name());
return Stream.concat(namespace, name).collect(Collectors.joining("."));
}
private String compact(String in) {
return in.replaceAll("\\r?\\n", " ").replaceAll("\\s+", " ");
}
private FragmentResult doTraceRecords(String id, FragmentResult fragmentResult) {
var records = fragmentResult
.records()
.doOnNext(record -> {
String rec = IntStream.range(0, record.size())
.mapToObj(i -> record.getValue(i).toString())
.collect(Collectors.joining(", ", "[", "]"));
trace(id, "output", rec);
})
.doOnError(err -> {
String rec = err.getClass().getSimpleName() + ": " + err.getMessage();
trace(id, "error", rec);
})
.doOnCancel(() -> trace(id, "cancel", "cancel"))
.doOnComplete(() -> trace(id, "complete", "complete"));
return new FragmentResult(records, fragmentResult.planDescription(), fragmentResult.executionType());
}
private void trace(String id, String event, String data) {
log.debug(String.format("%s: %s: %s", id, event, data));
}
private String executionId() {
String stmtId = idString(this.hashCode());
String step = idString(this.step.getAndIncrement());
return String.format("%s/%s", stmtId, step);
}
private String idString(int code) {
return String.format("%08X", code);
}
}
}
