public void SparqlFunctionsNow()
{
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromFile("resources\\now01.rq");
Console.WriteLine("ToString Output:");
Console.WriteLine(q.ToString());
Console.WriteLine();
SparqlFormatter formatter = new SparqlFormatter();
Console.WriteLine("SparqlFormatter Output:");
Console.WriteLine(formatter.Format(q));
TripleStore store = new TripleStore();
LeviathanQueryProcessor processor = new LeviathanQueryProcessor(store);
SparqlResultSet results = processor.ProcessQuery(q) as SparqlResultSet;
if (results != null)
{
Assert.IsTrue(results.Result, "Result should be true");
}
else
{
Assert.Fail("Expected a non-null result");
}
}
public void SparqlFormattingOptionalAtRoot()
{
SparqlQuery q = new SparqlQuery {
QueryType = SparqlQueryType.Select
};
q.AddVariable(new SparqlVariable("s", true));
GraphPattern gp = new GraphPattern();
gp.IsOptional = true;
gp.AddTriplePattern(new TriplePattern(new VariablePattern("s"), new VariablePattern("p"), new VariablePattern("o")));
q.RootGraphPattern = gp;
String toStr = q.ToString();
Console.WriteLine("ToString() Form:");
Console.WriteLine(toStr);
Assert.AreEqual(2, toStr.ToCharArray().Where(c => c == '{').Count());
Assert.AreEqual(2, toStr.ToCharArray().Where(c => c == '}').Count());
Console.WriteLine();
SparqlFormatter formatter = new SparqlFormatter();
String fmtStr = formatter.Format(q);
Console.WriteLine("SparqlFormatter Form:");
Console.WriteLine(fmtStr);
Assert.AreEqual(2, fmtStr.ToCharArray().Where(c => c == '{').Count());
Assert.AreEqual(2, fmtStr.ToCharArray().Where(c => c == '}').Count());
}
private void TestQuery(String query)
{
SparqlQuery q = this._parser.ParseFromString(query);
Console.WriteLine(q.ToString());
Console.WriteLine();
Console.WriteLine(q.ToAlgebra().ToString());
}
public void SparqlParsingNestedGraphPatternFirstItem2()
{
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromFile("resources\\childgraphpattern2.rq");
Console.WriteLine(q.ToString());
Console.WriteLine();
Console.WriteLine(q.ToAlgebra().ToString());
}
public void SparqlParsingSubqueries2()
{
String query = "SELECT * WHERE { { SELECT * WHERE { ?s ?p ?o } } }";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
Console.WriteLine("Parsed original input OK");
String query2 = q.ToString();
SparqlQuery q2 = parser.ParseFromString(query2);
Console.WriteLine("Parsed reserialized input OK");
}
public void SparqlParsingToStringRoundTripCore458()
{
const String query = @"PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT *
WHERE
{
?s ?p ?o .
FILTER(?p = rdf:type)
}";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
String output = q.ToString();
SparqlQuery q2 = parser.ParseFromString(output);
}
public void SparqlParsingCore427_1()
{
const String query = "SELECT (UUID() AS ?test) { }";
SparqlQuery q = this._parser.ParseFromString(query);
String toString = q.ToString();
Assert.Contains("(UUID", toString);
String formattedString = new SparqlFormatter().Format(q);
Assert.Contains("(UUID", formattedString);
}
public void SparqlParsingCore427_2()
{
const String query = "SELECT (StrUUID() AS ?test) { }";
SparqlQuery q = this._parser.ParseFromString(query);
String toString = q.ToString();
Assert.IsTrue(toString.Contains("(STRUUID"));
String formattedString = new SparqlFormatter().Format(q);
Assert.IsTrue(formattedString.Contains("(STRUUID"));
}
/// <summary>
/// Processes a SPARQL Query passing the results to the RDF or Results handler as appropriate
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="query">SPARQL Query</param>
public void ProcessQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, SparqlQuery query)
{
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
_svc.Query(rdfHandler, resultsHandler, query.ToString());
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
}
/// <summary>
/// Processes a SPARQL Query asynchronously invoking the relevant callback when the query completes
/// </summary>
/// <param name="query">SPARQL QUery</param>
/// <param name="rdfCallback">Callback for queries that return a Graph</param>
/// <param name="resultsCallback">Callback for queries that return a Result Set</param>
/// <param name="state">State to pass to the callback</param>
public void ProcessQuery(SparqlQuery query, GraphCallback rdfCallback, SparqlResultsCallback resultsCallback, Object state)
{
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
this._svc.Query(query.ToString(), rdfCallback, resultsCallback, state);
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
}
/// <summary>
/// Processes a SPARQL Query asynchronously passing the results to the relevant handler and invoking the callback when the query completes
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="query">SPARQL Query</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
public void ProcessQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, SparqlQuery query, QueryCallback callback, Object state)
{
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
this._svc.Query(rdfHandler, resultsHandler, query.ToString(), callback, state);
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
}
///<summary>
/// Processes a SPARQL Query
/// </summary>
/// <param name="query">SPARQL Query</param>
/// <returns></returns>
public object ProcessQuery(SparqlQuery query)
{
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
Object temp = _svc.Query(query.ToString());
return(temp);
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
}
/// <summary>
/// Processes a SPARQL Query passing the results to the RDF or Results handler as appropriate
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="query">SPARQL Query</param>
public void ProcessQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, SparqlQuery query)
{
#if !SILVERLIGHT
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
this._svc.Query(rdfHandler, resultsHandler, query.ToString());
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
#else
throw new NotSupportedException("Synchronous remote query is not supported under Silverlight/WP7 - please use one of the alternative overload of this methods which takes a callback");
#endif
}
public void SparqlFormattingFilter1()
{
const string query = "SELECT * WHERE { { ?s ?p ?o } FILTER(ISURI(?o)) }";
SparqlQuery q = this._parser.ParseFromString(query);
Console.WriteLine("ToString() form:");
String toString = q.ToString();
Console.WriteLine(toString);
Console.WriteLine();
Console.WriteLine("Format() form:");
String formatted = this._formatter.Format(q);
Console.WriteLine(formatted);
Assert.IsTrue(toString.Contains("FILTER"), "ToString() form should contain FILTER");
Assert.IsTrue(formatted.Contains("FILTER"), "Format() form should contain FILTER");
}
/// <summary>
/// Processes a SPARQL Query
/// </summary>
/// <param name="query">SPARQL Query</param>
/// <returns></returns>
public object ProcessQuery(SparqlQuery query)
{
#if !SILVERLIGHT
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
Object temp = this._svc.Query(query.ToString());
return(temp);
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
#else
throw new NotSupportedException("Synchronous remote query is not supported under Silverlight/WP7 - please use one of the alternative overload of this methods which takes a callback");
#endif
}
/// <summary>
/// Processes a SPARQL Query
/// </summary>
/// <param name="query">SPARQL Query</param>
/// <returns></returns>
public object ProcessQuery(SparqlQuery query)
{
query.QueryExecutionTime = null;
query.QueryTime = -1;
query.QueryTimeTicks = -1;
DateTime start = DateTime.Now;
try
{
Object temp = this._store.ExecuteQuery(query.ToString());
return temp;
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = elapsed;
query.QueryTime = elapsed.Milliseconds;
query.QueryTimeTicks = elapsed.Ticks;
}
}
/// <summary>
/// Processes a SPARQL Query passing the results to the RDF or Results handler as appropriate
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="query">SPARQL Query</param>
public void ProcessQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, SparqlQuery query)
{
query.QueryTime = -1;
query.QueryTimeTicks = -1;
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
this._svc.Query(rdfHandler, resultsHandler, query.ToString());
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
query.QueryTime = elapsed.Milliseconds;
query.QueryTimeTicks = elapsed.Ticks;
}
}
public void SparqlGroupByRefactor7()
{
String query = "SELECT ?s WHERE { ?s ?p ?o } GROUP BY (?s)";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
String queryStr = q.ToString();
Console.WriteLine("Raw ToString()");
Console.WriteLine(queryStr);
Console.WriteLine();
Assert.Contains("GROUP BY ?s", queryStr);
String queryStrFmt = new SparqlFormatter().Format(q);
Console.WriteLine("Formatted String");
Console.WriteLine(queryStrFmt);
Assert.Contains("GROUP BY ?s", queryStrFmt);
}
/// <summary>
/// Processes a SPARQL Query
/// </summary>
/// <param name="query">SPARQL Query</param>
/// <returns></returns>
public object ProcessQuery(SparqlQuery query)
{
query.QueryTime = -1;
query.QueryTimeTicks = -1;
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
Object temp = this._svc.Query(query.ToString());
return(temp);
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
query.QueryTime = elapsed.Milliseconds;
query.QueryTimeTicks = elapsed.Ticks;
}
}
public void SparqlFormattingFilter2()
{
String query = "SELECT * WHERE { { ?s ?p ?o } FILTER(REGEX(?o, 'search', 'i')) }";
SparqlQueryParser parser = new SparqlQueryParser();
SparqlQuery q = parser.ParseFromString(query);
Console.WriteLine("ToString() form:");
String toString = q.ToString();
Console.WriteLine(toString);
Console.WriteLine();
Console.WriteLine("Format() form:");
String formatted = this._formatter.Format(q);
Console.WriteLine(formatted);
Assert.IsTrue(toString.Contains("FILTER"), "ToString() form should contain FILTER");
Assert.IsTrue(toString.Contains("i"), "ToString() form should contain i option");
Assert.IsTrue(formatted.Contains("FILTER"), "Format() form should contain FILTER");
Assert.IsTrue(toString.Contains("i"), "Format() form should contain i option");
}
public void SparqlFormattingUnion5()
{
const string query = "SELECT * WHERE { { SERVICE <http://x> { ?s a ?type } } UNION { GRAPH <http://y> { ?s ?p ?o } } }";
SparqlQuery q = this._parser.ParseFromString(query);
Console.WriteLine("ToString() form:");
String toString = q.ToString();
Console.WriteLine(toString);
Console.WriteLine();
Console.WriteLine("Format() form:");
String formatted = this._formatter.Format(q);
Console.WriteLine(formatted);
Assert.True(toString.Contains("UNION"), "ToString() form should contain UNION");
Assert.Equal(5, CountOccurrences(toString, '{'));
Assert.Equal(5, CountOccurrences(toString, '}'));
Assert.True(formatted.Contains("UNION"), "Formatted form should contain UNION");
Assert.Equal(5, CountOccurrences(formatted, '{'));
Assert.Equal(5, CountOccurrences(formatted, '}'));
}
public void SparqlFormattingUnion1()
{
const string query = "SELECT * WHERE { { ?s a ?type } UNION { ?s ?p ?o } }";
SparqlQuery q = this._parser.ParseFromString(query);
Console.WriteLine("ToString() form:");
String toString = q.ToString();
Console.WriteLine(toString);
Console.WriteLine();
Console.WriteLine("Format() form:");
String formatted = this._formatter.Format(q);
Console.WriteLine(formatted);
Assert.IsTrue(toString.Contains("UNION"), "ToString() form should contain UNION");
Assert.AreEqual(3, CountOccurrences(toString, '{'), "ToString() form should contain three opening braces");
Assert.AreEqual(3, CountOccurrences(toString, '}'), "ToString() form should contain three closing braces");
Assert.IsTrue(formatted.Contains("UNION"), "Formatted form should contain UNION");
Assert.AreEqual(3, CountOccurrences(formatted, '{'), "Formatted form should contain three opening braces");
Assert.AreEqual(3, CountOccurrences(formatted, '}'), "Formatted form should contain three closing braces");
}
/// <summary>
/// Processes a SPARQL Query
/// </summary>
/// <param name="query">SPARQL Query</param>
/// <returns></returns>
public object ProcessQuery(SparqlQuery query)
{
query.QueryExecutionTime = null;
query.QueryTime = -1;
query.QueryTimeTicks = -1;
DateTime start = DateTime.Now;
Object temp;
try
{
switch (query.QueryType)
{
case SparqlQueryType.Ask:
case SparqlQueryType.Select:
case SparqlQueryType.SelectAll:
case SparqlQueryType.SelectAllDistinct:
case SparqlQueryType.SelectAllReduced:
case SparqlQueryType.SelectDistinct:
case SparqlQueryType.SelectReduced:
temp = this._endpoint.QueryWithResultSet(query.ToString());
break;
case SparqlQueryType.Construct:
case SparqlQueryType.Describe:
case SparqlQueryType.DescribeAll:
temp = this._endpoint.QueryWithResultGraph(query.ToString());
break;
default:
throw new RdfQueryException("Unable to execute an unknown query type against a Remote Endpoint");
}
return temp;
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = elapsed;
query.QueryTime = elapsed.Milliseconds;
query.QueryTimeTicks = elapsed.Ticks;
}
}
/// <summary>
/// Processes a SPARQL Query asynchronously passing the results to the relevant handler and invoking the callback when the query completes
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="query">SPARQL Query</param>
/// <param name="callback">Callback</param>
/// <param name="state">State to pass to the callback</param>
public void ProcessQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, SparqlQuery query, QueryCallback callback, Object state)
{
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
this._svc.Query(rdfHandler, resultsHandler, query.ToString(), callback, state);
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
}
/// <summary>
/// Processes a SPARQL Query asynchronously invoking the relevant callback when the query completes
/// </summary>
/// <param name="query">SPARQL QUery</param>
/// <param name="rdfCallback">Callback for queries that return a Graph</param>
/// <param name="resultsCallback">Callback for queries that return a Result Set</param>
/// <param name="state">State to pass to the callback</param>
public void ProcessQuery(SparqlQuery query, GraphCallback rdfCallback, SparqlResultsCallback resultsCallback, Object state)
{
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
this._svc.Query(query.ToString(), rdfCallback, resultsCallback, state);
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
}
/// <summary>
/// Processes a SPARQL Query passing the results to the RDF or Results handler as appropriate
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="query">SPARQL Query</param>
public void ProcessQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, SparqlQuery query)
{
#if !SILVERLIGHT
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
this._svc.Query(rdfHandler, resultsHandler, query.ToString());
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
#else
throw new NotSupportedException("Synchronous remote query is not supported under Silverlight/WP7 - please use one of the alternative overload of this methods which takes a callback");
#endif
}
/// <summary>
/// Processes a SPARQL Query
/// </summary>
/// <param name="query">SPARQL Query</param>
/// <returns></returns>
public object ProcessQuery(SparqlQuery query)
{
#if !SILVERLIGHT
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
Object temp = this._svc.Query(query.ToString());
return temp;
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
}
#else
throw new NotSupportedException("Synchronous remote query is not supported under Silverlight/WP7 - please use one of the alternative overload of this methods which takes a callback");
#endif
}
public BrightstarSparqlResultsType ExecuteSparql(SparqlQuery query, IStore store, TextWriter resultsWriter)
{
try
{
EnsureValidResultFormat(query);
var dataset = new StoreSparqlDataset(store);
if (_defaultGraphUris != null)
{
dataset.SetDefaultGraph(_defaultGraphUris);
}
var queryProcessor = new BrightstarQueryProcessor(store, dataset);
var queryResult = queryProcessor.ProcessQuery(query);
if (queryResult is SparqlResultSet)
{
var sparqlResultSet = (SparqlResultSet) queryResult;
ISparqlResultsWriter sparqlResultsWriter = null;
if (_sparqlResultsFormat != null)
{
sparqlResultsWriter =
MimeTypesHelper.GetSparqlWriter(new string[] {_sparqlResultsFormat.ToString()});
}
if (sparqlResultsWriter == null)
{
throw new NoAcceptableFormatException(typeof (SparqlResultsFormat),
"No acceptable format provided for writing a SPARQL result set.");
}
sparqlResultsWriter.Save(sparqlResultSet, resultsWriter);
switch (sparqlResultSet.ResultsType)
{
case SparqlResultsType.Boolean:
return BrightstarSparqlResultsType.Boolean;
case SparqlResultsType.VariableBindings:
return BrightstarSparqlResultsType.VariableBindings;
default:
throw new BrightstarInternalException("Unrecognized SPARQL result type");
}
}
if (queryResult is IGraph)
{
var g = (IGraph) queryResult;
var rdfWriter = _rdfFormat == null
? null
: MimeTypesHelper.GetWriter(new string[] {_rdfFormat.ToString()});
if (rdfWriter == null)
{
throw new NoAcceptableFormatException(typeof (RdfFormat),
"No acceptable format provided for writing an RDF graph result.");
}
rdfWriter.Save(g, resultsWriter);
return BrightstarSparqlResultsType.Graph;
}
throw new BrightstarInternalException(
String.Format("Unexpected return type from QueryProcessor.ProcessQuery: {0}",
queryResult.GetType()));
}
catch (Exception ex)
{
Logging.LogError(BrightstarEventId.SparqlExecutionError,
"Error Executing query {0}. Cause: {1}",
query.ToString(), ex);
throw;
}
}
private SparqlResultSet ExecuteSelect(SparqlQuery query)
{
var store = _store as IInMemoryQueryableStore;
if (store != null)
{
var inMemoryQuadDataset = new InMemoryQuadDataset(store, MetaGraphUri);
var processor = new LeviathanQueryProcessor(inMemoryQuadDataset);
return (SparqlResultSet)processor.ProcessQuery(query);
}
return (SparqlResultSet)((INativelyQueryableStore)_store).ExecuteQuery(query.ToString());
}
public void SparqlPropertyPathParser()
{
//Load our test data
TripleStore store = new TripleStore();
Graph g = new Graph();
FileLoader.Load(g, "resources\\InferenceTest.ttl");
store.Add(g);
List <String> testQueries = new List <string>();
String rdfsPrefix = "PREFIX rdfs: <" + NamespaceMapper.RDFS + ">\n";
//Cardinality Paths
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf* <http://example.org/vehicles/Vehicle>}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf+ <http://example.org/vehicles/Vehicle>}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf? <http://example.org/vehicles/Vehicle>}");
//testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf{2,4} <http://example.org/vehicles/Vehicle>}");
//testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf{2,} <http://example.org/vehicles/Vehicle>}");
//testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf{,4} <http://example.org/vehicles/Vehicle>}");
//testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf{2} <http://example.org/vehicles/Vehicle>}");
//Simple Inverse Paths
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?type ^a ?entity}");
//Sequence Paths
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf / rdfs:subClassOf <http://example.org/vehicles/Vehicle>}");
//testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf{2} / rdfs:subClassOf <http://example.org/vehicles/Vehicle>}");
//testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf / rdfs:subClassOf{2} <http://example.org/vehicles/Vehicle>}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass a / rdfs:subClassOf <http://example.org/vehicles/Plane>}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?vehicle a ^ rdfs:subClassOf <http://example.org/vehicles/Plane>}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass a / ^ rdfs:subClassOf <http://example.org/vehicles/Vehicle>}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?entity a ^ a ?type}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?entity a ^ a / rdfs:subClassOf <http://example.org/vehicles/GroundVehicle>}");
//Alternative Paths
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf | a <http://example.org/vehicles/Vehicle>}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass (rdfs:subClassOf | a) | rdfs:someProperty <http://example.org/vehicles/Vehicle>}");
testQueries.Add(rdfsPrefix + "SELECT * WHERE {?subclass rdfs:subClassOf | a | rdfs:someProperty <http://example.org/vehicles/Vehicle>}");
SparqlQueryParser parser = new SparqlQueryParser();
foreach (String query in testQueries)
{
//Parse the Query and output to console
SparqlQuery q = parser.ParseFromString(query);
Console.WriteLine(q.ToString());
//Now we'll try and evaluate it (if this is possible)
try
{
Object results = store.ExecuteQuery(q);
Console.WriteLine("Evaluated OK");
TestTools.ShowResults(results);
Console.WriteLine();
}
catch (RdfQueryException queryEx)
{
Console.WriteLine("Unable to evaluate:");
Console.WriteLine(queryEx.Message);
Console.WriteLine(queryEx.StackTrace);
}
}
}
/// <summary>
/// Processes a SPARQL Query passing the results to the RDF or Results handler as appropriate
/// </summary>
/// <param name="rdfHandler">RDF Handler</param>
/// <param name="resultsHandler">Results Handler</param>
/// <param name="query">SPARQL Query</param>
public void ProcessQuery(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, SparqlQuery query)
{
query.QueryTime = -1;
query.QueryTimeTicks = -1;
query.QueryExecutionTime = null;
DateTime start = DateTime.Now;
try
{
this._svc.Query(rdfHandler, resultsHandler, query.ToString());
}
finally
{
TimeSpan elapsed = (DateTime.Now - start);
query.QueryExecutionTime = (DateTime.Now - start);
query.QueryTime = elapsed.Milliseconds;
query.QueryTimeTicks = elapsed.Ticks;
}
}
