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; }