/// <summary>
/// Executes a SPARQL Query on the Graph.
/// </summary>
/// <param name="query">SPARQL Query.</param>
/// <returns></returns>
public Object ExecuteQuery(SparqlQuery query)
{
if (_processor == null)
{
InMemoryDataset ds = new InMemoryDataset(this);
_processor = new LeviathanQueryProcessor(ds);
}
return(_processor.ProcessQuery(query));
}
private void TestResultCountHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
SparqlResultSet expected = processor.ProcessQuery(q) as SparqlResultSet;
Assert.NotNull(expected);
ResultCountHandler handler = new ResultCountHandler();
processor.ProcessQuery(null, handler, q);
Assert.Equal(expected.Count, handler.Count);
}
private void TestCountHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
Graph expected = processor.ProcessQuery(q) as Graph;
Assert.NotNull(expected);
CountHandler handler = new CountHandler();
processor.ProcessQuery(handler, null, q);
Assert.Equal(expected.Triples.Count, handler.Count);
}
private void TestGraphHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
Graph expected = processor.ProcessQuery(q) as Graph;
Assert.NotNull(expected);
Graph actual = new Graph();
GraphHandler handler = new GraphHandler(actual);
processor.ProcessQuery(handler, null, q);
Assert.Equal(expected, actual);
}
public object ExecuteQuery(string query)
{
SparqlQueryParser sparqlparser = new SparqlQueryParser();
var q = sparqlparser.ParseFromString(query.ToString());
return(_queryProcessor.ProcessQuery(q));
}
public IEnumerable <Dictionary <string, string> > Process(string query)
{
var parsedQuery = _sparqlQueryParser.ParseFromString(query);
var resObj = _queryProc.ProcessQuery(parsedQuery);
if (resObj is SparqlResultSet results)
{
foreach (var result in results)
{
var resDic = new Dictionary <string, string>();
foreach (var item in result)
{
string value;
if (item.Value is LiteralNode node)
{
value = node.Value;
}
else
{
value = item.Value.ToString();
}
resDic[item.Key] = value;
}
yield return(resDic);
}
}
else
{
throw new ExtensionException(Name, "Wrong query type");
}
}
public Stream ExecuteQuery(string queryExpression, IList <string> datasetGraphUris)
{
var parser = new SparqlQueryParser();
var query = parser.ParseFromString(queryExpression);
var sparqlResults = _queryProcessor.ProcessQuery(query);
var memoryStream = new MemoryStream();
using (var streamWriter = new StreamWriter(memoryStream, Encoding.UTF8))
{
if (sparqlResults is SparqlResultSet)
{
var resultSet = sparqlResults as SparqlResultSet;
var writer = new SparqlXmlWriter();
writer.Save(resultSet, streamWriter);
}
else if (sparqlResults is IGraph)
{
var g = sparqlResults as IGraph;
var writer = new RdfXmlWriter();
writer.Save(g, streamWriter);
}
}
return(new MemoryStream(memoryStream.ToArray()));
//return new MemoryStream(Encoding.UTF8.GetBytes(buff.ToString()), false);
}
public SparqlResult ExecuteQuery(SparqlQueryContext queryContext, IList <string> datasetGraphUris)
{
var parser = new SparqlQueryParser();
var query = parser.ParseFromString(queryContext.SparqlQuery);
var sparqlResults = _queryProcessor.ProcessQuery(query);
return(new SparqlResult(sparqlResults, queryContext));
}
private void TestCountHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
Graph expected = processor.ProcessQuery(q) as Graph;
if (expected == null)
{
Assert.Fail("Query failed to return a Graph as expected");
}
CountHandler handler = new CountHandler();
processor.ProcessQuery(handler, null, q);
Assert.AreEqual(expected.Triples.Count, handler.Count, "Counts should have been equal");
}
private void TestResultCountHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
SparqlResultSet expected = processor.ProcessQuery(q) as SparqlResultSet;
if (expected == null)
{
Assert.Fail("Query failed to return a Result Set as expected");
}
ResultCountHandler handler = new ResultCountHandler();
processor.ProcessQuery(null, handler, q);
Assert.AreEqual(expected.Count, handler.Count, "Counts should have been equal");
}
private void TestResultSetHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
SparqlResultSet expected = processor.ProcessQuery(q) as SparqlResultSet;
if (expected == null)
{
Assert.Fail("Query failed to return a Result Set as expected");
}
SparqlResultSet actual = new SparqlResultSet();
ResultSetHandler handler = new ResultSetHandler(actual);
processor.ProcessQuery(null, handler, q);
Assert.AreEqual(expected, actual, "Result Sets should be equal");
}
private void TestGraphHandler(ISparqlQueryProcessor processor, String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
Graph expected = processor.ProcessQuery(q) as Graph;
if (expected == null)
{
Assert.Fail("Query failed to return a Grah as expected");
}
Graph actual = new Graph();
GraphHandler handler = new GraphHandler(actual);
processor.ProcessQuery(handler, null, q);
Assert.AreEqual(expected, actual, "Graphs should be equal");
}
/// <summary>
/// This method queries the dotNetRdf store directly.
/// </summary>
/// <param name="query"></param>
/// <returns></returns>
public object ExecuteQuery(string query)
{
Log?.Invoke(query);
SparqlQueryParser parser = new SparqlQueryParser();
var q = parser.ParseFromString(query);
return(_queryProcessor.ProcessQuery(q));
}
/// <summary>
/// Executes this command as a query
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
public void ExecuteQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler)
{
if (_queryProcessor == null)
{
throw new RdfQueryException("Cannot call ExecuteQuery() when the QueryProcessor property has not been set");
}
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(ToString());
_queryProcessor.ProcessQuery(rdfHandler, resultsHandler, q);
}
private void TestWriteThroughHandler(ISparqlQueryProcessor processor, String query)
{
NTriplesFormatter formatter = new NTriplesFormatter();
StringWriter data = new StringWriter();
SparqlQuery q = this._parser.ParseFromString(query);
Graph expected = processor.ProcessQuery(q) as Graph;
Assert.NotNull(expected);
WriteThroughHandler handler = new WriteThroughHandler(formatter, data, false);
processor.ProcessQuery(handler, null, q);
Console.WriteLine(data.ToString());
Graph actual = new Graph();
StringParser.Parse(actual, data.ToString(), new NTriplesParser());
Assert.Equal(expected, actual);
}
private SparqlResultSet QueryWithResults(SparqlQuery q, ISparqlQueryProcessor processor)
{
var results = processor.ProcessQuery(q);
if (results is SparqlResultSet)
{
return((SparqlResultSet)results);
}
else
{
Assert.True(false, "Query did not produce a Result Set as expected");
}
return(null);
}
private IGraph QueryWithGraph(SparqlQuery q, ISparqlQueryProcessor processor)
{
var results = processor.ProcessQuery(q);
if (results is IGraph)
{
return((IGraph)results);
}
else
{
Assert.True(false, "Query did not produce a Graph as expected");
}
return(null);
}
private void TestWriteThroughHandler(ISparqlQueryProcessor processor, String query)
{
NTriplesFormatter formatter = new NTriplesFormatter();
StringWriter data = new StringWriter();
SparqlQuery q = this._parser.ParseFromString(query);
Graph expected = processor.ProcessQuery(q) as Graph;
if (expected == null)
{
Assert.Fail("Query did not produce a Graph as expected");
}
WriteThroughHandler handler = new WriteThroughHandler(formatter, data, false);
processor.ProcessQuery(handler, null, q);
Console.WriteLine(data.ToString());
Graph actual = new Graph();
StringParser.Parse(actual, data.ToString(), new NTriplesParser());
Assert.AreEqual(expected, actual, "Graphs should be equal");
}
public SparqlResultSet ExecuteQuery(string query)
{
var queryString = new SparqlParameterizedString(query);
foreach (var prefix in namespaceMapper.Prefixes)
{
if (!queryString.Namespaces.HasNamespace(prefix))
{
queryString.Namespaces.AddNamespace(prefix, namespaceMapper.GetNamespaceUri(prefix));
}
}
var parsed = sparqlQueryParser.ParseFromString(queryString);
return((SparqlResultSet)sparqlProcessor.ProcessQuery(parsed));
}
public AndConstraint <StoreAssertions> MatchAsk(
Action <ITriplePatternBuilder> getPtterns,
Func <INonAggregateExpressionBuilder, BooleanExpression> getFilters = null)
{
var queryBuilder = QueryBuilder.Ask().Where(getPtterns);
if (getFilters != null)
{
queryBuilder.Filter(getFilters);
}
var query = queryBuilder.BuildQuery();
var askResult = (SparqlResultSet)queryProcessor.ProcessQuery(queryBuilder.BuildQuery());
askResult.Result.Should().BeTrue("Dataset contents should match query:{0}{1}", Environment.NewLine, query);
return(new AndConstraint <StoreAssertions>(this));
}
private AndConstraint <StoreAssertions> VerifyAskQuery(
Action <ITriplePatternBuilder> buildPatterns,
bool expectedResult,
Func <ExpressionBuilder, BooleanExpression> filter = null)
{
var ask = QueryBuilder.Ask().Where(buildPatterns);
if (filter != null)
{
ask.Filter(filter);
}
var sparqlQuery = ask.BuildQuery();
var result = (SparqlResultSet)_queryProcessor.ProcessQuery(sparqlQuery);
result.Result.Should().Be(expectedResult, "RDF data should match query '{0}'", sparqlQuery);
return(new AndConstraint <StoreAssertions>(this));
}
/// <summary>
/// Processes a SPARQL Query using given SPARQL procesor returning either an IGraph instance or SparqlResultSet, or AsyncError if the processing failed
/// </summary>
/// <returns>IGraph or SparqlResultSet or AsyncError or null</returns>
public static Task <object> ProcessQuery(SparqlQuery query, ISparqlQueryProcessor processor)
{
TaskCompletionSource <object> taskComplSource = new TaskCompletionSource <object>();
if (query == null || processor == null)
{
var asyncError = new AsyncError(new BrowserException("An internal error occured while processing the query."), null);
taskComplSource.SetResult(asyncError);
}
else
{
//state will contain AsyncError
//catches all exceptions inside, putting them into AsyncError
processor.ProcessQuery(
query,
(IGraph g, object state) => { taskComplSource.SetResult(g ?? state); },
(SparqlResultSet results, object state) => { taskComplSource.SetResult(results ?? state); },
null
);
}
return(taskComplSource.Task);
}
public SparqlResultSet Execute(string queryExpr, IDictionary <string, INode> paramValues = null)
{
var queryString = new SparqlParameterizedString(queryExpr);
// Import namespace presets.
foreach (var prefix in namespaceMapper.Prefixes)
{
if (!queryString.Namespaces.HasNamespace(prefix))
{
queryString.Namespaces.AddNamespace(prefix, namespaceMapper.GetNamespaceUri(prefix));
}
}
// Apply parameters.
if (paramValues != null)
{
foreach (var(name, value) in paramValues)
{
queryString.SetParameter(name, value);
}
}
// Parse the query.
var query = GuardedParseQueryString(queryString);
foreach (var prefix in namespaceMapper.Prefixes)
{
if (!query.NamespaceMap.HasNamespace(prefix))
{
query.NamespaceMap.AddNamespace(prefix, namespaceMapper.GetNamespaceUri(prefix));
}
}
var result = queryProcessor.ProcessQuery(query);
if (!(result is SparqlResultSet resultSet))
{
throw new NotSupportedException("Persisting AOT query results other than SparqlResultSet is not supported.");
}
return(resultSet);
}
private IGraph QueryForCurrentState()
{
// throw new NotImplementedException();
var ps = new SparqlParameterizedString();
ps.CommandText = @"
PREFIX mig: <http://industrialinference.com/migrations/0.1#>
CONSTRUCT {
[] a mig:Migration ;
mig:ordinal ?ordinal ;
mig:dtApplied ?dtApplied ;
mig:appliedBy ?appliedBy ;
mig:migrationHash ?migrationHash;
mig:migratorVersion ?migratorVersion;
mig:originalPath ?originalPath .
}
WHERE {
GRAPH mig:migrations {
_:mig a mig:Migration ;
mig:ordinal ?ordinal ;
mig:dtApplied ?dtApplied ;
mig:appliedBy ?appliedBy ;
mig:migrationHash ?migrationHash;
mig:migratorVersion ?migratorVersion;
mig:originalPath ?originalPath .
}
}";
var parser = new SparqlQueryParser();
var query = parser.ParseFromString(ps);
var result = _queryProcessor.ProcessQuery(query) as IGraph;
result?.NamespaceMap.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#"));
result?.NamespaceMap.AddNamespace("mig", new Uri("http://industrialinference.com/migrations/0.1#"));
return(result);
}
private static Collection<BaprLocation> ExecuteQuery(ISparqlQueryProcessor processor, SparqlQuery query)
{
try
{
object queryResult = processor.ProcessQuery(query);
if (queryResult is SparqlResultSet)
{
SparqlResultSet entities = (SparqlResultSet)queryResult;
return BaprAPI.Utils.Utils.ConvertFromSparqlSetToBaprLocations(entities);
}
}
catch (VDS.RDF.Query.RdfQueryException ex)
{
}
return new Collection<BaprLocation>();
}
/// <summary>
/// Does the SPARQL query then returns the result set
/// </summary>
public static SparqlResultSet DoQuery(string str)
{
SparqlQuery query = sparqlparser.ParseFromString(str);
return((SparqlResultSet)processor.ProcessQuery(query));
}
private SparqlResultSet QueryWithResults(SparqlQuery q, ISparqlQueryProcessor processor)
{
Object results = processor.ProcessQuery(q);
if (results is SparqlResultSet)
{
return (SparqlResultSet)results;
}
else
{
Assert.Fail("Query did not produce a Result Set as expected");
}
return null;
}
private IGraph QueryWithGraph(SparqlQuery q, ISparqlQueryProcessor processor)
{
Object results = processor.ProcessQuery(q);
if (results is IGraph)
{
return (IGraph)results;
}
else
{
Assert.Fail("Query did not produce a Graph as expected");
}
return null;
}
/// <summary>
/// Processes the Query using the given Query Processor
/// </summary>
/// <param name="processor">SPARQL Query Processor</param>
/// <returns></returns>
public Object Process(ISparqlQueryProcessor processor)
{
return(processor.ProcessQuery(this));
}
/// <summary>
/// Processes the Query using the given Query Processor
/// </summary>
/// <param name="processor">SPARQL Query Processor</param>
/// <returns></returns>
public Object Process(ISparqlQueryProcessor processor)
{
return processor.ProcessQuery(this);
}
/// <summary>
/// Processes a PUT operation
/// </summary>
/// <param name="context">HTTP Context</param>
public override void ProcessPut(IHttpContext context)
{
// Get the payload assuming there is one
IGraph g = ParsePayload(context);
// Get the Graph URI of the Graph to be added
Uri graphUri = ResolveGraphUri(context, g);
// Determine whether the Graph already exists or not, if it doesn't then we have to send a 201 Response
bool created = false;
try
{
SparqlQueryParser parser = new SparqlQueryParser();
SparqlParameterizedString graphExistsQuery = new SparqlParameterizedString();
graphExistsQuery.CommandText = "ASK WHERE { GRAPH @graph { } }";
graphExistsQuery.SetUri("graph", graphUri);
Object temp = _queryProcessor.ProcessQuery(parser.ParseFromString(graphExistsQuery));
if (temp is SparqlResultSet)
{
created = !((SparqlResultSet)temp).Result;
}
}
catch
{
// If any error occurs assume the Graph doesn't exist and so we'll return a 201 created
created = true;
}
// Generate a set of commands based upon this
StringBuilder cmdSequence = new StringBuilder();
if (graphUri != null)
{
cmdSequence.AppendLine("DROP SILENT GRAPH @graph ;");
cmdSequence.Append("CREATE SILENT GRAPH @graph");
}
else
{
cmdSequence.Append("DROP SILENT DEFAULT");
}
if (g != null)
{
cmdSequence.AppendLine(" ;");
if (graphUri != null)
{
cmdSequence.AppendLine("INSERT DATA { GRAPH @graph {");
}
else
{
cmdSequence.AppendLine("INSERT DATA { ");
}
TurtleFormatter formatter = new TurtleFormatter(g.NamespaceMap);
foreach (Triple t in g.Triples)
{
cmdSequence.AppendLine(t.ToString(formatter));
}
if (graphUri != null)
{
cmdSequence.AppendLine("} }");
}
else
{
cmdSequence.AppendLine("}");
}
}
SparqlParameterizedString put = new SparqlParameterizedString(cmdSequence.ToString());
put.Namespaces = g.NamespaceMap;
if (graphUri != null)
{
put.SetUri("graph", graphUri);
}
SparqlUpdateCommandSet putCmds = _parser.ParseFromString(put);
_updateProcessor.ProcessCommandSet(putCmds);
_updateProcessor.Flush();
// Return a 201 if required, otherwise the default behaviour of returning a 200 will occur automatically
if (created)
{
context.Response.StatusCode = (int)HttpStatusCode.Created;
}
}
public SparqlResultSet QueryFromFile(string filePath)
{
SparqlQuery query = _sqlQueryParser.ParseFromFile(filePath);
return((SparqlResultSet)_processor.ProcessQuery(query));
}