public void SparqlAggEmptyGroupMax1() { String query = @"PREFIX ex: <http://example.com/> SELECT (MAX(?value) AS ?max) WHERE { ?x ex:p ?value } GROUP BY ?x"; SparqlQuery q = new SparqlQueryParser().ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); SparqlResultSet results = processor.ProcessQuery(q) as SparqlResultSet; Assert.NotNull(results); Assert.True(results.IsEmpty, "Results should be empty"); }
public void SparqlAggEmptyGroupCount1() { // counting no results with grouping returns no results var query = @"PREFIX : <http://example/> SELECT (count(*) AS ?C) WHERE { ?s :p ?x } GROUP BY ?s"; SparqlQuery q = new SparqlQueryParser().ParseFromString(query); var processor = new LeviathanQueryProcessor(new TripleStore()); var results = processor.ProcessQuery(q) as SparqlResultSet; Assert.NotNull(results); Assert.True(results.IsEmpty); }
private void TestQuery(IInMemoryQueryableStore store, String query, String queryName, int differences) { Console.WriteLine(queryName); SparqlQuery q = this._sparqlParser.ParseFromString(query); Console.WriteLine(q.ToAlgebra().ToString()); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(store); using (SparqlResultSet resultSet = processor.ProcessQuery(q) as SparqlResultSet) { Assert.IsNotNull(resultSet); TestTools.ShowResults(resultSet); Assert.AreEqual(differences, resultSet.Count); } Console.WriteLine(); }
private void TestBindings(ISparqlDataset data, String queryWithBindings) { LeviathanQueryProcessor processor = new LeviathanQueryProcessor(data); SparqlQuery bindingsQuery = this._parser.ParseFromString(queryWithBindings); SparqlResultSet bindingsResults = processor.ProcessQuery(bindingsQuery) as SparqlResultSet; if (bindingsResults == null) { Assert.Fail("Did not get a SPARQL Result Set for the Bindings Query"); } Console.WriteLine("Bindings Results"); TestTools.ShowResults(bindingsResults); Console.WriteLine(); Assert.IsTrue(bindingsResults.IsEmpty, "Result Set should be empty"); }
private void TestNegation(ISparqlDataset data, String queryWithNegation) { LeviathanQueryProcessor processor = new LeviathanQueryProcessor(data); SparqlQuery negQuery = this._parser.ParseFromString(queryWithNegation); SparqlResultSet negResults = processor.ProcessQuery(negQuery) as SparqlResultSet; if (negResults == null) { Assert.Fail("Did not get a SPARQL Result Set for the Negation Query"); } Console.WriteLine("Negation Results"); TestTools.ShowResults(negResults); Console.WriteLine(); Assert.IsTrue(negResults.IsEmpty, "Result Set should be empty"); }
public void SparqlServiceUsingDBPediaAndBindings() { String query = "SELECT * WHERE { SERVICE <http://dbpedia.org/sparql> { ?s a ?type } } VALUES ?s { <http://dbpedia.org/resource/Southampton> <http://dbpedia.org/resource/Ilkeston> }"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { TestTools.ShowResults(results); } else { Assert.Fail("Should have returned a SPARQL Result Set"); } }
public void SparqlConstructEmptyWhereCore407() { const String queryStr = @"CONSTRUCT { <http://s> <http://p> <http://o> . } WHERE {}"; SparqlQuery q = new SparqlQueryParser().ParseFromString(queryStr); InMemoryDataset dataset = new InMemoryDataset(); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); IGraph g = processor.ProcessQuery(q) as IGraph; Assert.NotNull(g); Assert.False(g.IsEmpty, "Graph should not be empty"); Assert.Equal(1, g.Triples.Count); }
public void SparqlQueryTimeoutDuringProductLazy() { String query = "SELECT * WHERE { ?s ?p ?o . ?x ?y ?z . ?a ?b ?c }"; SparqlQuery q = this._parser.ParseFromString(query); q.Timeout = 1; TripleStore store = new TripleStore(); Graph g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); store.Add(g); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(AsDataset(store)); Assert.Throws <RdfQueryTimeoutException>(() => { processor.ProcessQuery(q); }); }
public void SparqlServiceWithNonExistentService() { String query = "SELECT * WHERE { SERVICE <http://www.dotnetrdf.org/noSuchService> { ?s a ?type } } LIMIT 10"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); try { Object results = processor.ProcessQuery(q); Assert.Fail("Should have errored"); } catch (RdfQueryException queryEx) { Console.WriteLine("Errored as expected"); TestTools.ReportError("Query Error", queryEx); } }
public void SparqlPropertyPathEvaluationCore395ExactQuery() { IGraph g = new Graph(); g.LoadFromFile(@"resources/pp.rdf"); InMemoryDataset dataset = new InMemoryDataset(g); SparqlQuery query = new SparqlQueryParser().ParseFromFile(@"resources/pp.rq"); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); Object results = processor.ProcessQuery(query); Assert.NotNull(results); TestTools.ShowResults(results); Assert.IsType <SparqlResultSet>(results); SparqlResultSet rset = (SparqlResultSet)results; Assert.Equal(3, rset.Count); }
public void SparqlServiceUsingDBPediaAndBindings() { Skip.IfNot(TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing), "Test Config marks Remote Parsing as unavailable, test cannot be run"); String query = "SELECT * WHERE { SERVICE <http://dbpedia.org/sparql> { ?s a ?type } } VALUES ?s { <http://dbpedia.org/resource/Southampton> <http://dbpedia.org/resource/Ilkeston> }"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { TestTools.ShowResults(results); } else { Assert.True(false, "Should have returned a SPARQL Result Set"); } }
public void SparqlPropertyPathEvaluationCore441NoPath() { IGraph g = new Graph(); g.LoadFromFile(@"resources\core-441\data.ttl"); InMemoryDataset dataset = new InMemoryDataset(g); SparqlQuery query = new SparqlQueryParser().ParseFromFile(@"resources\core-441\no-path.rq"); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); Object results = processor.ProcessQuery(query); Assert.NotNull(results); TestTools.ShowResults(results); Assert.IsType <SparqlResultSet>(results); SparqlResultSet rset = (SparqlResultSet)results; Assert.Equal(1, rset.Count); Assert.Equal(g.CreateUriNode("Frame:Sheep"), rset[0]["prey"]); }
public void SparqlEvaluationMultipleOptionals2() { TripleStore store = new TripleStore(); store.LoadFromFile("resources\\multiple-options.trig"); SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery query = parser.ParseFromFile("resources\\multiple-optionals-alternate.rq"); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(store); Object results = processor.ProcessQuery(query); if (results is SparqlResultSet) { TestTools.ShowResults(results); } else { Assert.Fail("Expected a SPARQL Result Set"); } }
public void SparqlConstructFromSubqueryWithLimitCore420() { const string queryStr = @"CONSTRUCT { ?s ?p ?o . } WHERE { ?s ?p ?o . { SELECT ?s WHERE { ?s a <http://xmlns.com/foaf/0.1/Person> . } LIMIT 3 } }"; SparqlQuery q = new SparqlQueryParser().ParseFromString(queryStr); IGraph g = new Graph(); g.NamespaceMap.AddNamespace("rdf", new Uri("http://www.w3.org/1999/02/22-rdf-syntax-ns#")); g.NamespaceMap.AddNamespace("foaf", new Uri("http://xmlns.com/foaf/0.1/")); var rdfType = g.CreateUriNode("rdf:type"); var person = g.CreateUriNode("foaf:Person"); var name = g.CreateUriNode("foaf:name"); var age = g.CreateUriNode("foaf:age"); for (int i = 0; i < 3; i++) { // Create 3 statements for each instance of foaf:Person (including rdf:type statement) var s = g.CreateUriNode(new Uri("http://example.com/people/" + i)); g.Assert(new Triple(s, rdfType, person)); g.Assert(new Triple(s, name, g.CreateLiteralNode("Person " + i))); g.Assert(new Triple(s, age, g.CreateLiteralNode((20 + i).ToString(CultureInfo.InvariantCulture)))); } //ISparqlQueryProcessor processor = new ExplainQueryProcessor(new InMemoryDataset(g), ExplanationLevel.ShowAll | ExplanationLevel.AnalyseAll | ExplanationLevel.OutputToConsoleStdOut); var processor = new LeviathanQueryProcessor(new InMemoryDataset(g)); var resultGraph = processor.ProcessQuery(q) as IGraph; Assert.NotNull(resultGraph); Assert.Equal(9, resultGraph.Triples.Count); // Returns 3 rather than 9 }
public void SparqlGroupByAggregateEmptyGroup2() { String query = @"PREFIX ex: <http://example.com/> SELECT (MAX(?value) AS ?max) WHERE { ?x ex:p ?value } GROUP BY ?x"; SparqlQuery q = new SparqlQueryParser().ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); Console.WriteLine(q.ToAlgebra().ToString()); SparqlResultSet results = processor.ProcessQuery(q) as SparqlResultSet; if (results == null) { Assert.True(false, "Null results"); } Assert.False(results.IsEmpty, "Results should not be empty"); }
public void SparqlPropertyPathEvaluationCore441OneOrMorePath() { IGraph g = new Graph(); g.LoadFromFile(@"resources\core-441\data.ttl"); InMemoryDataset dataset = new InMemoryDataset(g); SparqlQuery query = new SparqlQueryParser().ParseFromFile(@"resources\core-441\plus-path.rq"); Console.WriteLine(query.ToAlgebra().ToString()); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); Object results = processor.ProcessQuery(query); Assert.NotNull(results); TestTools.ShowResults(results); Assert.IsType <SparqlResultSet>(results); SparqlResultSet rset = (SparqlResultSet)results; Assert.Equal(0, rset.Count); }
public void SparqlEvaluationGraphNonExistentUri() { String query = "SELECT * WHERE { GRAPH <http://example.org/noSuchGraph> { ?s ?p ?o } }"; TripleStore store = new TripleStore(); var processor = new LeviathanQueryProcessor(store); var parser = new SparqlQueryParser(); var q = parser.ParseFromString(query); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { TestTools.ShowResults(results); SparqlResultSet rset = (SparqlResultSet)results; Assert.True(rset.IsEmpty, "Result Set should be empty"); Assert.Equal(3, rset.Variables.Count()); } else { Assert.True(false, "Query should have returned a SPARQL Result Set"); } }
public void SparqlPropertyPathEvaluationCore441ZeroOrMorePath() { IGraph g = new Graph(); g.LoadFromFile(@"resources\core-441\data.ttl"); InMemoryDataset dataset = new InMemoryDataset(g); SparqlQuery query = new SparqlQueryParser().ParseFromFile(@"resources\core-441\star-path.rq"); Console.WriteLine(query.ToAlgebra().ToString()); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); Object results = processor.ProcessQuery(query); Assert.NotNull(results); TestTools.ShowResults(results); Assert.IsInstanceOf(typeof(SparqlResultSet), results); SparqlResultSet rset = (SparqlResultSet)results; Assert.AreEqual(1, rset.Count); Assert.AreEqual(g.CreateUriNode("Frame:Sheep"), rset[0]["prey"]); }
public void SparqlServiceUsingDBPedia() { if (!TestConfigManager.GetSettingAsBoolean(TestConfigManager.UseRemoteParsing)) { throw new SkipTestException("Test Config marks Remote Parsing as unavailable, test cannot be run"); } String query = "SELECT * WHERE { SERVICE <http://dbpedia.org/sparql> { ?s a ?type } } LIMIT 10"; SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { TestTools.ShowResults(results); } else { Assert.True(false, "Should have returned a SPARQL Result Set"); } }
public void SparqlQueryTimeout() { String query = "SELECT * WHERE { ?s ?p ?o . ?s ?p2 ?o2 . ?a ?b ?c }"; SparqlQuery q = this._parser.ParseFromString(query); q.Timeout = 1; TripleStore store = new TripleStore(); Graph g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); store.Add(g); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(AsDataset(store)); Assert.Throws <RdfQueryTimeoutException>(() => { //Try multiple times because sometimes machine load may mean we don't timeout for (int i = 0; i < 10; i++) { processor.ProcessQuery(q); } }); }
public void SparqlParallelEvaluationOptional1() { String data = @"<http://a> <http://p> <http://x> . <http://b> <http://p> <http://y> . <http://c> <http://p> <http://z> . <http://x> <http://value> ""X"" . <http://z> <http://value> ""Z"" ."; String query = "SELECT * WHERE { ?s <http://p> ?o . OPTIONAL { ?o <http://value> ?value } }"; SparqlQuery q = this._parser.ParseFromString(query); TripleStore store = new TripleStore(); StringParser.ParseDataset(store, data, new NQuadsParser()); InMemoryDataset dataset = new InMemoryDataset(store); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); Stopwatch timer = new Stopwatch(); timer.Start(); int i; for (i = 1; i <= 100000; i++) { SparqlResultSet results = processor.ProcessQuery(q) as SparqlResultSet; Assert.NotNull(results); if (results.Count != 3) { TestTools.ShowResults(results); } Assert.Equal(3, results.Count); } timer.Stop(); Console.WriteLine("Completed " + i + " Iterations OK"); Console.WriteLine("Took " + timer.Elapsed); }
public void SparqlQueryTimeoutMinimal() { Graph g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); String query = "SELECT * WHERE { ?s ?p ?o . ?x ?y ?z }"; long currTimeout = Options.QueryExecutionTimeout; try { Options.QueryExecutionTimeout = 1; SparqlQuery q = this._parser.ParseFromString(query); q.PartialResultsOnTimeout = true; TripleStore store = new TripleStore(); store.Add(g); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(AsDataset(store)); Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; Console.WriteLine("Results: " + rset.Count + " - Query Time: " + q.QueryExecutionTime); Assert.IsTrue(rset.Count < (g.Triples.Count * g.Triples.Count)); } else { Assert.Fail("Did not get a Result Set as expected"); } } finally { Options.QueryExecutionTimeout = currTimeout; } }
public void SparqlQueryTimeoutDuringProductLazy2() { String query = "ASK WHERE { ?s ?p ?o . ?x ?y ?z }"; SparqlQuery q = this._parser.ParseFromString(query); q.Timeout = 1; Console.WriteLine(q.ToAlgebra().ToString()); TripleStore store = new TripleStore(); Graph g = new Graph(); g.LoadFromEmbeddedResource("VDS.RDF.Configuration.configuration.ttl"); store.Add(g); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(AsDataset(store)); Assert.Throws <RdfQueryTimeoutException>(() => { //Try multiple times because sometimes machine load may mean we don't timeout for (int i = 0; i < 100; i++) { processor.ProcessQuery(q); } }); }
public void SparqlGroupByAggregateEmptyGroup1() { String query = @"PREFIX ex: <http://example.com/> SELECT (MAX(?value) AS ?max) WHERE { ?x ex:p ?value }"; SparqlQuery q = new SparqlQueryParser().ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(new TripleStore()); Console.WriteLine(q.ToAlgebra().ToString()); SparqlResultSet results = processor.ProcessQuery(q) as SparqlResultSet; if (results == null) { Assert.Fail("Null results"); } Assert.IsFalse(results.IsEmpty, "Results should not be empty"); Assert.AreEqual(1, results.Count, "Should be a single result"); Assert.IsTrue(results.First().All(kvp => kvp.Value == null), "Should be no bound values"); }
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 { var processor = new LeviathanQueryProcessor(store); Object results = processor.ProcessQuery(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); } } }
public void SparqlBgpEvaluation() { //Prepare the Store TripleStore store = new TripleStore(); Graph g = new Graph(); FileLoader.Load(g, "resources\\Turtle.ttl"); store.Add(g); SparqlQueryParser parser = new SparqlQueryParser(); SparqlQuery q = parser.ParseFromString(@"PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> SELECT * WHERE {?s ?p ?o . ?s rdfs:label ?label}"); var processor = new LeviathanQueryProcessor(store); Object testResult = processor.ProcessQuery(q); if (testResult is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)testResult; Console.WriteLine(rset.Count + " Results"); foreach (SparqlResult r in rset) { Console.WriteLine(r.ToString()); } Console.WriteLine(); } //Create some Triple Patterns TriplePattern t1 = new TriplePattern(new VariablePattern("?s"), new VariablePattern("?p"), new VariablePattern("?o")); TriplePattern t2 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(g.CreateUriNode("rdfs:label")), new VariablePattern("?label")); TriplePattern t3 = new TriplePattern(new VariablePattern("?x"), new VariablePattern("?y"), new VariablePattern("?z")); TriplePattern t4 = new TriplePattern(new VariablePattern("?s"), new NodeMatchPattern(g.CreateUriNode(":name")), new VariablePattern("?name")); //Build some BGPs Bgp selectNothing = new Bgp(); Bgp selectAll = new Bgp(t1); Bgp selectLabelled = new Bgp(new List <ITriplePattern>() { t1, t2 }); Bgp selectAllDisjoint = new Bgp(new List <ITriplePattern>() { t1, t3 }); Bgp selectLabels = new Bgp(t2); Bgp selectNames = new Bgp(t4); //LeftJoin selectOptionalNamed = new LeftJoin(selectAll, new Optional(selectNames)); LeftJoin selectOptionalNamed = new LeftJoin(selectAll, selectNames); Union selectAllUnion = new Union(selectAll, selectAll); Union selectAllUnion2 = new Union(selectAllUnion, selectAll); Filter selectAllUriObjects = new Filter(selectAll, new UnaryExpressionFilter(new IsUriFunction(new VariableTerm("o")))); //Test out the BGPs //Console.WriteLine("{}"); //this.ShowMultiset(selectNothing.Evaluate(new SparqlEvaluationContext(null, store))); //Console.WriteLine("{?s ?p ?o}"); //this.ShowMultiset(selectAll.Evaluate(new SparqlEvaluationContext(null, store))); //Console.WriteLine("{?s ?p ?o . ?s rdfs:label ?label}"); //SparqlEvaluationContext context = new SparqlEvaluationContext(null, store); //this.ShowMultiset(selectLabelled.Evaluate(context)); //SparqlResultSet lvnResult = new SparqlResultSet(context); //Console.WriteLine("{?s ?p ?o . ?x ?y ?z}"); //this.ShowMultiset(selectAllDisjoint.Evaluate(new SparqlEvaluationContext(null, store))); //Console.WriteLine("{?s ?p ?o . OPTIONAL {?s :name ?name}}"); //this.ShowMultiset(selectOptionalNamed.Evaluate(new SparqlEvaluationContext(null, store))); Console.WriteLine("{{?s ?p ?o} UNION {?s ?p ?o}}"); this.ShowMultiset(selectAllUnion.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store)))); Console.WriteLine("{{?s ?p ?o} UNION {?s ?p ?o} UNION {?s ?p ?o}}"); this.ShowMultiset(selectAllUnion2.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store)))); Console.WriteLine("{?s ?p ?o FILTER (ISURI(?o))}"); this.ShowMultiset(selectAllUriObjects.Evaluate(new SparqlEvaluationContext(null, new InMemoryDataset(store)))); }
private void TestProductTimeout(IGraph data, String query, bool useGlobal, int expectedResults) { Console.WriteLine("Maximum Expected Results: " + expectedResults); Console.WriteLine("Initial Global Timeout: " + Options.QueryExecutionTimeout); Console.WriteLine(); long globalOrig = Options.QueryExecutionTimeout; try { if (useGlobal) { Console.WriteLine("Global Timeout setting in use"); } else { Console.WriteLine("Per Query Timeout setting in use"); } Console.WriteLine(); TripleStore store = new TripleStore(); store.Add(data); SparqlQuery q = this._parser.ParseFromString(query); LeviathanQueryProcessor processor = new LeviathanQueryProcessor(AsDataset(store)); SparqlFormatter formatter = new SparqlFormatter(); Console.WriteLine("Query:"); Console.WriteLine(formatter.Format(q)); //Evaluate for each Timeout foreach (long t in this._timeouts) { //Set the Timeout and ask for Partial Results if (useGlobal) { Options.QueryExecutionTimeout = t; } else { q.Timeout = t; } q.PartialResultsOnTimeout = true; //Check that the reported Timeout matches the expected SparqlEvaluationContext context = new SparqlEvaluationContext(q, null); long expected; if (useGlobal) { expected = t; } else { if (Options.QueryExecutionTimeout > 0 && t <= Options.QueryExecutionTimeout) { expected = t; } else if (Options.QueryExecutionTimeout == 0) { expected = t; } else { expected = Options.QueryExecutionTimeout; } } Assert.AreEqual(expected, context.QueryTimeout, "Reported Timeout not as expected"); //Run the Query Object results = processor.ProcessQuery(q); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; Console.WriteLine("Requested Timeout: " + t + " - Actual Timeout: " + expected + "ms - Results: " + rset.Count + " - Query Time: " + q.QueryExecutionTime); Assert.IsTrue(rset.Count <= expectedResults, "Results should be <= expected"); } else { Assert.Fail("Did not get a Result Set as expected"); } } } finally { Options.QueryExecutionTimeout = globalOrig; } }
private void TestQuery(string query, bool checkGraphEquality) { EnsureTestData(); GC.WaitForPendingFinalizers(); GC.Collect(); var q = _parser.ParseFromString(query); _output.WriteLine("Query:"); _output.WriteLine(_formatter.Format(q)); _output.WriteLine(string.Empty); _output.WriteLine("Normal Algebra:"); _output.WriteLine(q.ToAlgebra().ToString()); _output.WriteLine(string.Empty); var timer = new Stopwatch(); //Evaluate normally timer.Start(); var normResults = _processor.ProcessQuery(q); timer.Stop(); _output.WriteLine("Normal Evaluation took " + timer.Elapsed); timer.Reset(); if (normResults is SparqlResultSet) { SparqlResultSet rsetNorm = (SparqlResultSet)normResults; _output.WriteLine("Normal Evaluation returned " + rsetNorm.Count + " Result(s)"); _output.WriteLine(string.Empty); //Evaluate parallelised q.AlgebraOptimisers = new IAlgebraOptimiser[] { new ParallelEvaluationOptimiser() }; _output.WriteLine("Parallel Algebra:"); _output.WriteLine(q.ToAlgebra().ToString()); _output.WriteLine(string.Empty); timer.Start(); var parResults = _processor.ProcessQuery(q); timer.Stop(); _output.WriteLine("Parallel Evaluation took " + timer.Elapsed); if (parResults is SparqlResultSet rsetPar) { _output.WriteLine("Parallel Evaluation returned " + rsetPar.Count + " Result(s)"); Assert.Equal(rsetNorm.Count, rsetPar.Count); if (checkGraphEquality) { Assert.StrictEqual(rsetNorm, rsetPar); } } else { Assert.True(false, "Query did not return a SPARQL Result Set as expected"); } } else { Assert.True(false, "Query did not return a SPARQL Result Set for normal evaluation as expected"); } }
public Object Evaluate(ISparqlDataset dataset) { LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); return(processor.ProcessQuery(this)); }
public void Evaluate(IRdfHandler rdfHandler, ISparqlResultsHandler resultsHandler, ISparqlDataset dataset) { LeviathanQueryProcessor processor = new LeviathanQueryProcessor(dataset); processor.ProcessQuery(rdfHandler, resultsHandler, this); }