public static IQueryResult StateInvalidForOperationExecution() =>
QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage(
"Either now compiled operation was found or the variables " +
"have not been coerced.")
.Build());
// This method extracts the relevant data from a merged result for a specific result.
private static QueryResultBuilder ExtractResult(
IDictionary <string, string> aliases,
IQueryResult mergedResult,
ICollection <IError> handledErrors)
{
var result = QueryResultBuilder.New();
// We first try to identify and copy data segments that belong to our specific result.
ExtractData(aliases, mergedResult, result);
// After extracting the data, we will try to find errors that can be associated with
// our specific request for which we are trying to branch out the result.
ExtractErrors(aliases, mergedResult, handledErrors, result);
// Last but not least we will copy all extensions and contextData over
// to the specific responses.
if (mergedResult.Extensions is not null)
{
result.SetExtensions(mergedResult.Extensions);
}
if (mergedResult.ContextData is not null)
{
foreach (KeyValuePair <string, object?> item in mergedResult.ContextData)
{
result.SetContextData(item.Key, item.Value);
}
}
return(result);
}
public static IQueryResult StateInvalidForOperationVariableCoercion() =>
QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage(
"There is no operation on the context which can be used to coerce " +
"variables.")
.Build());
public async ValueTask InvokeAsync(IRequestContext context)
{
if (context.Document is null)
{
context.Result = StateInvalidForDocumentValidation();
}
else
{
if (context.ValidationResult is null)
{
using (_diagnosticEvents.ValidateDocument(context))
{
context.ValidationResult = _documentValidator.Validate(
context.Schema,
context.Document,
context.ContextData);
}
}
if (context.ValidationResult is { HasErrors : true } validationResult)
{
context.Result = QueryResultBuilder.CreateError(
validationResult.Errors,
new Dictionary <string, object?>
{
{ WellKnownContextData.ValidationErrors, true }
});
_diagnosticEvents.ValidationErrors(context, validationResult.Errors);
}
public async Task ExecutePersistedQuery_NotFound()
{
// arrange
var queryId = Guid.NewGuid().ToString("N");
var storage = new RedisQueryStorage(_database);
await storage.WriteQueryAsync(queryId, new QuerySourceText("{ __typename }"));
IRequestExecutor executor =
await new ServiceCollection()
.AddGraphQL()
.AddQueryType(c => c.Name("Query").Field("a").Resolve("b"))
.AddRedisQueryStorage(s => _database)
.UseRequest(n => async c =>
{
await n(c);
if (c.IsPersistedDocument && c.Result is IQueryResult r)
{
c.Result = QueryResultBuilder
.FromResult(r)
.SetExtension("persistedDocument", true)
.Create();
}
})
.UsePersistedQueryPipeline()
.BuildRequestExecutorAsync();
// act
IExecutionResult result =
await executor.ExecuteAsync(new QueryRequest(queryId : "does_not_exist"));
// assert
result.MatchSnapshot();
}
public static IQueryResult StateInvalidForOperationResolver() =>
QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage(
"Either no query document exists or the document " +
"validation result is invalid.")
.Build());
public async ValueTask InvokeAsync(IRequestContext context)
{
if (context.Document is null)
{
// TODO : ErrorHelper
context.Result = QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage("Cannot Validate")
.Build());
}
else
{
if (context.ValidationResult is null)
{
using (_diagnosticEvents.ValidateDocument(context))
{
context.ValidationResult =
_documentValidator.Validate(context.Schema, context.Document !);
}
}
if (context.ValidationResult is { HasErrors : true } validationResult)
{
context.Result = QueryResultBuilder.CreateError(validationResult.Errors);
_diagnosticEvents.ValidationErrors(context, validationResult.Errors);
}
private async Task <IReadOnlyQueryResult> FetchAsync(
IReadOnlyQueryRequest request,
HttpContent requestContent,
HttpClient httpClient,
IEnumerable <IHttpQueryRequestInterceptor>?interceptors,
CancellationToken cancellationToken)
{
HttpResponseMessage message =
await FetchInternalAsync(requestContent, httpClient).ConfigureAwait(false);
using (Stream stream = await message.Content.ReadAsStreamAsync().ConfigureAwait(false))
{
object response = await BufferHelper.ReadAsync(
stream,
(buffer, bytesBuffered) => ParseJson(buffer, bytesBuffered),
cancellationToken)
.ConfigureAwait(false);
IReadOnlyQueryResult queryResult =
response is IReadOnlyDictionary <string, object> d
? HttpResponseDeserializer.Deserialize(d)
: QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage("Could not deserialize query response.")
.Build());
if (interceptors is { })
public async Task InvokeAsync(IQueryContext context)
{
try
{
IHttpClientFactory httpClientFactory =
context.Services.GetRequiredService <IHttpClientFactory>();
context.Result = await _client.FetchAsync(
context.Request,
httpClientFactory.CreateClient(_schemaName),
context.Services.GetServices <IHttpQueryRequestInterceptor>(),
context.RequestAborted)
.ConfigureAwait(false);
}
catch (HttpRequestException ex)
{
IError error = _errorHandler.CreateUnexpectedError(ex)
.SetCode(ErrorCodes.HttpRequestException)
.Build();
context.Exception = ex;
context.Result = QueryResultBuilder.CreateError(error);
}
await _next.Invoke(context).ConfigureAwait(false);
}
public static Task SerializeAsync(
this IQueryResultSerializer serializer,
IExecutionResult result,
Stream outputStream,
CancellationToken cancellationToken)
{
if (result is IReadOnlyQueryResult queryResult)
{
using (queryResult)
{
return(serializer.SerializeAsync(
queryResult,
outputStream,
cancellationToken));
}
}
else
{
// TODO : resources
return(serializer.SerializeAsync(
QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage("Result type not supported.")
.SetCode(ErrorCodes.Serialization.ResultTypeNotSupported)
.Build()),
outputStream,
cancellationToken));
}
}
public static IQueryResult RootTypeNotFound(OperationType operationType) =>
QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage(
"The specified root type `{0}` is not supported by this server.",
operationType)
.Build());
private static void ExtractData(
IDictionary <string, string> aliases,
IQueryResult mergedResult,
QueryResultBuilder result)
{
var data = new ResultMap();
data.EnsureCapacity(aliases.Count);
var i = 0;
if (mergedResult.Data is not null)
{
foreach (KeyValuePair <string, string> alias in aliases)
{
if (mergedResult.Data.TryGetValue(alias.Key, out object?o))
{
data.SetValue(i++, alias.Value, o);
}
}
}
else
{
foreach (KeyValuePair <string, string> alias in aliases)
{
data.SetValue(i++, alias.Value, null);
}
}
result.SetData(data);
}
public static IQueryResult UnknownSubscriptionError(Exception ex)
=> QueryResultBuilder.CreateError(
ErrorBuilder
.New()
.SetException(ex)
.SetCode(ErrorCodes.Execution.TaskProcessingError)
.SetMessage(AspNetCoreResources.Subscription_SendResultsAsync)
.Build());
protected IRequestExecutor CreateSchema <TEntity, T>(
TEntity[] entities,
FilterConvention?convention = null,
bool withPaging = false)
where TEntity : class
where T : FilterInputType <TEntity>
{
convention ??= new FilterConvention(x => x.AddDefaults().BindRuntimeType <TEntity, T>());
Func <IResolverContext, IEnumerable <TEntity> >?resolver = BuildResolver(entities);
ISchemaBuilder builder = SchemaBuilder.New()
.AddConvention <IFilterConvention>(convention)
.AddFiltering()
.AddQueryType(
c =>
{
ApplyConfigurationToField <TEntity, T>(
c.Name("Query").Field("root").Resolver(resolver),
withPaging);
ApplyConfigurationToField <TEntity, T>(
c.Name("Query")
.Field("rootExecutable")
.Resolver(
ctx => resolver(ctx).AsExecutable()),
withPaging);
});
ISchema schema = builder.Create();
return(new ServiceCollection()
.Configure <RequestExecutorSetup>(
Schema.DefaultName,
o => o.Schema = schema)
.AddGraphQL()
.UseRequest(
next => async context =>
{
await next(context);
if (context.Result is IReadOnlyQueryResult result &&
context.ContextData.TryGetValue("sql", out var queryString))
{
context.Result =
QueryResultBuilder
.FromResult(result)
.SetContextData("sql", queryString)
.Create();
}
})
.UseDefaultPipeline()
.Services
.BuildServiceProvider()
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync()
.Result);
}
public static IQueryResult TypeNotFound(string typeName)
=> QueryResultBuilder.CreateError(
new Error(
$"The type `{typeName}` does not exist.",
code: ErrorCodes.Server.TypeDoesNotExist,
extensions: new Dictionary <string, object?>
{
{ "typeName", typeName }
}));
private async Task HandleRequestAsync(HttpContext context)
{
// first we need to get the request executor to be able to execute requests.
IRequestExecutor requestExecutor = await GetExecutorAsync(context.RequestAborted);
IHttpRequestInterceptor requestInterceptor = requestExecutor.GetRequestInterceptor();
IErrorHandler errorHandler = requestExecutor.GetErrorHandler();
context.Items[WellKnownContextData.RequestExecutor] = requestExecutor;
HttpStatusCode? statusCode = null;
IExecutionResult?result;
// next we parse the GraphQL request.
GraphQLRequest request;
using (_diagnosticEvents.ParseHttpRequest(context))
{
try
{
request = _requestParser.ReadParamsRequest(context.Request.Query);
}
catch (GraphQLRequestException ex)
{
// A GraphQL request exception is thrown if the HTTP request body couldn't be
// parsed. In this case we will return HTTP status code 400 and return a
// GraphQL error result.
statusCode = HttpStatusCode.BadRequest;
IReadOnlyList <IError> errors = errorHandler.Handle(ex.Errors);
result = QueryResultBuilder.CreateError(errors);
_diagnosticEvents.ParserErrors(context, errors);
goto HANDLE_RESULT;
}
catch (Exception ex)
{
statusCode = HttpStatusCode.InternalServerError;
IError error = errorHandler.CreateUnexpectedError(ex).Build();
result = QueryResultBuilder.CreateError(error);
_diagnosticEvents.HttpRequestError(context, error);
goto HANDLE_RESULT;
}
}
// after successfully parsing the request we now will attempt to execute the request.
try
{
GraphQLServerOptions?options = context.GetGraphQLServerOptions();
result = await ExecuteSingleAsync(
context,
requestExecutor,
requestInterceptor,
_diagnosticEvents,
request,
options is null or { AllowedGetOperations : AllowedGetOperations.Query }
?_onlyQueries
: null);
}
public static IQueryResult InvalidTypeName(string typeName)
=> QueryResultBuilder.CreateError(
new Error(
"The type name is invalid.",
code: ErrorCodes.Server.InvalidTypeName,
extensions: new Dictionary <string, object?>
{
{ "typeName", typeName }
}));
public static IQueryResult OperationKindNotAllowed() =>
QueryResultBuilder.CreateError(
ErrorBuilder.New()
.SetMessage("The specified operation kind is not allowed.")
.Build(),
new Dictionary <string, object?>
{
{ WellKnownContextData.OperationNotAllowed, null }
});
public async Task DeserializeQueryResultWithErrors()
{
// arrange
var qux = new OrderedDictionary {
{ "quux", 123 }
};
var baz = new OrderedDictionary {
{ "qux", qux }
};
var objectList = new List <object> {
baz
};
var scalarList = new List <object> {
123
};
var result = QueryResultBuilder.New();
var data = new OrderedDictionary();
data["foo"] = objectList;
data["bar"] = scalarList;
data["baz"] = baz;
result.SetData(data);
result.AddError(ErrorBuilder.New()
.SetMessage("foo")
.SetPath(Path.New("root").Append("child"))
.AddLocation(new Location(15, 16))
.SetExtension("bar", "baz")
.Build());
result.AddError(ErrorBuilder.New()
.SetMessage("qux")
.SetExtension("bar", "baz")
.Build());
result.AddError(ErrorBuilder.New()
.SetMessage("quux")
.Build());
var stream = new MemoryStream();
var serializer = new JsonQueryResultSerializer();
await serializer.SerializeAsync(result.Create(), stream);
byte[] buffer = stream.ToArray();
var serializedResult = Utf8GraphQLRequestParser.ParseJson(buffer);
// act
IReadOnlyQueryResult deserializedResult =
HttpResponseDeserializer.Deserialize(
(IReadOnlyDictionary <string, object>)serializedResult);
// assert
Snapshot.Match(deserializedResult);
}
public async Task ClassDataLoader()
{
// arrange
IRequestExecutor executor = await CreateExecutorAsync(c => c
.AddQueryType <Query>()
.AddDataLoader <ITestDataLoader, TestDataLoader>()
.UseRequest(next => async context =>
{
await next(context);
var dataLoader =
context.Services
.GetRequiredService <IDataLoaderRegistry>()
.GetOrRegister <TestDataLoader>(() => throw new Exception());
context.Result = QueryResultBuilder
.FromResult((IQueryResult)context.Result)
.AddExtension("loads", dataLoader.Loads)
.Create();
})
.UseDefaultPipeline());
// act
var results = new List <IExecutionResult>();
results.Add(await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"{
a: withDataLoader(key: ""a"")
b: withDataLoader(key: ""b"")
bar {
c: withDataLoader(key: ""c"")
}
}")
.Create()));
results.Add(await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"{
a: withDataLoader(key: ""a"")
}")
.Create()));
results.Add(await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"{
c: withDataLoader(key: ""c"")
}")
.Create()));
// assert
results.MatchSnapshot();
}
private async Task DispatchRequestsAsync(
IList <BufferedRequest> requests,
DocumentNode mergedQuery,
NameNode operationName,
IReadOnlyDictionary <string, object> variableValues,
CancellationToken cancellationToken)
{
int index = 0;
try
{
IReadOnlyQueryRequest mergedRequest =
QueryRequestBuilder.New()
.SetQuery(mergedQuery)
.SetOperation(operationName.Value)
.SetVariableValues(variableValues)
.SetServices(_services)
.Create();
var mergedResult = (IReadOnlyQueryResult)await _queryExecutor
.ExecuteAsync(mergedRequest, cancellationToken)
.ConfigureAwait(false);
var handledErrors = new HashSet <IError>();
for (int i = 0; i < requests.Count; i++)
{
index = i;
QueryResultBuilder result = ExtractResult(
requests[i].Aliases,
mergedResult,
handledErrors);
IReadOnlyList <IError> mergedErrors = mergedResult.Errors ?? Array.Empty <IError>();
if (handledErrors.Count < mergedErrors.Count &&
i == requests.Count - 1)
{
foreach (IError error in mergedErrors.Except(handledErrors))
{
result.AddError(error);
}
}
requests[i].Promise.SetResult(result.Create());
}
}
catch (Exception ex)
{
for (int i = index; i < requests.Count; i++)
{
requests[i].Promise.SetException(ex);
}
}
}
public Task <IReadOnlyQueryResult> OnResponseReceivedAsync(
IReadOnlyQueryRequest request,
HttpResponseMessage response,
IReadOnlyQueryResult result)
{
return(Task.FromResult(
QueryResultBuilder.FromResult(result)
.SetContextData("foo", "bar")
.Create()));
}
protected async Task <IRequestExecutor> CreateSchemaAsync <TEntity, T>(
TEntity[] entities,
FilterConvention?convention = null)
where TEntity : class
where T : FilterInputType <TEntity>
{
Func <IResolverContext, IEnumerable <TEntity> > resolver =
await BuildResolverAsync(entities);
return(await new ServiceCollection()
.AddGraphQL()
.AddFiltering()
.AddSpatialTypes()
.AddSpatialFiltering()
.AddQueryType(
c => c
.Name("Query")
.Field("root")
.Resolve(resolver)
.Use(
next => async context =>
{
await next(context);
if (context.Result is IQueryable <TEntity> queryable)
{
try
{
context.ContextData["sql"] = queryable.ToQueryString();
}
catch (Exception)
{
context.ContextData["sql"] =
"EF Core 3.1 does not support ToQueryString officially";
}
}
})
.UseFiltering <T>())
.UseRequest(
next => async context =>
{
await next(context);
if (context.Result is IReadOnlyQueryResult result &&
context.ContextData.TryGetValue("sql", out var queryString))
{
context.Result =
QueryResultBuilder
.FromResult(result)
.SetContextData("sql", queryString)
.Create();
}
})
.UseDefaultPipeline()
.BuildRequestExecutorAsync());
}
public async Task DispatchMultipleQueriesAndRewriteErrors()
{
// arrange
string query = null;
int count = 0;
var result = QueryResultBuilder.New();
var data = new OrderedDictionary();
data["__0__a"] = "a";
data["__1__a"] = "b";
data["__1__b"] = "c";
result.SetData(data);
result.AddError(ErrorBuilder.New()
.SetMessage("foo")
.SetPath(Path.New("__1__b"))
.Build());
var executor = new Mock <IQueryExecutor>();
executor.Setup(t => t.ExecuteAsync(
It.IsAny <IReadOnlyQueryRequest>(),
It.IsAny <CancellationToken>()))
.Returns(new Func <IReadOnlyQueryRequest,
CancellationToken, Task <IExecutionResult> >((r, ct) =>
{
count++;
query = r.Query.ToString();
return(Task.FromResult <IExecutionResult>(result.Create()));
}));
var request_a = QueryRequestBuilder.Create("query a { a }");
var request_b = QueryRequestBuilder.Create("query b { a b }");
var client = new RemoteQueryClient(
new EmptyServiceProvider(),
executor.Object);
// act
Task <IExecutionResult> task_a = client.ExecuteAsync(request_a);
Task <IExecutionResult> task_b = client.ExecuteAsync(request_b);
await client.DispatchAsync(CancellationToken.None);
// assert
Assert.Equal(1, count);
IExecutionResult result_a = await task_a;
result_a.MatchSnapshot("DispatchMultipleQueriesAndRewriteErrors_A");
IExecutionResult result_b = await task_b;
result_b.MatchSnapshot("DispatchMultipleQueriesAndRewriteErrors_B");
}
public static IQueryResult MaxComplexityReached(
int complexity,
int allowedComplexity) =>
QueryResultBuilder.CreateError(
new Error(
ErrorHelper_MaxComplexityReached,
ErrorCodes.Execution.ComplexityExceeded,
extensions: new Dictionary <string, object?>
{
{ nameof(complexity), complexity },
{ nameof(allowedComplexity), allowedComplexity }
}));
private async Task <IQueryResult> ExecuteNextAsync(
IReadOnlyQueryRequest request,
CancellationToken cancellationToken)
{
try
{
DocumentNode document = request.Query is QueryDocument d
? d.Document
: Utf8GraphQLParser.Parse(request.Query !.AsSpan());
OperationDefinitionNode operation =
document.GetOperation(request.OperationName);
if (document != _previous)
{
_fragments = document.GetFragments();
_visitationMap.Initialize(_fragments);
}
operation.Accept(
_visitor,
_visitationMap,
n => VisitorAction.Continue);
_previous = document;
document = RewriteDocument(operation);
operation = (OperationDefinitionNode)document.Definitions[0];
IReadOnlyDictionary <string, object?>?variableValues =
MergeVariables(request.VariableValues, operation);
request = QueryRequestBuilder.From(request)
.SetQuery(document)
.SetVariableValues(variableValues)
.AddExportedVariables(_exportedVariables)
.SetQueryName(null) // TODO ... should we create a name here?
.SetQueryHash(null)
.Create();
return((IReadOnlyQueryResult)await _requestExecutor.ExecuteAsync(
request, cancellationToken)
.ConfigureAwait(false));
}
catch (GraphQLException ex)
{
return(QueryResultBuilder.CreateError(ex.Errors));
}
catch (Exception ex)
{
return(QueryResultBuilder.CreateError(
_errorHandler.Handle(
_errorHandler.CreateUnexpectedError(ex).Build())));
}
}
protected IRequestExecutor CreateSchema <TEntity, T>(
TEntity[] entities,
MongoResource mongoResource,
bool withPaging = false)
where TEntity : class
where T : FilterInputType <TEntity>
{
Func <IResolverContext, IExecutable <TEntity> > resolver = BuildResolver(
mongoResource,
entities);
return(new ServiceCollection()
.AddGraphQL()
.AddObjectIdConverters()
.AddFiltering(x => x.BindRuntimeType <TEntity, T>().AddMongoDbDefaults())
.AddQueryType(
c => c
.Name("Query")
.Field("root")
.Resolve(resolver)
.Use(
next => async context =>
{
await next(context);
if (context.Result is IExecutable executable)
{
context.ContextData["query"] = executable.Print();
}
})
.UseFiltering <T>())
.UseRequest(
next => async context =>
{
await next(context);
if (context.Result is IReadOnlyQueryResult result &&
context.ContextData.TryGetValue("query", out var queryString))
{
context.Result =
QueryResultBuilder
.FromResult(result)
.SetContextData("query", queryString)
.Create();
}
})
.UseDefaultPipeline()
.Services
.BuildServiceProvider()
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync()
.GetAwaiter()
.GetResult());
}
private async Task SendResultsAsync()
{
try
{
await foreach (IQueryResult result in
_responseStream.ReadResultsAsync().WithCancellation(_cts.Token))
{
using (result)
{
await _connection.SendAsync(new DataResultMessage(Id, result), _cts.Token);
}
}
if (!_cts.IsCancellationRequested)
{
await _connection.SendAsync(new DataCompleteMessage(Id), _cts.Token);
Completed?.Invoke(this, EventArgs.Empty);
}
}
catch (OperationCanceledException) { }
catch (ObjectDisposedException) { }
catch (Exception ex)
{
if (!_cts.IsCancellationRequested)
{
IError error =
ErrorBuilder
.New()
.SetException(ex)
.SetCode(ErrorCodes.Execution.TaskProcessingError)
.SetMessage("Unexpected Execution Error")
.Build();
IQueryResult result = QueryResultBuilder.CreateError(error);
try
{
await _connection.SendAsync(new DataResultMessage(Id, result), _cts.Token);
}
finally
{
await _connection.SendAsync(new DataCompleteMessage(Id), _cts.Token);
Completed?.Invoke(this, EventArgs.Empty);
}
}
}
finally
{
Dispose();
}
}
private static QueryResultBuilder ExtractResult(
IDictionary <string, string> aliases,
IQueryResult mergedResult,
ICollection <IError> handledErrors)
{
var result = QueryResultBuilder.New();
if (mergedResult.Data is not null)
{
var data = new ResultMap();
data.EnsureCapacity(aliases.Count);
var i = 0;
foreach (KeyValuePair <string, string> alias in aliases)
{
if (mergedResult.Data.TryGetValue(alias.Key, out object?o))
{
data.SetValue(i++, alias.Value, o);
}
}
result.SetData(data);
}
if (mergedResult.Errors is not null)
{
foreach (IError error in mergedResult.Errors)
{
if (TryResolveField(error, aliases, out string?responseName))
{
handledErrors.Add(error);
result.AddError(RewriteError(error, responseName));
}
}
}
if (mergedResult.Extensions is not null)
{
result.SetExtensions(mergedResult.Extensions);
}
if (mergedResult.ContextData is not null)
{
foreach (KeyValuePair <string, object?> item in mergedResult.ContextData)
{
result.SetContextData(item.Key, item.Value);
}
}
return(result);
}
public async Task ClassDataLoader_Resolve_From_DependencyInjection()
{
// arrange
IRequestExecutor executor = await CreateExecutorAsync(c => c
.AddQueryType <Query>()
.AddDataLoader <ITestDataLoader, TestDataLoader>()
.UseRequest(next => async context =>
{
await next(context);
var dataLoader =
(TestDataLoader)context.Services.GetRequiredService <ITestDataLoader>();
context.Result = QueryResultBuilder
.FromResult((IQueryResult)context.Result)
.AddExtension("loads", dataLoader.Loads)
.Create();
})
.UseDefaultPipeline());
// act
var results = new List <IExecutionResult>();
results.Add(await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"{
a: dataLoaderWithInterface(key: ""a"")
b: dataLoaderWithInterface(key: ""b"")
}")
.Create()));
results.Add(await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"{
a: dataLoaderWithInterface(key: ""a"")
}")
.Create()));
results.Add(await executor.ExecuteAsync(
QueryRequestBuilder.New()
.SetQuery(
@"{
c: dataLoaderWithInterface(key: ""c"")
}")
.Create()));
// assert
results.MatchSnapshot();
}
protected override RdfBindingSet runTripleConstraints(java.util.List tripleConstraints,
name.levering.ryan.sparql.model.logic.ConstraintLogic.CallParams p)
{
if (DisableQuery)
return null;
RdfSourceWrapper s = (RdfSourceWrapper)p.source;
if (s.source is QueryableSource) {
QueryableSource qs = (QueryableSource)s.source;
QueryOptions opts = new QueryOptions();
opts.Limit = p.limit;
VariableList distinguishedVars = new VariableList();
VariableList undistinguishedVars = new VariableList();
opts.VariableKnownValues = new VarKnownValuesType();
Statement[] graph = new Statement[tripleConstraints.size()];
Hashtable varMap1 = new Hashtable();
Hashtable varMap2 = new Hashtable();
Entity metaField;
// In this case, we want to treat the meta fields of all of the statements
// in this group as bound by a single variable.
if (p.graphVariable != null) {
metaField = ToRes(p.graphVariable, p.knownValues, true, varMap1, varMap2, s, opts, distinguishedVars, undistinguishedVars, p.distinguishedVariables) as Entity;
// Otherwise, we are told what graph to use. If sourceDatasets is null,
// we are looking in the default graph.
} else if (p.sourceDatasets == null) {
/*if (p.defaultDatasets.size() == 0) {
metaField = Statement.DefaultMeta;
} else if (p.defaultDatasets.size() == 1) {
metaField = s.ToEntity((Value)p.defaultDatasets.iterator().next());
} else {
metaField = new SemWebVariable();
opts.VariableKnownValues[(Variable)metaField] = s.ToEntities((Value[])p.defaultDatasets.toArray(new Value[0]));
}*/
// For the default Graph, we always pass DefaultMeta.
metaField = Statement.DefaultMeta;
// Otherwise, we are looking in the indicated graphs.
} else {
if (p.sourceDatasets.size() == 0) {
metaField = new SemWebVariable();
} else if (p.sourceDatasets.size() == 1) {
metaField = s.ToEntity((Value)p.sourceDatasets.iterator().next());
} else {
metaField = new SemWebVariable();
opts.VariableKnownValues[(Variable)metaField] = s.ToEntities((Value[])p.sourceDatasets.toArray(new Value[0]));
}
}
for (int i = 0; i < tripleConstraints.size(); i++) {
TripleConstraintData triple = tripleConstraints.get(i) as TripleConstraintData;
if (triple == null) return null;
graph[i] = new Statement(null, null, null, null); // I don't understand why this should be necessary for a struct, but I get a null reference exception otherwise (yet, that didn't happen initially)
graph[i].Subject = ToRes(triple.getSubjectExpression(), p.knownValues, true, varMap1, varMap2, s, opts, distinguishedVars, undistinguishedVars, p.distinguishedVariables) as Entity;
graph[i].Predicate = ToRes(triple.getPredicateExpression(), p.knownValues, true, varMap1, varMap2, s, opts, distinguishedVars, undistinguishedVars, p.distinguishedVariables) as Entity;
graph[i].Object = ToRes(triple.getObjectExpression(), p.knownValues, false, varMap1, varMap2, s, opts, distinguishedVars, undistinguishedVars, p.distinguishedVariables);
graph[i].Meta = metaField;
if (graph[i].AnyNull) return new RdfBindingSetImpl();
if (!(graph[i].Subject is Variable) && !(graph[i].Predicate is Variable) && !(graph[i].Object is Variable) && !(graph[i].Meta is Variable))
return null; // we could use Contains(), but we'll just abandon the Query() path altogether
}
if (p.distinguishedVariables == null) {
opts.DistinguishedVariables = null;
} else if (distinguishedVars.Count > 0) {
opts.DistinguishedVariables = distinguishedVars;
} else if (undistinguishedVars.Count > 0) {
// we don't mean to make it distinguished, but we need at least one,
// and for now we'll just take the first
opts.DistinguishedVariables = new VariableList();
((VariableList)opts.DistinguishedVariables).Add(undistinguishedVars[0]);
} else {
// no variables!
return null;
}
opts.VariableLiteralFilters = new LitFilterMap();
foreach (DictionaryEntry kv in varMap1) {
if (p.knownFilters != null && p.knownFilters.containsKey(kv.Key)) {
LitFilterList filters = new LitFilterList();
for (java.util.Iterator iter = ((java.util.List)p.knownFilters.get(kv.Key)).iterator(); iter.hasNext(); )
filters.Add((LiteralFilter)iter.next());
opts.VariableLiteralFilters[(Variable)kv.Value] = filters;
}
}
// too expensive to do...
//if (!qs.MetaQuery(graph, opts).QuerySupported)
// return null; // TODO: We could also check if any part has NoData, we can abandon the query entirely
QueryResultBuilder builder = new QueryResultBuilder();
builder.varMap = varMap2;
builder.source = s;
qs.Query(graph, opts, builder);
return builder.bindings;
}
return null;
}
